ALPS Home Libraries License Support People ALPS Web Site

PrevUpHomeNext

Class template fixed_capacity_deque

alps::fixed_capacity_deque

Synopsis

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

template<typename T, std::size_t N, typename CheckingPolicy> 
class fixed_capacity_deque {
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 fixed_capacity::deque_iterator< T, N, T &, T * >             iterator;              
  typedef fixed_capacity::deque_iterator< T, N, const T &, 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_deque();
  explicit fixed_capacity_deque(size_type, const T & = T());
  template<typename InputIterator> 
    fixed_capacity_deque(InputIterator, InputIterator);
  fixed_capacity_deque(const fixed_capacity_deque &);
  fixed_capacity_deque & operator=(const fixed_capacity_deque &);
  ~fixed_capacity_deque();

  // 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_front(const T &);
  void push_back(const T &);
  void pop_front();
  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_deque &);
  void clear();

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

  // protected member functions
  T * base();
  const T * base() const;
  T * top();
  const T * top() const;
  bool is_continuous() const;
  size_type position(size_type) 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);
  iterator insert_n(iterator, size_type, const T &);
  iterator erase_n(iterator, size_type);
  void destroy(T *);
  void destroy(T *, T *);

  // private member functions
   BOOST_STATIC_ASSERT(N, 0);
   BOOST_STATIC_CONSTANT(std::size_t, M = N+1);
};

Description

fixed_capacity_deque public construct/copy/destruct

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

fixed_capacity_deque 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_front(const T & x);
  26. void push_back(const T & x);
  27. void pop_front();
  28. void pop_back();
  29. iterator insert(iterator pos, const T & x);
  30. void insert(iterator pos, size_type n, const T & x);
  31. template<typename InputIterator> 
      void insert(iterator pos, InputIterator first, InputIterator last);
  32. iterator erase(iterator pos);
  33. iterator erase(iterator first, iterator last);
  34. void swap(fixed_capacity_deque & x);
  35. void clear();

fixed_capacity_deque public static functions

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

fixed_capacity_deque protected member functions

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

fixed_capacity_deque private member functions

  1.  BOOST_STATIC_ASSERT(N, 0);
  2.  BOOST_STATIC_CONSTANT(std::size_t, M = N+1);
Copyright © 1994, 2002-2005 Matthias Troyer, Synge Todo

PrevUpHomeNext