Move iterators to internal, improve doc, make unit test c++03 friendly

1 files changed, 89 insertions, 76 deletions

diff --git a/Eigen/src/Core/StlIterators.h b/Eigen/src/Core/StlIterators.h
index 04d3d3c8d..8713964bd 100644
--- a/Eigen/src/Core/StlIterators.h
+++ b/Eigen/src/Core/StlIterators.h
@@ -9,20 +9,17 @@
 
 namespace Eigen {
 
+namespace internal {
+
 template<typename XprType,typename Derived>
-class IndexedBasedStlIteratorBase
+class indexed_based_stl_iterator_base
 {
 public:
   typedef Index difference_type;
   typedef std::random_access_iterator_tag iterator_category;
 
-  IndexedBasedStlIteratorBase() : mp_xpr(0), m_index(0) {}
-  IndexedBasedStlIteratorBase(XprType& xpr, Index index) : mp_xpr(&xpr), m_index(index) {}
-
-  void swap(IndexedBasedStlIteratorBase& other) {
-    std::swap(mp_xpr,other.mp_xpr);
-    std::swap(m_index,other.m_index);
-  }
+  indexed_based_stl_iterator_base() : mp_xpr(0), m_index(0) {}
+  indexed_based_stl_iterator_base(XprType& xpr, Index index) : mp_xpr(&xpr), m_index(index) {}
 
   Derived& operator++() { ++m_index; return derived(); }
   Derived& operator--() { --m_index; return derived(); }
@@ -30,22 +27,22 @@ public:
   Derived operator++(int) { Derived prev(derived()); operator++(); return prev;}
   Derived operator--(int) { Derived prev(derived()); operator--(); return prev;}
 
-  friend Derived operator+(const IndexedBasedStlIteratorBase& a, Index b) { Derived ret(a.derived()); ret += b; return ret; }
-  friend Derived operator-(const IndexedBasedStlIteratorBase& a, Index b) { Derived ret(a.derived()); ret -= b; return ret; }
-  friend Derived operator+(Index a, const IndexedBasedStlIteratorBase& b) { Derived ret(b.derived()); ret += a; return ret; }
-  friend Derived operator-(Index a, const IndexedBasedStlIteratorBase& b) { Derived ret(b.derived()); ret -= a; return ret; }
+  friend Derived operator+(const indexed_based_stl_iterator_base& a, Index b) { Derived ret(a.derived()); ret += b; return ret; }
+  friend Derived operator-(const indexed_based_stl_iterator_base& a, Index b) { Derived ret(a.derived()); ret -= b; return ret; }
+  friend Derived operator+(Index a, const indexed_based_stl_iterator_base& b) { Derived ret(b.derived()); ret += a; return ret; }
+  friend Derived operator-(Index a, const indexed_based_stl_iterator_base& b) { Derived ret(b.derived()); ret -= a; return ret; }
   
   Derived& operator+=(Index b) { m_index += b; return derived(); }
   Derived& operator-=(Index b) { m_index -= b; return derived(); }
 
-  difference_type operator-(const IndexedBasedStlIteratorBase& other) const { eigen_assert(mp_xpr == other.mp_xpr);return m_index - other.m_index; }
+  difference_type operator-(const indexed_based_stl_iterator_base& other) const { eigen_assert(mp_xpr == other.mp_xpr);return m_index - other.m_index; }
 
-  bool operator==(const IndexedBasedStlIteratorBase& other) { eigen_assert(mp_xpr == other.mp_xpr); return m_index == other.m_index; }
-  bool operator!=(const IndexedBasedStlIteratorBase& other) { eigen_assert(mp_xpr == other.mp_xpr); return m_index != other.m_index; }
-  bool operator< (const IndexedBasedStlIteratorBase& other) { eigen_assert(mp_xpr == other.mp_xpr); return m_index <  other.m_index; }
-  bool operator<=(const IndexedBasedStlIteratorBase& other) { eigen_assert(mp_xpr == other.mp_xpr); return m_index <= other.m_index; }
-  bool operator> (const IndexedBasedStlIteratorBase& other) { eigen_assert(mp_xpr == other.mp_xpr); return m_index >  other.m_index; }
-  bool operator>=(const IndexedBasedStlIteratorBase& other) { eigen_assert(mp_xpr == other.mp_xpr); return m_index >= other.m_index; }
+  bool operator==(const indexed_based_stl_iterator_base& other) { eigen_assert(mp_xpr == other.mp_xpr); return m_index == other.m_index; }
+  bool operator!=(const indexed_based_stl_iterator_base& other) { eigen_assert(mp_xpr == other.mp_xpr); return m_index != other.m_index; }
+  bool operator< (const indexed_based_stl_iterator_base& other) { eigen_assert(mp_xpr == other.mp_xpr); return m_index <  other.m_index; }
+  bool operator<=(const indexed_based_stl_iterator_base& other) { eigen_assert(mp_xpr == other.mp_xpr); return m_index <= other.m_index; }
+  bool operator> (const indexed_based_stl_iterator_base& other) { eigen_assert(mp_xpr == other.mp_xpr); return m_index >  other.m_index; }
+  bool operator>=(const indexed_based_stl_iterator_base& other) { eigen_assert(mp_xpr == other.mp_xpr); return m_index >= other.m_index; }
 
 protected:
 
@@ -57,7 +54,7 @@ protected:
 };
 
 template<typename XprType>
-class PointerBasedStlIterator
+class pointer_based_stl_iterator
 {
   enum { is_lvalue  = internal::is_lvalue<XprType>::value };
 public:
@@ -67,8 +64,8 @@ public:
   typedef typename internal::conditional<bool(is_lvalue), value_type*, const value_type*>::type pointer;
   typedef typename internal::conditional<bool(is_lvalue), value_type&, const value_type&>::type reference;
 
-  PointerBasedStlIterator() : m_ptr(0) {}
-  PointerBasedStlIterator(XprType& xpr, Index index) : m_incr(xpr.innerStride())
+  pointer_based_stl_iterator() : m_ptr(0) {}
+  pointer_based_stl_iterator(XprType& xpr, Index index) : m_incr(xpr.innerStride())
   {
     m_ptr = xpr.data() + index * m_incr.value();
   }
@@ -77,30 +74,30 @@ public:
   reference operator[](Index i) const { return *(m_ptr+i*m_incr.value()); }
   pointer   operator->()        const { return m_ptr;    }
 
-  PointerBasedStlIterator& operator++() { m_ptr += m_incr.value(); return *this; }
-  PointerBasedStlIterator& operator--() { m_ptr -= m_incr.value(); return *this; }
+  pointer_based_stl_iterator& operator++() { m_ptr += m_incr.value(); return *this; }
+  pointer_based_stl_iterator& operator--() { m_ptr -= m_incr.value(); return *this; }
 
-  PointerBasedStlIterator operator++(int) { PointerBasedStlIterator prev(*this); operator++(); return prev;}
-  PointerBasedStlIterator operator--(int) { PointerBasedStlIterator prev(*this); operator--(); return prev;}
+  pointer_based_stl_iterator operator++(int) { pointer_based_stl_iterator prev(*this); operator++(); return prev;}
+  pointer_based_stl_iterator operator--(int) { pointer_based_stl_iterator prev(*this); operator--(); return prev;}
 
-  friend PointerBasedStlIterator operator+(const PointerBasedStlIterator& a, Index b) { PointerBasedStlIterator ret(a); ret += b; return ret; }
-  friend PointerBasedStlIterator operator-(const PointerBasedStlIterator& a, Index b) { PointerBasedStlIterator ret(a); ret -= b; return ret; }
-  friend PointerBasedStlIterator operator+(Index a, const PointerBasedStlIterator& b) { PointerBasedStlIterator ret(b); ret += a; return ret; }
-  friend PointerBasedStlIterator operator-(Index a, const PointerBasedStlIterator& b) { PointerBasedStlIterator ret(b); ret -= a; return ret; }
+  friend pointer_based_stl_iterator operator+(const pointer_based_stl_iterator& a, Index b) { pointer_based_stl_iterator ret(a); ret += b; return ret; }
+  friend pointer_based_stl_iterator operator-(const pointer_based_stl_iterator& a, Index b) { pointer_based_stl_iterator ret(a); ret -= b; return ret; }
+  friend pointer_based_stl_iterator operator+(Index a, const pointer_based_stl_iterator& b) { pointer_based_stl_iterator ret(b); ret += a; return ret; }
+  friend pointer_based_stl_iterator operator-(Index a, const pointer_based_stl_iterator& b) { pointer_based_stl_iterator ret(b); ret -= a; return ret; }
   
-  PointerBasedStlIterator& operator+=(Index b) { m_ptr += b*m_incr.value(); return *this; }
-  PointerBasedStlIterator& operator-=(Index b) { m_ptr -= b*m_incr.value(); return *this; }
+  pointer_based_stl_iterator& operator+=(Index b) { m_ptr += b*m_incr.value(); return *this; }
+  pointer_based_stl_iterator& operator-=(Index b) { m_ptr -= b*m_incr.value(); return *this; }
 
-  difference_type operator-(const PointerBasedStlIterator& other) const {
+  difference_type operator-(const pointer_based_stl_iterator& other) const {
     return (m_ptr - other.m_ptr)/m_incr.value();
   }
 
-  bool operator==(const PointerBasedStlIterator& other) { return m_ptr == other.m_ptr; }
-  bool operator!=(const PointerBasedStlIterator& other) { return m_ptr != other.m_ptr; }
-  bool operator< (const PointerBasedStlIterator& other) { return m_ptr <  other.m_ptr; }
-  bool operator<=(const PointerBasedStlIterator& other) { return m_ptr <= other.m_ptr; }
-  bool operator> (const PointerBasedStlIterator& other) { return m_ptr >  other.m_ptr; }
-  bool operator>=(const PointerBasedStlIterator& other) { return m_ptr >= other.m_ptr; }
+  bool operator==(const pointer_based_stl_iterator& other) { return m_ptr == other.m_ptr; }
+  bool operator!=(const pointer_based_stl_iterator& other) { return m_ptr != other.m_ptr; }
+  bool operator< (const pointer_based_stl_iterator& other) { return m_ptr <  other.m_ptr; }
+  bool operator<=(const pointer_based_stl_iterator& other) { return m_ptr <= other.m_ptr; }
+  bool operator> (const pointer_based_stl_iterator& other) { return m_ptr >  other.m_ptr; }
+  bool operator>=(const pointer_based_stl_iterator& other) { return m_ptr >= other.m_ptr; }
 
 protected:
 
@@ -109,7 +106,7 @@ protected:
 };
 
 template<typename XprType>
-class DenseStlIterator : public IndexedBasedStlIteratorBase<XprType, DenseStlIterator<XprType> >
+class generic_randaccess_stl_iterator : public indexed_based_stl_iterator_base<XprType, generic_randaccess_stl_iterator<XprType> >
 {
 public:
   typedef typename XprType::Scalar value_type;
@@ -121,7 +118,7 @@ protected:
     is_lvalue  = internal::is_lvalue<XprType>::value
   };
 
-  typedef IndexedBasedStlIteratorBase<XprType,DenseStlIterator> Base;
+  typedef indexed_based_stl_iterator_base<XprType,generic_randaccess_stl_iterator> Base;
   using Base::m_index;
   using Base::mp_xpr;
 
@@ -135,19 +132,48 @@ public:
   typedef typename internal::conditional<bool(is_lvalue), value_type *, const value_type *>::type pointer;
   typedef typename internal::conditional<bool(is_lvalue), value_type&, read_only_ref_t>::type reference;
   
-  DenseStlIterator() : Base() {}
-  DenseStlIterator(XprType& xpr, Index index) : Base(xpr,index) {}
+  generic_randaccess_stl_iterator() : Base() {}
+  generic_randaccess_stl_iterator(XprType& xpr, Index index) : Base(xpr,index) {}
 
   reference operator*()         const { return   (*mp_xpr)(m_index);   }
   reference operator[](Index i) const { return   (*mp_xpr)(m_index+i); }
   pointer   operator->()        const { return &((*mp_xpr)(m_index)); }
 };
 
-template<typename XprType,typename Derived>
-void swap(IndexedBasedStlIteratorBase<XprType,Derived>& a, IndexedBasedStlIteratorBase<XprType,Derived>& b) {
-  a.swap(b);
-}
+template<typename XprType, DirectionType Direction>
+class subvector_stl_iterator : public indexed_based_stl_iterator_base<XprType, subvector_stl_iterator<XprType,Direction> >
+{
+protected:
+
+  enum { is_lvalue  = internal::is_lvalue<XprType>::value };
+
+  typedef indexed_based_stl_iterator_base<XprType,subvector_stl_iterator> Base;
+  using Base::m_index;
+  using Base::mp_xpr;
+
+  typedef typename internal::conditional<Direction==Vertical,typename XprType::ColXpr,typename XprType::RowXpr>::type SubVectorType;
+  typedef typename internal::conditional<Direction==Vertical,typename XprType::ConstColXpr,typename XprType::ConstRowXpr>::type ConstSubVectorType;
+
+public:
+  typedef typename internal::conditional<bool(is_lvalue), SubVectorType, ConstSubVectorType>::type value_type;
+  typedef value_type* pointer;
+  typedef value_type  reference;
+  
+  subvector_stl_iterator() : Base() {}
+  subvector_stl_iterator(XprType& xpr, Index index) : Base(xpr,index) {}
+
+  reference operator*()         const { return   (*mp_xpr).template subVector<Direction>(m_index);   }
+  reference operator[](Index i) const { return   (*mp_xpr).template subVector<Direction>(m_index+i); }
+  pointer   operator->()        const { return &((*mp_xpr).template subVector<Direction>(m_index)); }
+};
+
+} // namespace internal
 
+
+/** returns an iterator to the first element of the 1D vector or array
+  * \only_for_vectors
+  * \sa end(), cbegin()
+  */
 template<typename Derived>
 inline typename DenseBase<Derived>::iterator DenseBase<Derived>::begin()
 {
@@ -155,12 +181,17 @@ inline typename DenseBase<Derived>::iterator DenseBase<Derived>::begin()
   return iterator(derived(), 0);
 }
 
+/** const version of begin() */
 template<typename Derived>
 inline typename DenseBase<Derived>::const_iterator DenseBase<Derived>::begin() const
 {
   return cbegin();
 }
 
+/** returns a read-only const_iterator to the first element of the 1D vector or array
+  * \only_for_vectors
+  * \sa cend(), begin()
+  */
 template<typename Derived>
 inline typename DenseBase<Derived>::const_iterator DenseBase<Derived>::cbegin() const
 {
@@ -168,6 +199,10 @@ inline typename DenseBase<Derived>::const_iterator DenseBase<Derived>::cbegin()
   return const_iterator(derived(), 0);
 }
 
+/** returns an iterator to the element following the last element of the 1D vector or array
+  * \only_for_vectors
+  * \sa begin(), cend()
+  */
 template<typename Derived>
 inline typename DenseBase<Derived>::iterator DenseBase<Derived>::end()
 {
@@ -175,12 +210,17 @@ inline typename DenseBase<Derived>::iterator DenseBase<Derived>::end()
   return iterator(derived(), size());
 }
 
+/** const version of end() */
 template<typename Derived>
 inline typename DenseBase<Derived>::const_iterator DenseBase<Derived>::end() const
 {
   return cend();
 }
 
+/** returns a read-only const_iterator to the element following the last element of the 1D vector or array
+  * \only_for_vectors
+  * \sa begin(), cend()
+  */
 template<typename Derived>
 inline typename DenseBase<Derived>::const_iterator DenseBase<Derived>::cend() const
 {
@@ -189,38 +229,11 @@ inline typename DenseBase<Derived>::const_iterator DenseBase<Derived>::cend() co
 }
 
 template<typename XprType, DirectionType Direction>
-class SubVectorStlIterator : public IndexedBasedStlIteratorBase<XprType, SubVectorStlIterator<XprType,Direction> >
-{
-protected:
-
-  enum { is_lvalue  = internal::is_lvalue<XprType>::value };
-
-  typedef IndexedBasedStlIteratorBase<XprType,SubVectorStlIterator> Base;
-  using Base::m_index;
-  using Base::mp_xpr;
-
-  typedef typename internal::conditional<Direction==Vertical,typename XprType::ColXpr,typename XprType::RowXpr>::type SubVectorType;
-  typedef typename internal::conditional<Direction==Vertical,typename XprType::ConstColXpr,typename XprType::ConstRowXpr>::type ConstSubVectorType;
-
-public:
-  typedef typename internal::conditional<bool(is_lvalue), SubVectorType, ConstSubVectorType>::type value_type;
-  typedef value_type* pointer;
-  typedef value_type  reference;
-  
-  SubVectorStlIterator() : Base() {}
-  SubVectorStlIterator(XprType& xpr, Index index) : Base(xpr,index) {}
-
-  reference operator*()         const { return   (*mp_xpr).template subVector<Direction>(m_index);   }
-  reference operator[](Index i) const { return   (*mp_xpr).template subVector<Direction>(m_index+i); }
-  pointer   operator->()        const { return &((*mp_xpr).template subVector<Direction>(m_index)); }
-};
-
-template<typename XprType, DirectionType Direction>
 class SubVectorsProxy
 {
 public:
-  typedef SubVectorStlIterator<XprType,       Direction> iterator;
-  typedef SubVectorStlIterator<const XprType, Direction> const_iterator;
+  typedef internal::subvector_stl_iterator<XprType,       Direction> iterator;
+  typedef internal::subvector_stl_iterator<const XprType, Direction> const_iterator;
 
   SubVectorsProxy(XprType& xpr) : m_xpr(xpr) {}