iterator.hpp

CGAL is a collaborative effort of several sites in Europe and Israel. The goal is to make the most i

        // Comparison
        BOOST_UBLAS_INLINE
        bool operator < (const reverse_iterator_base2 &it) const {
            return ! (this->base () < it.base ());
        }
        BOOST_UBLAS_INLINE
        bool operator <= (const reverse_iterator_base2 &it) const {
            return ! (this->base () <= it.base ());
        }
        BOOST_UBLAS_INLINE
        bool operator >= (const reverse_iterator_base2 &it) const {
            return ! (this->base () >= it.base ());
        }
        BOOST_UBLAS_INLINE
        bool operator > (const reverse_iterator_base2 &it) const {
            return ! (this->base () > it.base ());
        }
    };

    template<class I, class T, class R>
    BOOST_UBLAS_INLINE
    reverse_iterator_base2<I, T, R> operator + (const reverse_iterator_base2<I, T, R> &it, std::ptrdiff_t n) {
        reverse_iterator_base2<I, T, R> tmp (it);
        return tmp += n;
    }
    template<class I, class T, class R>
    BOOST_UBLAS_INLINE
    reverse_iterator_base2<I, T, R> operator + (std::ptrdiff_t n, const reverse_iterator_base2<I, T, R> &it) {
        reverse_iterator_base2<I, T, R> tmp (it);
        return tmp += n;
    }
    template<class I, class T, class R>
    BOOST_UBLAS_INLINE
    reverse_iterator_base2<I, T, R> operator - (const reverse_iterator_base2<I, T, R> &it, std::ptrdiff_t n) {
        reverse_iterator_base2<I, T, R> tmp (it);
        return tmp -= n;
    }
    template<class I, class T, class R>
    BOOST_UBLAS_INLINE
    std::ptrdiff_t operator - (const reverse_iterator_base2<I, T, R> &it1, const reverse_iterator_base2<I, T, R> &it2) {
        return it2.base () - it1.base ();
    }

#else

  /** \brief Base class of all reverse iterators. (non-MSVC version)
   *
   * \param I the derived iterator type
   * \param T the value type
   * \param R the reference type
   *
   * The reverse iterator implements a bidirectional iterator
   * reversing the elements of the underlying iterator. It
   * implements most operators of a random access iterator.
   *
   * uBLAS extension: it.index()
   */

    // Renamed this class from reverse_iterator to get
    // typedef reverse_iterator<...> reverse_iterator
    // working. Thanks to Gabriel Dos Reis for explaining this.
    template <class I>
    class reverse_iterator_base:
        public std::reverse_iterator<I> {
    public:
        typedef typename I::container_type container_type;
        typedef typename container_type::size_type size_type;
        typedef typename I::difference_type difference_type;
        typedef I iterator_type;

        // Construction and destruction
        BOOST_UBLAS_INLINE
        reverse_iterator_base ():
            std::reverse_iterator<iterator_type> () {}
        BOOST_UBLAS_INLINE
        reverse_iterator_base (const iterator_type &it):
            std::reverse_iterator<iterator_type> (it) {}

#ifndef BOOST_UBLAS_NO_REVERSE_ITERATOR_OVERLOADS
        // Arithmetic
        BOOST_UBLAS_INLINE
        reverse_iterator_base &operator ++ () {
            // Comeau recommends...
            return *this = -- this->base ();
        }
        BOOST_UBLAS_INLINE
        reverse_iterator_base operator ++ (int) {
            // Comeau recommends...
            reverse_iterator_base tmp (*this);
            *this = -- this->base ();
            return tmp;
        }
        BOOST_UBLAS_INLINE
        reverse_iterator_base &operator -- () {
            // Comeau recommends...
            return *this = ++ this->base ();
        }
        BOOST_UBLAS_INLINE
        reverse_iterator_base operator -- (int) {
            // Comeau recommends...
            reverse_iterator_base tmp (*this);
            *this = ++ this->base ();
            return tmp;
        }
        BOOST_UBLAS_INLINE
        reverse_iterator_base &operator += (difference_type n) {
            // Comeau recommends...
            return *this = this->base () - n;
        }
        BOOST_UBLAS_INLINE
        reverse_iterator_base &operator -= (difference_type n) {
            // Comeau recommends...
            return *this = this->base () + n;
        }
#endif

#ifndef BOOST_UBLAS_NO_MEMBER_FRIENDS
        BOOST_UBLAS_INLINE
        friend reverse_iterator_base operator + (const reverse_iterator_base &it, difference_type n) {
            reverse_iterator_base tmp (it);
            return tmp += n;
        }
        BOOST_UBLAS_INLINE
        friend reverse_iterator_base operator + (difference_type n, const reverse_iterator_base &it) {
            reverse_iterator_base tmp (it);
            return tmp += n;
        }
        BOOST_UBLAS_INLINE
        friend reverse_iterator_base operator - (const reverse_iterator_base &it, difference_type n) {
            reverse_iterator_base tmp (it);
            return tmp -= n;
        }
        BOOST_UBLAS_INLINE
        friend difference_type operator - (const reverse_iterator_base &it1, const reverse_iterator_base &it2) {
            return it2.base () - it1.base ();
        }
#endif

        BOOST_UBLAS_INLINE
        const container_type &operator () () const {
            return this->base () ();
        }

        BOOST_UBLAS_INLINE
        size_type index () const {
            // Comeau recommends...
            iterator_type tmp (this->base ());
            return (-- tmp).index ();
        }
    };

