ALPS Home Libraries License Support People ALPS Web Site

PrevUpHomeNext

Class template fixed_capacity_vector

alps::fixed_capacity_vector

Synopsis

// In header: <alps/fixed_capacity_vector.h>

template<typename T, std::size_t N, typename CheckingPolicy> 
class fixed_capacity_vector {
public:
  // types
  typedef std::size_t                             size_type;             
  typedef std::ptrdiff_t                          difference_type;       
  typedef T                                       value_type;            
  typedef T &                                     reference;             
  typedef const T &                               const_reference;       
  typedef T *                                     iterator;              
  typedef const T *                               const_iterator;        
  typedef std::reverse_iterator< iterator >       reverse_iterator;      
  typedef std::reverse_iterator< const_iterator > const_reverse_iterator;

  // member classes/structs/unions
  template<bool B> 
  struct bool_type {
  };

  // construct/copy/destruct
  fixed_capacity_vector();
  fixed_capacity_vector(size_type, const T & = T());
  template<typename InputIterator> 
    fixed_capacity_vector(InputIterator, InputIterator);
  fixed_capacity_vector(const fixed_capacity_vector &);
  fixed_capacity_vector& operator=(const fixed_capacity_vector &);
  ~fixed_capacity_vector();

  // public member functions
   BOOST_STATIC_CONSTANT(size_type, static_max_size = N);
  void assign(const T &);
  void assign(size_type, const T &);
  template<typename InputIterator> void assign(InputIterator, InputIterator);
  iterator begin();
  const_iterator begin() const;
  iterator end();
  const_iterator end() const;
  reverse_iterator rbegin();
  const_reverse_iterator rbegin() const;
  reverse_iterator rend();
  const_reverse_iterator rend() const;
  size_type size() const;
  void resize(size_type, const T & = T());
  bool empty() const;
  void reserve(size_type) const;
  reference operator[](size_type);
  const_reference operator[](size_type) const;
  reference at(size_type);
  const_reference at(size_type) const;
  reference front();
  const_reference front() const;
  reference back();
  const_reference back() const;
  void push_back(const T &);
  void pop_back();
  iterator insert(iterator, const T &);
  void insert(iterator, size_type, const T &);
  template<typename InputIterator> 
    void insert(iterator, InputIterator, InputIterator);
  iterator erase(iterator);
  iterator erase(iterator, iterator);
  void swap(fixed_capacity_vector &);
  void clear();
  const T * data() const;

  // public static functions
  static size_type max_size();
  static size_type capacity();

  // protected member functions
  T * base();
  const T * base() const;
  template<typename U> 
    void insert_dispatch(iterator, size_type, U, bool_type< true >);
  template<typename InputIterator> 
    void insert_dispatch(iterator, InputIterator, InputIterator, 
                         bool_type< false >);
  template<typename InputIterator> 
    void insert_dispatch(iterator, InputIterator, InputIterator, 
                         std::random_access_iterator_tag);
  template<typename InputIterator> 
    void insert_dispatch(iterator, InputIterator, InputIterator, 
                         std::input_iterator_tag);
  void insert_n(T *, size_type, const T &);
  void erase_n(T *, size_type);
  void destroy(T *);
  void destroy(T *, T *);

  // private member functions
   BOOST_STATIC_ASSERT(N, 0);
};

Description

fixed_capacity_vector public construct/copy/destruct

  1. fixed_capacity_vector();
  2. fixed_capacity_vector(size_type n, const T & x = T());
  3. template<typename InputIterator> 
      fixed_capacity_vector(InputIterator first, InputIterator last);
  4. fixed_capacity_vector(const fixed_capacity_vector & x);
  5. fixed_capacity_vector& operator=(const fixed_capacity_vector & x);
  6. ~fixed_capacity_vector();

fixed_capacity_vector public member functions

  1.  BOOST_STATIC_CONSTANT(size_type, static_max_size = N);
  2. void assign(const T & x);
  3. void assign(size_type n, const T & x);
  4. template<typename InputIterator> 
      void assign(InputIterator first, InputIterator last);
  5. iterator begin();
  6. const_iterator begin() const;
  7. iterator end();
  8. const_iterator end() const;
  9. reverse_iterator rbegin();
  10. const_reverse_iterator rbegin() const;
  11. reverse_iterator rend();
  12. const_reverse_iterator rend() const;
  13. size_type size() const;
  14. void resize(size_type n, const T & c = T());
  15. bool empty() const;
  16. void reserve(size_type n) const;
  17. reference operator[](size_type i);
  18. const_reference operator[](size_type i) const;
  19. reference at(size_type i);
  20. const_reference at(size_type i) const;
  21. reference front();
  22. const_reference front() const;
  23. reference back();
  24. const_reference back() const;
  25. void push_back(const T & x);
  26. void pop_back();
  27. iterator insert(iterator pos, const T & x);
  28. void insert(iterator pos, size_type n, const T & x);
  29. template<typename InputIterator> 
      void insert(iterator pos, InputIterator first, InputIterator last);
  30. iterator erase(iterator pos);
  31. iterator erase(iterator first, iterator last);
  32. void swap(fixed_capacity_vector & x);
  33. void clear();
  34. const T * data() const;

fixed_capacity_vector public static functions

  1. static size_type max_size();
  2. static size_type capacity();

fixed_capacity_vector protected member functions

  1. T * base();
  2. const T * base() const;
  3. template<typename U> 
      void insert_dispatch(iterator pos, size_type n, U x, bool_type< true >);
  4. template<typename InputIterator> 
      void insert_dispatch(iterator pos, InputIterator first, InputIterator last, 
                           bool_type< false >);
  5. template<typename InputIterator> 
      void insert_dispatch(iterator pos, InputIterator first, InputIterator last, 
                           std::random_access_iterator_tag);
  6. template<typename InputIterator> 
      void insert_dispatch(iterator pos, InputIterator first, InputIterator last, 
                           std::input_iterator_tag);
  7. void insert_n(T * pos, size_type n, const T & x);
  8. void erase_n(T * pos, size_type n);
  9. void destroy(T * pos);
  10. void destroy(T * first, T * last);

fixed_capacity_vector private member functions

  1.  BOOST_STATIC_ASSERT(N, 0);
Copyright © 1994, 2002-2005 Matthias Troyer, Synge Todo

PrevUpHomeNext