|  | Home | Libraries | People | FAQ | More | 
template<typename IteratorTuple> class zip_iterator { public: typedef /* see below */ reference; typedef reference value_type; typedef value_type* pointer; typedef /* see below */ difference_type; typedef /* see below */ iterator_category; zip_iterator(); zip_iterator(IteratorTuple iterator_tuple); template<typename OtherIteratorTuple> zip_iterator( const zip_iterator<OtherIteratorTuple>& other , typename enable_if_convertible< OtherIteratorTuple , IteratorTuple>::type* = 0 // exposition only ); const IteratorTuple& get_iterator_tuple() const; private: IteratorTuple m_iterator_tuple; // exposition only }; template<typename IteratorTuple> zip_iterator<IteratorTuple> make_zip_iterator(IteratorTuple t);
          The reference member of
          zip_iterator is the type
          of the tuple made of the reference types of the iterator types in the
          IteratorTuple argument.
        
          The difference_type member
          of zip_iterator is the
          difference_type of the
          first of the iterator types in the IteratorTuple
          argument.
        
          The iterator_category member
          of zip_iterator is convertible
          to the minimum of the traversal categories of the iterator types in the
          IteratorTuple argument.
          For example, if the zip_iterator
          holds only vector iterators, then iterator_category
          is convertible to boost::random_access_traversal_tag.
          If you add a list iterator, then iterator_category
          will be convertible to boost::bidirectional_traversal_tag,
          but no longer to boost::random_access_traversal_tag.
        
          All iterator types in the argument IteratorTuple
          shall model Readable Iterator.
        
          The resulting zip_iterator
          models Readable Iterator.
        
          The fact that the zip_iterator
          models only Readable Iterator does not prevent you from modifying the values
          that the individual iterators point to. The tuple returned by the zip_iterator's operator* is a tuple constructed from the reference
          types of the individual iterators, not their value types. For example,
          if zip_it is a zip_iterator whose first member iterator
          is an std::vector<double>::iterator, then the following line will
          modify the value which the first member iterator of zip_it
          currently points to:
        
zip_it->get<0>() = 42.0;
          Consider the set of standard traversal concepts obtained by taking the
          most refined standard traversal concept modeled by each individual iterator
          type in the IteratorTuple
          argument.The zip_iterator
          models the least refined standard traversal concept in this set.
        
          zip_iterator<IteratorTuple1>
          is interoperable with zip_iterator<IteratorTuple2> if and only if IteratorTuple1
          is interoperable with IteratorTuple2.
        
          In addition to the operations required by the concepts modeled by zip_iterator, zip_iterator
          provides the following operations.
        
zip_iterator();
          Returns: An instance of zip_iterator with m_iterator_tuple
          default constructed.
        
zip_iterator(IteratorTuple iterator_tuple);
          Returns: An instance of zip_iterator with m_iterator_tuple
          initialized to iterator_tuple.
        
template<typename OtherIteratorTuple> zip_iterator( const zip_iterator<OtherIteratorTuple>& other , typename enable_if_convertible< OtherIteratorTuple , IteratorTuple>::type* = 0 // exposition only );
          Returns: An instance of zip_iterator that is a copy of other.
 Requires:
          OtherIteratorTuple is implicitly
          convertible to IteratorTuple.
        
const IteratorTuple& get_iterator_tuple() const;
          Returns: m_iterator_tuple
        
reference operator*() const;
          Returns: A tuple consisting of the results
          of dereferencing all iterators in m_iterator_tuple.
        
zip_iterator& operator++();
          Effects: Increments each iterator in
          m_iterator_tuple.
          Returns: *this
        
zip_iterator& operator--();
          Effects: Decrements each iterator in
          m_iterator_tuple.
          Returns: *this
        
template<typename IteratorTuple> zip_iterator<IteratorTuple> make_zip_iterator(IteratorTuple t);
          Returns: An instance of zip_iterator<IteratorTuple>
          with m_iterator_tuple initialized
          to t.