Main Page   Class Hierarchy   Alphabetical List   Compound List   File List   Compound Members   File Members  

__deque_iterator Struct Template Reference

#include <stl_deque.h>

Inheritance diagram for __deque_iterator:

Inheritance graph
[legend]
Collaboration diagram for __deque_iterator:

Collaboration graph
[legend]
List of all members.

Public Types

typedef __deque_iterator<
T, T &, T *, BufSiz > 		iterator
typedef __deque_iterator<
T, const T &, const T *,
BufSiz > 		const_iterator
typedef random_access_iterator_tag iterator_category
typedef T value_type
typedef Ptr pointer
typedef Ref reference
typedef size_t size_type
typedef ptrdiff_t difference_type
typedef T ** map_pointer
typedef __deque_iterator self

Public Methods

 __deque_iterator (T *x, map_pointer y)
 __deque_iterator ()
 __deque_iterator (const iterator &x)
reference operator * () const
pointer operator-> () const
difference_type operator- (const self &x) const
self & operator++ ()
self operator++ (int)
self & operator-- ()
self operator-- (int)
self & operator+= (difference_type n)
self operator+ (difference_type n) const
self & operator-= (difference_type n)
self operator- (difference_type n) const
reference operator[] (difference_type n) const
bool operator== (const self &x) const
bool operator!= (const self &x) const
bool operator< (const self &x) const
void set_node (map_pointer new_node)

Static Public Methods

size_t buffer_size ()

Public Attributes

T * cur
T * first
T * last
map_pointer node

template<class T, class Ref, class Ptr, size_t BufSiz>
struct __deque_iterator< T, Ref, Ptr, BufSiz >

Member Typedef Documentation

template<class T, class Ref, class Ptr, size_t BufSiz>
typedef __deque_iterator<T, const T&, const T*, BufSiz> __deque_iterator::const_iterator
 

Definition at line 99 of file stl_deque.h.

template<class T, class Ref, class Ptr, size_t BufSiz>
typedef ptrdiff_t __deque_iterator::difference_type
 

Definition at line 114 of file stl_deque.h.

Referenced by __deque_iterator< T, T &, T *, BufSiz >::operator+=, __deque_iterator< T, T &, T *, BufSiz >::operator-, deque::reserve_elements_at_back, __deque_iterator< T, T &, T *, BufSiz >::set_node, and deque::swap.

template<class T, class Ref, class Ptr, size_t BufSiz>
typedef __deque_iterator<T, T&, T*, BufSiz> __deque_iterator::iterator
 

Definition at line 98 of file stl_deque.h.

template<class T, class Ref, class Ptr, size_t BufSiz>
typedef random_access_iterator_tag __deque_iterator::iterator_category
 

Definition at line 109 of file stl_deque.h.

Referenced by deque::deque.

template<class T, class Ref, class Ptr, size_t BufSiz>
typedef T** __deque_iterator::map_pointer
 

Definition at line 115 of file stl_deque.h.

template<class T, class Ref, class Ptr, size_t BufSiz>
typedef Ptr __deque_iterator::pointer
 

Definition at line 111 of file stl_deque.h.

template<class T, class Ref, class Ptr, size_t BufSiz>
typedef Ref __deque_iterator::reference
 

Definition at line 112 of file stl_deque.h.

template<class T, class Ref, class Ptr, size_t BufSiz>
typedef __deque_iterator __deque_iterator::self
 

Definition at line 117 of file stl_deque.h.

template<class T, class Ref, class Ptr, size_t BufSiz>
typedef size_t __deque_iterator::size_type
 

Definition at line 113 of file stl_deque.h.

template<class T, class Ref, class Ptr, size_t BufSiz>
typedef T __deque_iterator::value_type
 

Definition at line 110 of file stl_deque.h.

Constructor & Destructor Documentation

template<class T, class Ref, class Ptr, size_t BufSiz>
__deque_iterator< T, Ref, Ptr, BufSiz >::__deque_iterator (  T *    x,
map_pointer    y
)  [inline]
 

Definition at line 124 of file stl_deque.h. 

00125     : cur(x), first(*y), last(*y + buffer_size()), node(y) {}