#ifdef BOOST_UBLAS_NO_MEMBER_FRIENDS
    template<class I>
    BOOST_UBLAS_INLINE
    reverse_iterator_base<I> operator + (const reverse_iterator_base<I> &it, std::ptrdiff_t n) {
        reverse_iterator_base<I> tmp (it);
        return tmp += n;
    }
    template<class I>
    BOOST_UBLAS_INLINE
    reverse_iterator_base<I> operator + (std::ptrdiff_t n, const reverse_iterator_base<I> &it) {
        reverse_iterator_base<I> tmp (it);
        return tmp += n;
    }
    template<class I>
    BOOST_UBLAS_INLINE
    reverse_iterator_base<I> operator - (const reverse_iterator_base<I> &it, std::ptrdiff_t n) {
        reverse_iterator_base<I> tmp (it);
        return tmp -= n;
    }
    template<class I>
    BOOST_UBLAS_INLINE
    std::ptrdiff_t operator - (const reverse_iterator_base<I> &it1, const reverse_iterator_base<I> &it2) {
        return it2.base () - it1.base ();
    }
#endif

  /** \brief 1st base class of all matrix reverse iterators. (non-MSVC version)
   *
   * \param I the derived iterator type
   *
   * The reverse iterator implements a bidirectional iterator
   * reversing the elements of the underlying iterator. It
   * implements most operators of a random access iterator.
   *
   * uBLAS extension: it.index1(), it.index2() and access to
   * the dual iterator via begin(), end(), rbegin(), rend()
   */

    // Renamed this class from reverse_iterator1 to get
    // typedef reverse_iterator1<...> reverse_iterator1
    // working. Thanks to Gabriel Dos Reis for explaining this.
    template <class I>
    class reverse_iterator_base1:
        public std::reverse_iterator<I> {
    public:
        typedef typename I::container_type container_type;
        typedef typename container_type::size_type size_type;
        typedef typename I::difference_type difference_type;
        typedef I iterator_type;
        typedef typename I::dual_iterator_type dual_iterator_type;
        typedef typename I::dual_reverse_iterator_type dual_reverse_iterator_type;

        // Construction and destruction
        BOOST_UBLAS_INLINE
        reverse_iterator_base1 ():
            std::reverse_iterator<iterator_type> () {}
        BOOST_UBLAS_INLINE
        reverse_iterator_base1 (const iterator_type &it):
            std::reverse_iterator<iterator_type> (it) {}

#ifndef BOOST_UBLAS_NO_REVERSE_ITERATOR_OVERLOADS
        // Arithmetic
        BOOST_UBLAS_INLINE
        reverse_iterator_base1 &operator ++ () {
            // Comeau recommends...
            return *this = -- this->base ();
        }
        BOOST_UBLAS_INLINE
        reverse_iterator_base1 operator ++ (int) {
            // Comeau recommends...
            reverse_iterator_base1 tmp (*this);
            *this = -- this->base ();
            return tmp;
        }
        BOOST_UBLAS_INLINE
        reverse_iterator_base1 &operator -- () {
            // Comeau recommends...
            return *this = ++ this->base ();
        }
        BOOST_UBLAS_INLINE
        reverse_iterator_base1 operator -- (int) {
            // Comeau recommends...
            reverse_iterator_base1 tmp (*this);
            *this = ++ this->base ();
            return tmp;
        }
        BOOST_UBLAS_INLINE
        reverse_iterator_base1 &operator += (difference_type n) {
            // Comeau recommends...
            return *this = this->base () - n;
        }
        BOOST_UBLAS_INLINE
        reverse_iterator_base1 &operator -= (difference_type n) {
            // Comeau recommends...
            return *this = this->base () + n;
        }
#endif

#ifndef BOOST_UBLAS_NO_MEMBER_FRIENDS
        BOOST_UBLAS_INLINE
        friend reverse_iterator_base1 operator + (const reverse_iterator_base1 &it, difference_type n) {
            reverse_iterator_base1 tmp (it);
            return tmp += n;
        }
        BOOST_UBLAS_INLINE
        friend reverse_iterator_base1 operator + (difference_type n, const reverse_iterator_base1 &it) {
            reverse_iterator_base1 tmp (it);
            return tmp += n;
        }
        BOOST_UBLAS_INLINE
        friend reverse_iterator_base1 operator - (const reverse_iterator_base1 &it, difference_type n) {
            reverse_iterator_base1 tmp (it);
            return tmp -= n;
        }
        BOOST_UBLAS_INLINE
        friend difference_type operator - (const reverse_iterator_base1 &it1, const reverse_iterator_base1 &it2) {
            return it2.base () - it1.base ();
        }
#endif

        BOOST_UBLAS_INLINE
        const container_type &operator () () const {
            // Comeau recommends...
            return this->base () ();
        }

        BOOST_UBLAS_INLINE
        size_type index1 () const {
            // Comeau recommends...
            iterator_type tmp (this->base ());
            return (-- tmp).index1 ();
        }
        BOOST_UBLAS_INLINE
        size_type index2 () const {
            // Comeau recommends...
            iterator_type tmp (this->base ());
            return (-- tmp).index2 ();
        }

        BOOST_UBLAS_INLINE
        dual_iterator_type begin () const {
            // Comeau recommends...
            iterator_type tmp (this->base ());
            return (-- tmp).begin ();
        }
        BOOST_UBLAS_INLINE
        dual_iterator_type end () const {
            // Comeau recommends...
            iterator_type tmp (this->base ());
            return (-- tmp).end ();
        }
        BOOST_UBLAS_INLINE
        dual_reverse_iterator_type rbegin () const {
            return dual_reverse_iterator_type (end ());
        }
        BOOST_UBLAS_INLINE
        dual_reverse_iterator_type rend () const {
            return dual_reverse_iterator_type (begin ());
        }
    };

