Introduction

<boost/python/sequence.hpp> provides different C++ iterators to iterate over Python sequences.
The iterators are all of type forward_iterator and can be used with all algorithm accepting
forward iterators.
There main difference lies in the type returned by the dereferencing operator, operator*().

Provided iterators are:
   reference_iterator
      Iterator of type reference_iterator return a non const reference to the
      sequence value under the iterator
   const_reference_iterator
      Iterator of type reference_iterator return a const reference to the
      sequence value under the iterator
   value_iterator
      Iterator of type value_iterator return a copy of the
      sequence value under the iterator
   object_iterator
      Iterator of type reference_iterator return a boost::python::object of the
      sequence value under the iterator

      
Classes

namespace boost { namespace python { namespace sequence {

template <typename T>
class reference_iterator               // A forward iterator over a mutable sequence with
   : public detail::iterator_base      // dereferencing operator: value_type& operator*() 
   , public std::iterator<std::forward_iterator_tag, T>
{
   typedef T value_type;
   
public:
   reference_iterator(); //  Default constructor acting as end iterator

   reference_iterator(boost::python::object); //  Constructor with a sequence, begin iterator
   
   reference_iterator(const reference_iterator&);

   ~reference_iterator();

   reference_iterator& operator=(const reference_iterator&);

   value_type& operator*();

   value_type* operator->();

   reference_iterator& operator++();

   reference_iterator  operator++(int);
};
}}

namespace boost { namespace python { namespace sequence {

template <typename T>
class const_reference_iterator      // A forward iterator over a immutable sequence with
   : public detail::iterator_base   // dereferencing operator: const value_type& operator*() 
   , public std::iterator<std::forward_iterator_tag, T>
{
private:
   typedef T value_type;
   
public:
   const_reference_iterator() ;//  Default constructor acting as end iterator
      
   const_reference_iterator(object); //  Constructor with a sequence, begin iterator
   
   const_reference_iterator(const const_reference_iterator&);

   ~const_reference_iterator();

   const_reference_iterator& operator=(const const_reference_iterator&);

   const value_type& operator*() const;

   const value_type* operator->() const;

   const_reference_iterator& operator++();
};
}}

namespace boost { namespace python { namespace sequence {

template <typename T>
class value_iterator                // A forward iterator over an immutable sequence with
   : public detail::iterator_base   // dereferencing operator: value_type operator*() 
   , public std::iterator<std::forward_iterator_tag, T>
{
private:
   typedef T value_type;
   
public:
   value_iterator() //  Default constructor acting as end iterator
      
   value_iterator(boost::python::object obj) //  Constructor with a sequence, begin iterator

   value_iterator(const value_iterator& other)

   ~value_iterator()

   value_iterator& operator=(const value_iterator& other)

   value_type operator*()

//   value_type* operator->()    // There is no operator-> for value_type as it would return the address of a temporary

   value_iterator& operator++()
};
}}


namespace boost { namespace python { namespace sequence {

template <class T>
class begin    // Inspired (copied!) from extract
{
private:
   typedef T iter_type;
   
public:
   begin (boost::python::object const& obj) : m_iter(iter_type(obj))

   operator iter_type() const
};

template <class T>
class end
{
private:
   typedef T iter_type;
   
public:
   end () : m_iter(iter_type())

   operator iter_type() const
};

}}} // namespace boost::python::sequence