template<class T, class Ref, class Ptr, size_t BufSiz>
__deque_iterator< T, Ref, Ptr, BufSiz >::__deque_iterator (    )  [inline]
 

Definition at line 126 of file stl_deque.h. 

00126 : cur(0), first(0), last(0), node(0) {}

template<class T, class Ref, class Ptr, size_t BufSiz>
__deque_iterator< T, Ref, Ptr, BufSiz >::__deque_iterator (  const iterator &    x )  [inline]
 

Definition at line 127 of file stl_deque.h. 

00128     : cur(x.cur), first(x.first), last(x.last), node(x.node) {}

Member Function Documentation

template<class T, class Ref, class Ptr, size_t BufSiz>
size_t __deque_iterator< T, Ref, Ptr, BufSiz >::buffer_size (    )  [inline, static]
 

Definition at line 100 of file stl_deque.h.

Referenced by __deque_iterator< T, T &, T *, BufSiz >::operator+=, __deque_iterator< T, T &, T *, BufSiz >::operator-, and __deque_iterator< T, T &, T *, BufSiz >::set_node. 

00100 {return __deque_buf_size(BufSiz, sizeof(T)); }

template<class T, class Ref, class Ptr, size_t BufSiz>
reference __deque_iterator< T, Ref, Ptr, BufSiz >::operator * (    )  const [inline]
 

Definition at line 130 of file stl_deque.h.

Referenced by __deque_iterator< T, T &, T *, BufSiz >::operator->. 

00130 { return *cur; }

template<class T, class Ref, class Ptr, size_t BufSiz>
bool __deque_iterator< T, Ref, Ptr, BufSiz >::operator!= (  const self &    x )  const [inline]
 

Definition at line 197 of file stl_deque.h. 

00197 { return !(*this == x); }

template<class T, class Ref, class Ptr, size_t BufSiz>
self __deque_iterator< T, Ref, Ptr, BufSiz >::operator+ (  difference_type    n )  const [inline]
 

Definition at line 182 of file stl_deque.h. 

00182                                           {
00183     self tmp = *this;
00184     return tmp += n;
00185   }

template<class T, class Ref, class Ptr, size_t BufSiz>
self __deque_iterator< T, Ref, Ptr, BufSiz >::operator++ (  int    )  [inline]
 

Definition at line 148 of file stl_deque.h. 

00148                         {
00149     self tmp = *this;
00150     ++*this;
00151     return tmp;
00152   }

template<class T, class Ref, class Ptr, size_t BufSiz>
self& __deque_iterator< T, Ref, Ptr, BufSiz >::operator++ (    )  [inline]
 

Definition at line 140 of file stl_deque.h. 

00140                      {
00141     ++cur;
00142     if (cur == last) {
00143       set_node(node + 1);
00144       cur = first;
00145     }
00146     return *this; 
00147   }

template<class T, class Ref, class Ptr, size_t BufSiz>
self& __deque_iterator< T, Ref, Ptr, BufSiz >::operator+= (  difference_type    n )  [inline]
 

Definition at line 168 of file stl_deque.h. 

00168                                       {
00169     difference_type offset = n + (cur - first);
00170     if (offset >= 0 && offset < difference_type(buffer_size()))
00171       cur += n;
00172     else {
00173       difference_type node_offset =
00174         offset > 0 ? offset / difference_type(buffer_size())
00175                    : -difference_type((-offset - 1) / buffer_size()) - 1;
00176       set_node(node + node_offset);
00177       cur = first + (offset - node_offset * difference_type(buffer_size()));
00178     }
00179     return *this;
00180   }

template<class T, class Ref, class Ptr, size_t BufSiz>
self __deque_iterator< T, Ref, Ptr, BufSiz >::operator- (  difference_type    n )  const [inline]
 

Definition at line 189 of file stl_deque.h. 

00189                                           {
00190     self tmp = *this;
00191     return tmp -= n;
00192   }

template<class T, class Ref, class Ptr, size_t BufSiz>
difference_type __deque_iterator< T, Ref, Ptr, BufSiz >::operator- (  const self &    x )  const [inline]
 

Definition at line 135 of file stl_deque.h. 

