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