#ifdef BOOST_UBLAS_NO_MEMBER_FRIENDS
    template<class I>
    BOOST_UBLAS_INLINE
    reverse_iterator_base1<I> operator + (const reverse_iterator_base1<I> &it, std::ptrdiff_t n) {
        reverse_iterator_base1<I> tmp (it);
        return tmp += n;
    }
    template<class I>
    BOOST_UBLAS_INLINE
    reverse_iterator_base1<I> operator + (std::ptrdiff_t n, const reverse_iterator_base1<I> &it) {
        reverse_iterator_base1<I> tmp (it);
        return tmp += n;
    }
    template<class I>
    BOOST_UBLAS_INLINE
    reverse_iterator_base1<I> operator - (const reverse_iterator_base1<I> &it, std::ptrdiff_t n) {
        reverse_iterator_base1<I> tmp (it);
        return tmp -= n;
    }
    template<class I>
    BOOST_UBLAS_INLINE
    std::ptrdiff_t operator - (const reverse_iterator_base1<I> &it1, const reverse_iterator_base1<I> &it2) {
        return it2.base () - it1.base ();
    }
#endif

  /** \brief 2nd base class of all matrix reverse iterators. (non-MSVC version)
   *
   * \param I the derived iterator type
   *
   * The reverse iterator implements a bidirectional iterator
   * reversing the elements of the underlying iterator. It
   * implements most operators of a random access iterator.
   *
   * uBLAS extension: it.index1(), it.index2() and access to
   * the dual iterator via begin(), end(), rbegin(), rend()
   *
   * Note: this type is _identical_ to reverse_iterator_base1
   */

    // Renamed this class from reverse_iterator2 to get
    // typedef reverse_iterator2<...> reverse_iterator2
    // working. Thanks to Gabriel Dos Reis for explaining this.
    template <class I>
    class reverse_iterator_base2:
        public std::reverse_iterator<I> {
    public:
        typedef typename I::container_type container_type;
        typedef typename container_type::size_type size_type;
        typedef typename I::difference_type difference_type;
        typedef I iterator_type;
        typedef typename I::dual_iterator_type dual_iterator_type;
        typedef typename I::dual_reverse_iterator_type dual_reverse_iterator_type;

        // Construction and destruction
        BOOST_UBLAS_INLINE