00135                                                  {
00136     return difference_type(buffer_size()) * (node - x.node - 1) +
00137       (cur - first) + (x.last - x.cur);
00138   }

template<class T, class Ref, class Ptr, size_t BufSiz>
self __deque_iterator< T, Ref, Ptr, BufSiz >::operator-- (  int    )  [inline]
 

Definition at line 162 of file stl_deque.h. 

00162                        {
00163     self tmp = *this;
00164     --*this;
00165     return tmp;
00166   }

template<class T, class Ref, class Ptr, size_t BufSiz>
self& __deque_iterator< T, Ref, Ptr, BufSiz >::operator-- (    )  [inline]
 

Definition at line 154 of file stl_deque.h. 

00154                      {
00155     if (cur == first) {
00156       set_node(node - 1);
00157       cur = last;
00158     }
00159     --cur;
00160     return *this;
00161   }

template<class T, class Ref, class Ptr, size_t BufSiz>
self& __deque_iterator< T, Ref, Ptr, BufSiz >::operator-= (  difference_type    n )  [inline]
 

Definition at line 187 of file stl_deque.h. 

00187 { return *this += -n; }

template<class T, class Ref, class Ptr, size_t BufSiz>
pointer __deque_iterator< T, Ref, Ptr, BufSiz >::operator-> (    )  const [inline]
 

Definition at line 132 of file stl_deque.h. 

00132 { return &(operator*()); }

template<class T, class Ref, class Ptr, size_t BufSiz>
bool __deque_iterator< T, Ref, Ptr, BufSiz >::operator< (  const self &    x )  const [inline]
 

Definition at line 198 of file stl_deque.h. 

00198                                       {
00199     return (node == x.node) ? (cur < x.cur) : (node < x.node);
00200   }

template<class T, class Ref, class Ptr, size_t BufSiz>
bool __deque_iterator< T, Ref, Ptr, BufSiz >::operator== (  const self &    x )  const [inline]
 

Definition at line 196 of file stl_deque.h. 

00196 { return cur == x.cur; }

template<class T, class Ref, class Ptr, size_t BufSiz>
reference __deque_iterator< T, Ref, Ptr, BufSiz >::operator[] (  difference_type    n )  const [inline]
 

Definition at line 194 of file stl_deque.h. 

00194 { return *(*this + n); }

template<class T, class Ref, class Ptr, size_t BufSiz>
void __deque_iterator< T, Ref, Ptr, BufSiz >::set_node (  map_pointer    new_node )  [inline]
 

Definition at line 202 of file stl_deque.h.

Referenced by __deque_iterator< T, T &, T *, BufSiz >::operator++, __deque_iterator< T, T &, T *, BufSiz >::operator+=, and __deque_iterator< T, T &, T *, BufSiz >::operator--. 

00202                                       {
00203     node = new_node;
00204     first = *new_node;
00205     last = first + difference_type(buffer_size());
00206   }

Member Data Documentation

template<class T, class Ref, class Ptr, size_t BufSiz>
T* __deque_iterator::cur
 

Definition at line 119 of file stl_deque.h.

Referenced by __deque_iterator< T, T &, T *, BufSiz >::operator-, __deque_iterator< T, T &, T *, BufSiz >::operator<, and __deque_iterator< T, T &, T *, BufSiz >::operator==.

template<class T, class Ref, class Ptr, size_t BufSiz>
T* __deque_iterator::first
 

Definition at line 120 of file stl_deque.h.

template<class T, class Ref, class Ptr, size_t BufSiz>
T* __deque_iterator::last
 

Definition at line 121 of file stl_deque.h.

Referenced by __deque_iterator< T, T &, T *, BufSiz >::operator-.

template<class T, class Ref, class Ptr, size_t BufSiz>
map_pointer __deque_iterator::node
 

Definition at line 122 of file stl_deque.h.

Referenced by __deque_iterator< T, T &, T *, BufSiz >::operator-, and __deque_iterator< T, T &, T *, BufSiz >::operator<.

The documentation for this struct was generated from the following file:
logo OpenMask

Documentation generated on Thu May 2 15:03:15 2002

Generated with doxygen 1.2.12 by Dimitri van Heesch ,   1997-2001