|  | Home | Libraries | People | FAQ | More | 
        The iterator_adaptor class
        template adapts some Base
        _ type to create a new iterator. Instantiations of iterator_adaptor are derived from a corresponding
        instantiation of iterator_facade
        and implement the core behaviors in terms of the Base
        type. In essence, iterator_adaptor
        merely forwards all operations to an instance of the Base
        type, which it stores as a member.
      
        .. The term "Base" here does not refer to a
        base class and is not meant to imply the use of derivation. We have followed
        the lead of the standard library, which provides a base() function to access
        the underlying iterator object of a reverse_iterator
        adaptor.
      
        The user of iterator_adaptor
        creates a class derived from an instantiation of iterator_adaptor
        and then selectively redefines some of the core member functions described
        in the iterator_facade core
        requirements table. The Base
        type need not meet the full requirements for an iterator; it need only support
        the operations used by the core interface functions of iterator_adaptor
        that have not been redefined in the user's derived class.
      
        Several of the template parameters of iterator_adaptor
        default to use_default. This
        allows the user to make use of a default parameter even when she wants to
        specify a parameter later in the parameter list. Also, the defaults for the
        corresponding associated types are somewhat complicated, so metaprogramming
        is required to compute them, and use_default
        can help to simplify the implementation. Finally, the identity of the use_default type is not left unspecified
        because specification helps to highlight that the Reference
        template parameter may not always be identical to the iterator's reference type, and will keep users from
        making mistakes based on that assumption.
      
template < class Derived , class Base , class Value = use_default , class CategoryOrTraversal = use_default , class Reference = use_default , class Difference = use_default > class iterator_adaptor : public iterator_facade<Derived, *V'*, *C'*, *R'*, *D'*> // see details { friend class iterator_core_access; public: iterator_adaptor(); explicit iterator_adaptor(Base const& iter); typedef Base base_type; Base const& base() const; protected: typedef iterator_adaptor iterator_adaptor\_; Base const& base_reference() const; Base& base_reference(); private: // Core iterator interface for iterator_facade. typename iterator_adaptor::reference dereference() const; template < class OtherDerived, class OtherIterator, class V, class C, class R, class D > bool equal(iterator_adaptor<OtherDerived, OtherIterator, V, C, R, D> const& x) const; void advance(typename iterator_adaptor::difference_type n); void increment(); void decrement(); template < class OtherDerived, class OtherIterator, class V, class C, class R, class D > typename iterator_adaptor::difference_type distance_to( iterator_adaptor<OtherDerived, OtherIterator, V, C, R, D> const& y) const; private: Base m_iterator; // exposition only };
__ base_parameters_
.. _requirements:
          static_cast<Derived*>(iterator_adaptor*)
          shall be well-formed. The Base
          argument shall be Assignable and Copy Constructible.
        
.. _base_parameters:
          The V', C',
          R', and D'
          parameters of the iterator_facade
          used as a base class in the summary of iterator_adaptor
          above are defined as follows:
        
V' = if (Value is use_default) return iterator_traits<Base>::value_type else return Value C' = if (CategoryOrTraversal is use_default) return iterator_traversal<Base>::type else return CategoryOrTraversal R' = if (Reference is use_default) if (Value is use_default) return iterator_traits<Base>::reference else return Value& else return Reference D' = if (Difference is use_default) return iterator_traits<Base>::difference_type else return Difference
iterator_adaptor();
          Requires: The Base
          type must be Default Constructible.
 Returns:
          An instance of iterator_adaptor
          with m_iterator default
          constructed.
        
explicit iterator_adaptor(Base const& iter);
          Returns: An instance of iterator_adaptor with m_iterator
          copy constructed from iter.
        
Base const& base() const;
          Returns: m_iterator
        
Base const& base_reference() const;
          Returns: A const reference to m_iterator.
        
Base& base_reference();
          Returns: A non-const reference to m_iterator.
        
typename iterator_adaptor::reference dereference() const;
          Returns: *m_iterator
        
template < class OtherDerived, class OtherIterator, class V, class C, class R, class D > bool equal(iterator_adaptor<OtherDerived, OtherIterator, V, C, R, D> const& x) const;
          Returns: m_iterator
          == x.base()
        
void advance(typename iterator_adaptor::difference_type n);
          Effects: m_iterator
          += n;
        
void increment();
          Effects: ++m_iterator;
        
void decrement();
          Effects: --m_iterator;
        
template < class OtherDerived, class OtherIterator, class V, class C, class R, class D > typename iterator_adaptor::difference_type distance_to( iterator_adaptor<OtherDerived, OtherIterator, V, C, R, D> const& y) const;
          Returns: y.base() - m_iterator