1437 lines
51 KiB
Plaintext
1437 lines
51 KiB
Plaintext
//
|
|
// Copyright (c) 2000-2002
|
|
// Joerg Walter, Mathias Koch
|
|
//
|
|
// Distributed under the Boost Software License, Version 1.0. (See
|
|
// accompanying file LICENSE_1_0.txt or copy at
|
|
// http://www.boost.org/LICENSE_1_0.txt)
|
|
//
|
|
// The authors gratefully acknowledge the support of
|
|
// GeNeSys mbH & Co. KG in producing this work.
|
|
//
|
|
|
|
#ifndef _BOOST_UBLAS_ITERATOR_
|
|
#define _BOOST_UBLAS_ITERATOR_
|
|
|
|
#include <boost/numeric/ublas/exception.hpp>
|
|
#include <iterator>
|
|
|
|
|
|
namespace boost { namespace numeric { namespace ublas {
|
|
|
|
/** \brief Base class of all proxy classes that contain
|
|
* a (redirectable) reference to an immutable object.
|
|
*
|
|
* \param C the type of the container referred to
|
|
*/
|
|
template<class C>
|
|
class container_const_reference:
|
|
private nonassignable {
|
|
public:
|
|
typedef C container_type;
|
|
|
|
BOOST_UBLAS_INLINE
|
|
container_const_reference ():
|
|
c_ (0) {}
|
|
BOOST_UBLAS_INLINE
|
|
container_const_reference (const container_type &c):
|
|
c_ (&c) {}
|
|
|
|
BOOST_UBLAS_INLINE
|
|
const container_type &operator () () const {
|
|
return *c_;
|
|
}
|
|
|
|
BOOST_UBLAS_INLINE
|
|
container_const_reference &assign (const container_type *c) {
|
|
c_ = c;
|
|
return *this;
|
|
}
|
|
|
|
// Closure comparison
|
|
BOOST_UBLAS_INLINE
|
|
bool same_closure (const container_const_reference &cr) const {
|
|
return c_ == cr.c_;
|
|
}
|
|
|
|
private:
|
|
const container_type *c_;
|
|
};
|
|
|
|
/** \brief Base class of all proxy classes that contain
|
|
* a (redirectable) reference to a mutable object.
|
|
*
|
|
* \param C the type of the container referred to
|
|
*/
|
|
template<class C>
|
|
class container_reference:
|
|
private nonassignable {
|
|
public:
|
|
typedef C container_type;
|
|
|
|
BOOST_UBLAS_INLINE
|
|
container_reference ():
|
|
c_ (0) {}
|
|
BOOST_UBLAS_INLINE
|
|
container_reference (container_type &c):
|
|
c_ (&c) {}
|
|
|
|
BOOST_UBLAS_INLINE
|
|
container_type &operator () () const {
|
|
return *c_;
|
|
}
|
|
|
|
BOOST_UBLAS_INLINE
|
|
container_reference &assign (container_type *c) {
|
|
c_ = c;
|
|
return *this;
|
|
}
|
|
|
|
// Closure comparison
|
|
BOOST_UBLAS_INLINE
|
|
bool same_closure (const container_reference &cr) const {
|
|
return c_ == cr.c_;
|
|
}
|
|
|
|
private:
|
|
container_type *c_;
|
|
};
|
|
|
|
/** \brief Base class of all forward iterators.
|
|
*
|
|
* \param IC the iterator category
|
|
* \param I the derived iterator type
|
|
* \param T the value type
|
|
*
|
|
* The forward iterator can only proceed in one direction
|
|
* via the post increment operator.
|
|
*/
|
|
template<class IC, class I, class T>
|
|
struct forward_iterator_base:
|
|
public std::iterator<IC, T> {
|
|
typedef I derived_iterator_type;
|
|
typedef T derived_value_type;
|
|
|
|
// Arithmetic
|
|
BOOST_UBLAS_INLINE
|
|
derived_iterator_type operator ++ (int) {
|
|
derived_iterator_type &d (*static_cast<const derived_iterator_type *> (this));
|
|
derived_iterator_type tmp (d);
|
|
++ d;
|
|
return tmp;
|
|
}
|
|
BOOST_UBLAS_INLINE
|
|
friend derived_iterator_type operator ++ (derived_iterator_type &d, int) {
|
|
derived_iterator_type tmp (d);
|
|
++ d;
|
|
return tmp;
|
|
}
|
|
|
|
// Comparison
|
|
BOOST_UBLAS_INLINE
|
|
bool operator != (const derived_iterator_type &it) const {
|
|
const derived_iterator_type *d = static_cast<const derived_iterator_type *> (this);
|
|
return ! (*d == it);
|
|
}
|
|
};
|
|
|
|
/** \brief Base class of all bidirectional iterators.
|
|
*
|
|
* \param IC the iterator category
|
|
* \param I the derived iterator type
|
|
* \param T the value type
|
|
*
|
|
* The bidirectional iterator can proceed in both directions
|
|
* via the post increment and post decrement operator.
|
|
*/
|
|
template<class IC, class I, class T>
|
|
struct bidirectional_iterator_base:
|
|
public std::iterator<IC, T> {
|
|
typedef I derived_iterator_type;
|
|
typedef T derived_value_type;
|
|
|
|
// Arithmetic
|
|
BOOST_UBLAS_INLINE
|
|
derived_iterator_type operator ++ (int) {
|
|
derived_iterator_type &d (*static_cast<const derived_iterator_type *> (this));
|
|
derived_iterator_type tmp (d);
|
|
++ d;
|
|
return tmp;
|
|
}
|
|
BOOST_UBLAS_INLINE
|
|
friend derived_iterator_type operator ++ (derived_iterator_type &d, int) {
|
|
derived_iterator_type tmp (d);
|
|
++ d;
|
|
return tmp;
|
|
}
|
|
BOOST_UBLAS_INLINE
|
|
derived_iterator_type operator -- (int) {
|
|
derived_iterator_type &d (*static_cast<const derived_iterator_type *> (this));
|
|
derived_iterator_type tmp (d);
|
|
-- d;
|
|
return tmp;
|
|
}
|
|
BOOST_UBLAS_INLINE
|
|
friend derived_iterator_type operator -- (derived_iterator_type &d, int) {
|
|
derived_iterator_type tmp (d);
|
|
-- d;
|
|
return tmp;
|
|
}
|
|
|
|
// Comparison
|
|
BOOST_UBLAS_INLINE
|
|
bool operator != (const derived_iterator_type &it) const {
|
|
const derived_iterator_type *d = static_cast<const derived_iterator_type *> (this);
|
|
return ! (*d == it);
|
|
}
|
|
};
|
|
|
|
/** \brief Base class of all random access iterators.
|
|
*
|
|
* \param IC the iterator category
|
|
* \param I the derived iterator type
|
|
* \param T the value type
|
|
* \param D the difference type, default: std::ptrdiff_t
|
|
*
|
|
* The random access iterator can proceed in both directions
|
|
* via the post increment/decrement operator or in larger steps
|
|
* via the +, - and +=, -= operators. The random access iterator
|
|
* is LessThan Comparable.
|
|
*/
|
|
template<class IC, class I, class T, class D = std::ptrdiff_t>
|
|
// ISSUE the default for D seems rather dangerous as it can easily be (silently) incorrect
|
|
struct random_access_iterator_base:
|
|
public std::iterator<IC, T> {
|
|
typedef I derived_iterator_type;
|
|
typedef T derived_value_type;
|
|
typedef D derived_difference_type;
|
|
|
|
/* FIXME Need to explicitly pass derived_reference_type as otherwise I undefined type or forward declared
|
|
typedef typename derived_iterator_type::reference derived_reference_type;
|
|
// Indexed element
|
|
BOOST_UBLAS_INLINE
|
|
derived_reference_type operator [] (derived_difference_type n) {
|
|
return *(*this + n);
|
|
}
|
|
*/
|
|
|
|
// Arithmetic
|
|
BOOST_UBLAS_INLINE
|
|
derived_iterator_type operator ++ (int) {
|
|
derived_iterator_type &d (*static_cast<derived_iterator_type *> (this));
|
|
derived_iterator_type tmp (d);
|
|
++ d;
|
|
return tmp;
|
|
}
|
|
BOOST_UBLAS_INLINE
|
|
friend derived_iterator_type operator ++ (derived_iterator_type &d, int) {
|
|
derived_iterator_type tmp (d);
|
|
++ d;
|
|
return tmp;
|
|
}
|
|
BOOST_UBLAS_INLINE
|
|
derived_iterator_type operator -- (int) {
|
|
derived_iterator_type &d (*static_cast<derived_iterator_type *> (this));
|
|
derived_iterator_type tmp (d);
|
|
-- d;
|
|
return tmp;
|
|
}
|
|
BOOST_UBLAS_INLINE
|
|
friend derived_iterator_type operator -- (derived_iterator_type &d, int) {
|
|
derived_iterator_type tmp (d);
|
|
-- d;
|
|
return tmp;
|
|
}
|
|
BOOST_UBLAS_INLINE
|
|
derived_iterator_type operator + (derived_difference_type n) const {
|
|
derived_iterator_type tmp (*static_cast<const derived_iterator_type *> (this));
|
|
return tmp += n;
|
|
}
|
|
BOOST_UBLAS_INLINE
|
|
friend derived_iterator_type operator + (const derived_iterator_type &d, derived_difference_type n) {
|
|
derived_iterator_type tmp (d);
|
|
return tmp += n;
|
|
}
|
|
BOOST_UBLAS_INLINE
|
|
friend derived_iterator_type operator + (derived_difference_type n, const derived_iterator_type &d) {
|
|
derived_iterator_type tmp (d);
|
|
return tmp += n;
|
|
}
|
|
BOOST_UBLAS_INLINE
|
|
derived_iterator_type operator - (derived_difference_type n) const {
|
|
derived_iterator_type tmp (*static_cast<const derived_iterator_type *> (this));
|
|
return tmp -= n;
|
|
}
|
|
BOOST_UBLAS_INLINE
|
|
friend derived_iterator_type operator - (const derived_iterator_type &d, derived_difference_type n) {
|
|
derived_iterator_type tmp (d);
|
|
return tmp -= n;
|
|
}
|
|
|
|
// Comparison
|
|
BOOST_UBLAS_INLINE
|
|
bool operator != (const derived_iterator_type &it) const {
|
|
const derived_iterator_type *d = static_cast<const derived_iterator_type *> (this);
|
|
return ! (*d == it);
|
|
}
|
|
BOOST_UBLAS_INLINE
|
|
bool operator <= (const derived_iterator_type &it) const {
|
|
const derived_iterator_type *d = static_cast<const derived_iterator_type *> (this);
|
|
return ! (it < *d);
|
|
}
|
|
BOOST_UBLAS_INLINE
|
|
bool operator >= (const derived_iterator_type &it) const {
|
|
const derived_iterator_type *d = static_cast<const derived_iterator_type *> (this);
|
|
return ! (*d < it);
|
|
}
|
|
BOOST_UBLAS_INLINE
|
|
bool operator > (const derived_iterator_type &it) const {
|
|
const derived_iterator_type *d = static_cast<const derived_iterator_type *> (this);
|
|
return it < *d;
|
|
}
|
|
};
|
|
|
|
/** \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) {}
|
|
|
|
// Arithmetic
|
|
BOOST_UBLAS_INLINE
|
|
reverse_iterator_base &operator ++ () {
|
|
return *this = -- this->base ();
|
|
}
|
|
BOOST_UBLAS_INLINE
|
|
reverse_iterator_base operator ++ (int) {
|
|
reverse_iterator_base tmp (*this);
|
|
*this = -- this->base ();
|
|
return tmp;
|
|
}
|
|
BOOST_UBLAS_INLINE
|
|
reverse_iterator_base &operator -- () {
|
|
return *this = ++ this->base ();
|
|
}
|
|
BOOST_UBLAS_INLINE
|
|
reverse_iterator_base operator -- (int) {
|
|
reverse_iterator_base tmp (*this);
|
|
*this = ++ this->base ();
|
|
return tmp;
|
|
}
|
|
BOOST_UBLAS_INLINE
|
|
reverse_iterator_base &operator += (difference_type n) {
|
|
return *this = this->base () - n;
|
|
}
|
|
BOOST_UBLAS_INLINE
|
|
reverse_iterator_base &operator -= (difference_type n) {
|
|
return *this = this->base () + 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 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 ();
|
|
}
|
|
|
|
BOOST_UBLAS_INLINE
|
|
const container_type &operator () () const {
|
|
return this->base () ();
|
|
}
|
|
|
|
BOOST_UBLAS_INLINE
|
|
size_type index () const {
|
|
iterator_type tmp (this->base ());
|
|
return (-- tmp).index ();
|
|
}
|
|
};
|
|
|
|
/** \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) {}
|
|
|
|
// Arithmetic
|
|
BOOST_UBLAS_INLINE
|
|
reverse_iterator_base1 &operator ++ () {
|
|
return *this = -- this->base ();
|
|
}
|
|
BOOST_UBLAS_INLINE
|
|
reverse_iterator_base1 operator ++ (int) {
|
|
reverse_iterator_base1 tmp (*this);
|
|
*this = -- this->base ();
|
|
return tmp;
|
|
}
|
|
BOOST_UBLAS_INLINE
|
|
reverse_iterator_base1 &operator -- () {
|
|
return *this = ++ this->base ();
|
|
}
|
|
BOOST_UBLAS_INLINE
|
|
reverse_iterator_base1 operator -- (int) {
|
|
reverse_iterator_base1 tmp (*this);
|
|
*this = ++ this->base ();
|
|
return tmp;
|
|
}
|
|
BOOST_UBLAS_INLINE
|
|
reverse_iterator_base1 &operator += (difference_type n) {
|
|
return *this = this->base () - n;
|
|
}
|
|
BOOST_UBLAS_INLINE
|
|
reverse_iterator_base1 &operator -= (difference_type n) {
|
|
return *this = this->base () + 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 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 ();
|
|
}
|
|
|
|
BOOST_UBLAS_INLINE
|
|
const container_type &operator () () const {
|
|
return this->base () ();
|
|
}
|
|
|
|
BOOST_UBLAS_INLINE
|
|
size_type index1 () const {
|
|
iterator_type tmp (this->base ());
|
|
return (-- tmp).index1 ();
|
|
}
|
|
BOOST_UBLAS_INLINE
|
|
size_type index2 () const {
|
|
iterator_type tmp (this->base ());
|
|
return (-- tmp).index2 ();
|
|
}
|
|
|
|
BOOST_UBLAS_INLINE
|
|
dual_iterator_type begin () const {
|
|
iterator_type tmp (this->base ());
|
|
return (-- tmp).begin ();
|
|
}
|
|
BOOST_UBLAS_INLINE
|
|
dual_iterator_type end () const {
|
|
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 ());
|
|
}
|
|
};
|
|
|
|
/** \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
|
|
reverse_iterator_base2 ():
|
|
std::reverse_iterator<iterator_type> () {}
|
|
BOOST_UBLAS_INLINE
|
|
reverse_iterator_base2 (const iterator_type &it):
|
|
std::reverse_iterator<iterator_type> (it) {}
|
|
|
|
// Arithmetic
|
|
BOOST_UBLAS_INLINE
|
|
reverse_iterator_base2 &operator ++ () {
|
|
return *this = -- this->base ();
|
|
}
|
|
BOOST_UBLAS_INLINE
|
|
reverse_iterator_base2 operator ++ (int) {
|
|
reverse_iterator_base2 tmp (*this);
|
|
*this = -- this->base ();
|
|
return tmp;
|
|
}
|
|
BOOST_UBLAS_INLINE
|
|
reverse_iterator_base2 &operator -- () {
|
|
return *this = ++ this->base ();
|
|
}
|
|
BOOST_UBLAS_INLINE
|
|
reverse_iterator_base2 operator -- (int) {
|
|
reverse_iterator_base2 tmp (*this);
|
|
*this = ++ this->base ();
|
|
return tmp;
|
|
}
|
|
BOOST_UBLAS_INLINE
|
|
reverse_iterator_base2 &operator += (difference_type n) {
|
|
return *this = this->base () - n;
|
|
}
|
|
BOOST_UBLAS_INLINE
|
|
reverse_iterator_base2 &operator -= (difference_type n) {
|
|
return *this = this->base () + n;
|
|
}
|
|
|
|
BOOST_UBLAS_INLINE
|
|
friend reverse_iterator_base2 operator + (const reverse_iterator_base2 &it, difference_type n) {
|
|
reverse_iterator_base2 tmp (it);
|
|
return tmp += n;
|
|
}
|
|
BOOST_UBLAS_INLINE
|
|
friend reverse_iterator_base2 operator + (difference_type n, const reverse_iterator_base2 &it) {
|
|
reverse_iterator_base2 tmp (it);
|
|
return tmp += n;
|
|
}
|
|
BOOST_UBLAS_INLINE
|
|
friend reverse_iterator_base2 operator - (const reverse_iterator_base2 &it, difference_type n) {
|
|
reverse_iterator_base2 tmp (it);
|
|
return tmp -= n;
|
|
}
|
|
BOOST_UBLAS_INLINE
|
|
friend difference_type operator - (const reverse_iterator_base2 &it1, const reverse_iterator_base2 &it2) {
|
|
return it2.base () - it1.base ();
|
|
}
|
|
|
|
BOOST_UBLAS_INLINE
|
|
const container_type &operator () () const {
|
|
return this->base () ();
|
|
}
|
|
|
|
BOOST_UBLAS_INLINE
|
|
size_type index1 () const {
|
|
iterator_type tmp (this->base ());
|
|
return (-- tmp).index1 ();
|
|
}
|
|
BOOST_UBLAS_INLINE
|
|
size_type index2 () const {
|
|
iterator_type tmp (this->base ());
|
|
return (-- tmp).index2 ();
|
|
}
|
|
|
|
BOOST_UBLAS_INLINE
|
|
dual_iterator_type begin () const {
|
|
iterator_type tmp (this->base ());
|
|
return (-- tmp).begin ();
|
|
}
|
|
BOOST_UBLAS_INLINE
|
|
dual_iterator_type end () const {
|
|
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 ());
|
|
}
|
|
};
|
|
|
|
/** \brief A class implementing an indexed random access iterator.
|
|
*
|
|
* \param C the (mutable) container type
|
|
* \param IC the iterator category
|
|
*
|
|
* This class implements a random access iterator. The current
|
|
* position is stored as the unsigned integer it_ and the
|
|
* values are accessed via operator()(it_) of the container.
|
|
*
|
|
* uBLAS extension: index()
|
|
*/
|
|
|
|
template<class C, class IC>
|
|
class indexed_iterator:
|
|
public container_reference<C>,
|
|
public random_access_iterator_base<IC,
|
|
indexed_iterator<C, IC>,
|
|
typename C::value_type,
|
|
typename C::difference_type> {
|
|
public:
|
|
typedef C container_type;
|
|
typedef IC iterator_category;
|
|
typedef typename container_type::size_type size_type;
|
|
typedef typename container_type::difference_type difference_type;
|
|
typedef typename container_type::value_type value_type;
|
|
typedef typename container_type::reference reference;
|
|
|
|
// Construction and destruction
|
|
BOOST_UBLAS_INLINE
|
|
indexed_iterator ():
|
|
container_reference<container_type> (), it_ () {}
|
|
BOOST_UBLAS_INLINE
|
|
indexed_iterator (container_type &c, size_type it):
|
|
container_reference<container_type> (c), it_ (it) {}
|
|
|
|
// Arithmetic
|
|
BOOST_UBLAS_INLINE
|
|
indexed_iterator &operator ++ () {
|
|
++ it_;
|
|
return *this;
|
|
}
|
|
BOOST_UBLAS_INLINE
|
|
indexed_iterator &operator -- () {
|
|
-- it_;
|
|
return *this;
|
|
}
|
|
BOOST_UBLAS_INLINE
|
|
indexed_iterator &operator += (difference_type n) {
|
|
it_ += n;
|
|
return *this;
|
|
}
|
|
BOOST_UBLAS_INLINE
|
|
indexed_iterator &operator -= (difference_type n) {
|
|
it_ -= n;
|
|
return *this;
|
|
}
|
|
BOOST_UBLAS_INLINE
|
|
difference_type operator - (const indexed_iterator &it) const {
|
|
BOOST_UBLAS_CHECK (&(*this) () == &it (), external_logic ());
|
|
return it_ - it.it_;
|
|
}
|
|
|
|
// Dereference
|
|
BOOST_UBLAS_INLINE
|
|
reference operator * () const {
|
|
BOOST_UBLAS_CHECK (index () < (*this) ().size (), bad_index ());
|
|
return (*this) () (it_);
|
|
}
|
|
BOOST_UBLAS_INLINE
|
|
reference operator [] (difference_type n) const {
|
|
return *((*this) + n);
|
|
}
|
|
|
|
// Index
|
|
BOOST_UBLAS_INLINE
|
|
size_type index () const {
|
|
return it_;
|
|
}
|
|
|
|
// Assignment
|
|
BOOST_UBLAS_INLINE
|
|
indexed_iterator &operator = (const indexed_iterator &it) {
|
|
// FIX: ICC needs full qualification?!
|
|
// assign (&it ());
|
|
container_reference<C>::assign (&it ());
|
|
it_ = it.it_;
|
|
return *this;
|
|
}
|
|
|
|
// Comparison
|
|
BOOST_UBLAS_INLINE
|
|
bool operator == (const indexed_iterator &it) const {
|
|
BOOST_UBLAS_CHECK (&(*this) () == &it (), external_logic ());
|
|
return it_ == it.it_;
|
|
}
|
|
BOOST_UBLAS_INLINE
|
|
bool operator < (const indexed_iterator &it) const {
|
|
BOOST_UBLAS_CHECK (&(*this) () == &it (), external_logic ());
|
|
return it_ < it.it_;
|
|
}
|
|
|
|
private:
|
|
size_type it_;
|
|
};
|
|
|
|
/** \brief A class implementing an indexed random access iterator.
|
|
*
|
|
* \param C the (immutable) container type
|
|
* \param IC the iterator category
|
|
*
|
|
* This class implements a random access iterator. The current
|
|
* position is stored as the unsigned integer \c it_ and the
|
|
* values are accessed via \c operator()(it_) of the container.
|
|
*
|
|
* uBLAS extension: \c index()
|
|
*
|
|
* Note: there is an automatic conversion from
|
|
* \c indexed_iterator to \c indexed_const_iterator
|
|
*/
|
|
|
|
template<class C, class IC>
|
|
class indexed_const_iterator:
|
|
public container_const_reference<C>,
|
|
public random_access_iterator_base<IC,
|
|
indexed_const_iterator<C, IC>,
|
|
typename C::value_type,
|
|
typename C::difference_type> {
|
|
public:
|
|
typedef C container_type;
|
|
typedef IC iterator_category;
|
|
typedef typename container_type::size_type size_type;
|
|
typedef typename container_type::difference_type difference_type;
|
|
typedef typename container_type::value_type value_type;
|
|
typedef typename container_type::const_reference reference;
|
|
typedef indexed_iterator<container_type, iterator_category> iterator_type;
|
|
|
|
// Construction and destruction
|
|
BOOST_UBLAS_INLINE
|
|
indexed_const_iterator ():
|
|
container_const_reference<container_type> (), it_ () {}
|
|
BOOST_UBLAS_INLINE
|
|
indexed_const_iterator (const container_type &c, size_type it):
|
|
container_const_reference<container_type> (c), it_ (it) {}
|
|
BOOST_UBLAS_INLINE
|
|
indexed_const_iterator (const iterator_type &it):
|
|
container_const_reference<container_type> (it ()), it_ (it.index ()) {}
|
|
|
|
// Arithmetic
|
|
BOOST_UBLAS_INLINE
|
|
indexed_const_iterator &operator ++ () {
|
|
++ it_;
|
|
return *this;
|
|
}
|
|
BOOST_UBLAS_INLINE
|
|
indexed_const_iterator &operator -- () {
|
|
-- it_;
|
|
return *this;
|
|
}
|
|
BOOST_UBLAS_INLINE
|
|
indexed_const_iterator &operator += (difference_type n) {
|
|
it_ += n;
|
|
return *this;
|
|
}
|
|
BOOST_UBLAS_INLINE
|
|
indexed_const_iterator &operator -= (difference_type n) {
|
|
it_ -= n;
|
|
return *this;
|
|
}
|
|
BOOST_UBLAS_INLINE
|
|
difference_type operator - (const indexed_const_iterator &it) const {
|
|
BOOST_UBLAS_CHECK (&(*this) () == &it (), external_logic ());
|
|
return it_ - it.it_;
|
|
}
|
|
|
|
// Dereference
|
|
BOOST_UBLAS_INLINE
|
|
reference operator * () const {
|
|
BOOST_UBLAS_CHECK (index () < (*this) ().size (), bad_index ());
|
|
return (*this) () (it_);
|
|
}
|
|
BOOST_UBLAS_INLINE
|
|
reference operator [] (difference_type n) const {
|
|
return *((*this) + n);
|
|
}
|
|
|
|
// Index
|
|
BOOST_UBLAS_INLINE
|
|
size_type index () const {
|
|
return it_;
|
|
}
|
|
|
|
// Assignment
|
|
BOOST_UBLAS_INLINE
|
|
indexed_const_iterator &operator = (const indexed_const_iterator &it) {
|
|
// FIX: ICC needs full qualification?!
|
|
// assign (&it ());
|
|
container_const_reference<C>::assign (&it ());
|
|
it_ = it.it_;
|
|
return *this;
|
|
}
|
|
|
|
// Comparison
|
|
BOOST_UBLAS_INLINE
|
|
bool operator == (const indexed_const_iterator &it) const {
|
|
BOOST_UBLAS_CHECK (&(*this) () == &it (), external_logic ());
|
|
return it_ == it.it_;
|
|
}
|
|
BOOST_UBLAS_INLINE
|
|
bool operator < (const indexed_const_iterator &it) const {
|
|
BOOST_UBLAS_CHECK (&(*this) () == &it (), external_logic ());
|
|
return it_ < it.it_;
|
|
}
|
|
|
|
private:
|
|
size_type it_;
|
|
|
|
friend class indexed_iterator<container_type, iterator_category>;
|
|
};
|
|
|
|
template<class C, class IC>
|
|
class indexed_iterator2;
|
|
|
|
/** \brief A class implementing an indexed random access iterator
|
|
* of a matrix.
|
|
*
|
|
* \param C the (mutable) container type
|
|
* \param IC the iterator category
|
|
*
|
|
* This class implements a random access iterator. The current
|
|
* position is stored as two unsigned integers \c it1_ and \c it2_
|
|
* and the values are accessed via \c operator()(it1_, it2_) of the
|
|
* container. The iterator changes the first index.
|
|
*
|
|
* uBLAS extension: \c index1(), \c index2() and access to the
|
|
* dual iterator via \c begin(), \c end(), \c rbegin() and \c rend()
|
|
*
|
|
* Note: The container has to support the \code find2(rank, i, j) \endcode
|
|
* method
|
|
*/
|
|
|
|
template<class C, class IC>
|
|
class indexed_iterator1:
|
|
public container_reference<C>,
|
|
public random_access_iterator_base<IC,
|
|
indexed_iterator1<C, IC>,
|
|
typename C::value_type,
|
|
typename C::difference_type> {
|
|
public:
|
|
typedef C container_type;
|
|
typedef IC iterator_category;
|
|
typedef typename container_type::size_type size_type;
|
|
typedef typename container_type::difference_type difference_type;
|
|
typedef typename container_type::value_type value_type;
|
|
typedef typename container_type::reference reference;
|
|
|
|
typedef indexed_iterator2<container_type, iterator_category> dual_iterator_type;
|
|
typedef reverse_iterator_base2<dual_iterator_type> dual_reverse_iterator_type;
|
|
|
|
// Construction and destruction
|
|
BOOST_UBLAS_INLINE
|
|
indexed_iterator1 ():
|
|
container_reference<container_type> (), it1_ (), it2_ () {}
|
|
BOOST_UBLAS_INLINE
|
|
indexed_iterator1 (container_type &c, size_type it1, size_type it2):
|
|
container_reference<container_type> (c), it1_ (it1), it2_ (it2) {}
|
|
|
|
// Arithmetic
|
|
BOOST_UBLAS_INLINE
|
|
indexed_iterator1 &operator ++ () {
|
|
++ it1_;
|
|
return *this;
|
|
}
|
|
BOOST_UBLAS_INLINE
|
|
indexed_iterator1 &operator -- () {
|
|
-- it1_;
|
|
return *this;
|
|
}
|
|
BOOST_UBLAS_INLINE
|
|
indexed_iterator1 &operator += (difference_type n) {
|
|
it1_ += n;
|
|
return *this;
|
|
}
|
|
BOOST_UBLAS_INLINE
|
|
indexed_iterator1 &operator -= (difference_type n) {
|
|
it1_ -= n;
|
|
return *this;
|
|
}
|
|
BOOST_UBLAS_INLINE
|
|
difference_type operator - (const indexed_iterator1 &it) const {
|
|
BOOST_UBLAS_CHECK (&(*this) () == &it (), external_logic ());
|
|
BOOST_UBLAS_CHECK (it2_ == it.it2_, external_logic ());
|
|
return it1_ - it.it1_;
|
|
}
|
|
|
|
// Dereference
|
|
BOOST_UBLAS_INLINE
|
|
reference operator * () const {
|
|
BOOST_UBLAS_CHECK (index1 () < (*this) ().size1 (), bad_index ());
|
|
BOOST_UBLAS_CHECK (index2 () < (*this) ().size2 (), bad_index ());
|
|
return (*this) () (it1_, it2_);
|
|
}
|
|
BOOST_UBLAS_INLINE
|
|
reference operator [] (difference_type n) const {
|
|
return *((*this) + n);
|
|
}
|
|
|
|
// Index
|
|
BOOST_UBLAS_INLINE
|
|
size_type index1 () const {
|
|
return it1_;
|
|
}
|
|
BOOST_UBLAS_INLINE
|
|
size_type index2 () const {
|
|
return it2_;
|
|
}
|
|
|
|
BOOST_UBLAS_INLINE
|
|
dual_iterator_type begin () const {
|
|
return (*this) ().find2 (1, index1 (), 0);
|
|
}
|
|
BOOST_UBLAS_INLINE
|
|
dual_iterator_type end () const {
|
|
return (*this) ().find2 (1, index1 (), (*this) ().size2 ());
|
|
}
|
|
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 ());
|
|
}
|
|
|
|
// Assignment
|
|
BOOST_UBLAS_INLINE
|
|
indexed_iterator1 &operator = (const indexed_iterator1 &it) {
|
|
// FIX: ICC needs full qualification?!
|
|
// assign (&it ());
|
|
container_reference<C>::assign (&it ());
|
|
it1_ = it.it1_;
|
|
it2_ = it.it2_;
|
|
return *this;
|
|
}
|
|
|
|
// Comparison
|
|
BOOST_UBLAS_INLINE
|
|
bool operator == (const indexed_iterator1 &it) const {
|
|
BOOST_UBLAS_CHECK (&(*this) () == &it (), external_logic ());
|
|
BOOST_UBLAS_CHECK (it2_ == it.it2_, external_logic ());
|
|
return it1_ == it.it1_;
|
|
}
|
|
BOOST_UBLAS_INLINE
|
|
bool operator < (const indexed_iterator1 &it) const {
|
|
BOOST_UBLAS_CHECK (&(*this) () == &it (), external_logic ());
|
|
BOOST_UBLAS_CHECK (it2_ == it.it2_, external_logic ());
|
|
return it1_ < it.it1_;
|
|
}
|
|
|
|
private:
|
|
size_type it1_;
|
|
size_type it2_;
|
|
};
|
|
|
|
template<class C, class IC>
|
|
class indexed_const_iterator2;
|
|
|
|
/** \brief A class implementing an indexed random access iterator
|
|
* of a matrix.
|
|
*
|
|
* \param C the (immutable) container type
|
|
* \param IC the iterator category
|
|
*
|
|
* This class implements a random access iterator. The current
|
|
* position is stored as two unsigned integers \c it1_ and \c it2_
|
|
* and the values are accessed via \c operator()(it1_, it2_) of the
|
|
* container. The iterator changes the first index.
|
|
*
|
|
* uBLAS extension: \c index1(), \c index2() and access to the
|
|
* dual iterator via \c begin(), \c end(), \c rbegin() and \c rend()
|
|
*
|
|
* Note 1: The container has to support the find2(rank, i, j) method
|
|
*
|
|
* Note 2: there is an automatic conversion from
|
|
* \c indexed_iterator1 to \c indexed_const_iterator1
|
|
*/
|
|
|
|
template<class C, class IC>
|
|
class indexed_const_iterator1:
|
|
public container_const_reference<C>,
|
|
public random_access_iterator_base<IC,
|
|
indexed_const_iterator1<C, IC>,
|
|
typename C::value_type,
|
|
typename C::difference_type> {
|
|
public:
|
|
typedef C container_type;
|
|
typedef IC iterator_category;
|
|
typedef typename container_type::size_type size_type;
|
|
typedef typename container_type::difference_type difference_type;
|
|
typedef typename container_type::value_type value_type;
|
|
typedef typename container_type::const_reference reference;
|
|
|
|
typedef indexed_iterator1<container_type, iterator_category> iterator_type;
|
|
typedef indexed_const_iterator2<container_type, iterator_category> dual_iterator_type;
|
|
typedef reverse_iterator_base2<dual_iterator_type> dual_reverse_iterator_type;
|
|
|
|
// Construction and destruction
|
|
BOOST_UBLAS_INLINE
|
|
indexed_const_iterator1 ():
|
|
container_const_reference<container_type> (), it1_ (), it2_ () {}
|
|
BOOST_UBLAS_INLINE
|
|
indexed_const_iterator1 (const container_type &c, size_type it1, size_type it2):
|
|
container_const_reference<container_type> (c), it1_ (it1), it2_ (it2) {}
|
|
BOOST_UBLAS_INLINE
|
|
indexed_const_iterator1 (const iterator_type &it):
|
|
container_const_reference<container_type> (it ()), it1_ (it.index1 ()), it2_ (it.index2 ()) {}
|
|
|
|
// Arithmetic
|
|
BOOST_UBLAS_INLINE
|
|
indexed_const_iterator1 &operator ++ () {
|
|
++ it1_;
|
|
return *this;
|
|
}
|
|
BOOST_UBLAS_INLINE
|
|
indexed_const_iterator1 &operator -- () {
|
|
-- it1_;
|
|
return *this;
|
|
}
|
|
BOOST_UBLAS_INLINE
|
|
indexed_const_iterator1 &operator += (difference_type n) {
|
|
it1_ += n;
|
|
return *this;
|
|
}
|
|
BOOST_UBLAS_INLINE
|
|
indexed_const_iterator1 &operator -= (difference_type n) {
|
|
it1_ -= n;
|
|
return *this;
|
|
}
|
|
BOOST_UBLAS_INLINE
|
|
difference_type operator - (const indexed_const_iterator1 &it) const {
|
|
BOOST_UBLAS_CHECK (&(*this) () == &it (), external_logic ());
|
|
BOOST_UBLAS_CHECK (it2_ == it.it2_, external_logic ());
|
|
return it1_ - it.it1_;
|
|
}
|
|
|
|
// Dereference
|
|
BOOST_UBLAS_INLINE
|
|
reference operator * () const {
|
|
BOOST_UBLAS_CHECK (index1 () < (*this) ().size1 (), bad_index ());
|
|
BOOST_UBLAS_CHECK (index2 () < (*this) ().size2 (), bad_index ());
|
|
return (*this) () (it1_, it2_);
|
|
}
|
|
BOOST_UBLAS_INLINE
|
|
reference operator [] (difference_type n) const {
|
|
return *((*this) + n);
|
|
}
|
|
|
|
// Index
|
|
BOOST_UBLAS_INLINE
|
|
size_type index1 () const {
|
|
return it1_;
|
|
}
|
|
BOOST_UBLAS_INLINE
|
|
size_type index2 () const {
|
|
return it2_;
|
|
}
|
|
|
|
BOOST_UBLAS_INLINE
|
|
dual_iterator_type begin () const {
|
|
return (*this) ().find2 (1, index1 (), 0);
|
|
}
|
|
BOOST_UBLAS_INLINE
|
|
dual_iterator_type end () const {
|
|
return (*this) ().find2 (1, index1 (), (*this) ().size2 ());
|
|
}
|
|
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 ());
|
|
}
|
|
|
|
// Assignment
|
|
BOOST_UBLAS_INLINE
|
|
indexed_const_iterator1 &operator = (const indexed_const_iterator1 &it) {
|
|
// FIX: ICC needs full qualification?!
|
|
// assign (&it ());
|
|
container_const_reference<C>::assign (&it ());
|
|
it1_ = it.it1_;
|
|
it2_ = it.it2_;
|
|
return *this;
|
|
}
|
|
|
|
// Comparison
|
|
BOOST_UBLAS_INLINE
|
|
bool operator == (const indexed_const_iterator1 &it) const {
|
|
BOOST_UBLAS_CHECK (&(*this) () == &it (), external_logic ());
|
|
BOOST_UBLAS_CHECK (it2_ == it.it2_, external_logic ());
|
|
return it1_ == it.it1_;
|
|
}
|
|
BOOST_UBLAS_INLINE
|
|
bool operator < (const indexed_const_iterator1 &it) const {
|
|
BOOST_UBLAS_CHECK (&(*this) () == &it (), external_logic ());
|
|
BOOST_UBLAS_CHECK (it2_ == it.it2_, external_logic ());
|
|
return it1_ < it.it1_;
|
|
}
|
|
|
|
private:
|
|
size_type it1_;
|
|
size_type it2_;
|
|
|
|
friend class indexed_iterator1<container_type, iterator_category>;
|
|
};
|
|
|
|
/** \brief A class implementing an indexed random access iterator
|
|
* of a matrix.
|
|
*
|
|
* \param C the (mutable) container type
|
|
* \param IC the iterator category
|
|
*
|
|
* This class implements a random access iterator. The current
|
|
* position is stored as two unsigned integers \c it1_ and \c it2_
|
|
* and the values are accessed via \c operator()(it1_, it2_) of the
|
|
* container. The iterator changes the second index.
|
|
*
|
|
* uBLAS extension: \c index1(), \c index2() and access to the
|
|
* dual iterator via \c begin(), \c end(), \c rbegin() and \c rend()
|
|
*
|
|
* Note: The container has to support the find1(rank, i, j) method
|
|
*/
|
|
template<class C, class IC>
|
|
class indexed_iterator2:
|
|
public container_reference<C>,
|
|
public random_access_iterator_base<IC,
|
|
indexed_iterator2<C, IC>,
|
|
typename C::value_type,
|
|
typename C::difference_type> {
|
|
public:
|
|
typedef C container_type;
|
|
typedef IC iterator_category;
|
|
typedef typename container_type::size_type size_type;
|
|
typedef typename container_type::difference_type difference_type;
|
|
typedef typename container_type::value_type value_type;
|
|
typedef typename container_type::reference reference;
|
|
|
|
typedef indexed_iterator1<container_type, iterator_category> dual_iterator_type;
|
|
typedef reverse_iterator_base1<dual_iterator_type> dual_reverse_iterator_type;
|
|
|
|
// Construction and destruction
|
|
BOOST_UBLAS_INLINE
|
|
indexed_iterator2 ():
|
|
container_reference<container_type> (), it1_ (), it2_ () {}
|
|
BOOST_UBLAS_INLINE
|
|
indexed_iterator2 (container_type &c, size_type it1, size_type it2):
|
|
container_reference<container_type> (c), it1_ (it1), it2_ (it2) {}
|
|
|
|
// Arithmetic
|
|
BOOST_UBLAS_INLINE
|
|
indexed_iterator2 &operator ++ () {
|
|
++ it2_;
|
|
return *this;
|
|
}
|
|
BOOST_UBLAS_INLINE
|
|
indexed_iterator2 &operator -- () {
|
|
-- it2_;
|
|
return *this;
|
|
}
|
|
BOOST_UBLAS_INLINE
|
|
indexed_iterator2 &operator += (difference_type n) {
|
|
it2_ += n;
|
|
return *this;
|
|
}
|
|
BOOST_UBLAS_INLINE
|
|
indexed_iterator2 &operator -= (difference_type n) {
|
|
it2_ -= n;
|
|
return *this;
|
|
}
|
|
BOOST_UBLAS_INLINE
|
|
difference_type operator - (const indexed_iterator2 &it) const {
|
|
BOOST_UBLAS_CHECK (&(*this) () == &it (), external_logic ());
|
|
BOOST_UBLAS_CHECK (it1_ == it.it1_, external_logic ());
|
|
return it2_ - it.it2_;
|
|
}
|
|
|
|
// Dereference
|
|
BOOST_UBLAS_INLINE
|
|
reference operator * () const {
|
|
BOOST_UBLAS_CHECK (index1 () < (*this) ().size1 (), bad_index ());
|
|
BOOST_UBLAS_CHECK (index2 () < (*this) ().size2 (), bad_index ());
|
|
return (*this) () (it1_, it2_);
|
|
}
|
|
BOOST_UBLAS_INLINE
|
|
reference operator [] (difference_type n) const {
|
|
return *((*this) + n);
|
|
}
|
|
|
|
// Index
|
|
BOOST_UBLAS_INLINE
|
|
size_type index1 () const {
|
|
return it1_;
|
|
}
|
|
BOOST_UBLAS_INLINE
|
|
size_type index2 () const {
|
|
return it2_;
|
|
}
|
|
|
|
BOOST_UBLAS_INLINE
|
|
dual_iterator_type begin () const {
|
|
return (*this) ().find1 (1, 0, index2 ());
|
|
}
|
|
BOOST_UBLAS_INLINE
|
|
dual_iterator_type end () const {
|
|
return (*this) ().find1 (1, (*this) ().size1 (), index2 ());
|
|
}
|
|
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 ());
|
|
}
|
|
|
|
// Assignment
|
|
BOOST_UBLAS_INLINE
|
|
indexed_iterator2 &operator = (const indexed_iterator2 &it) {
|
|
// FIX: ICC needs full qualification?!
|
|
// assign (&it ());
|
|
container_reference<C>::assign (&it ());
|
|
it1_ = it.it1_;
|
|
it2_ = it.it2_;
|
|
return *this;
|
|
}
|
|
|
|
// Comparison
|
|
BOOST_UBLAS_INLINE
|
|
bool operator == (const indexed_iterator2 &it) const {
|
|
BOOST_UBLAS_CHECK (&(*this) () == &it (), external_logic ());
|
|
BOOST_UBLAS_CHECK (it1_ == it.it1_, external_logic ());
|
|
return it2_ == it.it2_;
|
|
}
|
|
BOOST_UBLAS_INLINE
|
|
bool operator < (const indexed_iterator2 &it) const {
|
|
BOOST_UBLAS_CHECK (&(*this) () == &it (), external_logic ());
|
|
BOOST_UBLAS_CHECK (it1_ == it.it1_, external_logic ());
|
|
return it2_ < it.it2_;
|
|
}
|
|
|
|
private:
|
|
size_type it1_;
|
|
size_type it2_;
|
|
};
|
|
|
|
/** \brief A class implementing an indexed random access iterator
|
|
* of a matrix.
|
|
*
|
|
* \param C the (immutable) container type
|
|
* \param IC the iterator category
|
|
*
|
|
* This class implements a random access iterator. The current
|
|
* position is stored as two unsigned integers \c it1_ and \c it2_
|
|
* and the values are accessed via \c operator()(it1_, it2_) of the
|
|
* container. The iterator changes the second index.
|
|
*
|
|
* uBLAS extension: \c index1(), \c index2() and access to the
|
|
* dual iterator via \c begin(), \c end(), \c rbegin() and \c rend()
|
|
*
|
|
* Note 1: The container has to support the \c find2(rank, i, j) method
|
|
*
|
|
* Note 2: there is an automatic conversion from
|
|
* \c indexed_iterator2 to \c indexed_const_iterator2
|
|
*/
|
|
|
|
template<class C, class IC>
|
|
class indexed_const_iterator2:
|
|
public container_const_reference<C>,
|
|
public random_access_iterator_base<IC,
|
|
indexed_const_iterator2<C, IC>,
|
|
typename C::value_type,
|
|
typename C::difference_type> {
|
|
public:
|
|
typedef C container_type;
|
|
typedef IC iterator_category;
|
|
typedef typename container_type::size_type size_type;
|
|
typedef typename container_type::difference_type difference_type;
|
|
typedef typename container_type::value_type value_type;
|
|
typedef typename container_type::const_reference reference;
|
|
|
|
typedef indexed_iterator2<container_type, iterator_category> iterator_type;
|
|
typedef indexed_const_iterator1<container_type, iterator_category> dual_iterator_type;
|
|
typedef reverse_iterator_base1<dual_iterator_type> dual_reverse_iterator_type;
|
|
|
|
// Construction and destruction
|
|
BOOST_UBLAS_INLINE
|
|
indexed_const_iterator2 ():
|
|
container_const_reference<container_type> (), it1_ (), it2_ () {}
|
|
BOOST_UBLAS_INLINE
|
|
indexed_const_iterator2 (const container_type &c, size_type it1, size_type it2):
|
|
container_const_reference<container_type> (c), it1_ (it1), it2_ (it2) {}
|
|
BOOST_UBLAS_INLINE
|
|
indexed_const_iterator2 (const iterator_type &it):
|
|
container_const_reference<container_type> (it ()), it1_ (it.index1 ()), it2_ (it.index2 ()) {}
|
|
|
|
// Arithmetic
|
|
BOOST_UBLAS_INLINE
|
|
indexed_const_iterator2 &operator ++ () {
|
|
++ it2_;
|
|
return *this;
|
|
}
|
|
BOOST_UBLAS_INLINE
|
|
indexed_const_iterator2 &operator -- () {
|
|
-- it2_;
|
|
return *this;
|
|
}
|
|
BOOST_UBLAS_INLINE
|
|
indexed_const_iterator2 &operator += (difference_type n) {
|
|
it2_ += n;
|
|
return *this;
|
|
}
|
|
BOOST_UBLAS_INLINE
|
|
indexed_const_iterator2 &operator -= (difference_type n) {
|
|
it2_ -= n;
|
|
return *this;
|
|
}
|
|
BOOST_UBLAS_INLINE
|
|
difference_type operator - (const indexed_const_iterator2 &it) const {
|
|
BOOST_UBLAS_CHECK (&(*this) () == &it (), external_logic ());
|
|
BOOST_UBLAS_CHECK (it1_ == it.it1_, external_logic ());
|
|
return it2_ - it.it2_;
|
|
}
|
|
|
|
// Dereference
|
|
BOOST_UBLAS_INLINE
|
|
reference operator * () const {
|
|
BOOST_UBLAS_CHECK (index1 () < (*this) ().size1 (), bad_index ());
|
|
BOOST_UBLAS_CHECK (index2 () < (*this) ().size2 (), bad_index ());
|
|
return (*this) () (it1_, it2_);
|
|
}
|
|
BOOST_UBLAS_INLINE
|
|
reference operator [] (difference_type n) const {
|
|
return *((*this) + n);
|
|
}
|
|
|
|
// Index
|
|
BOOST_UBLAS_INLINE
|
|
size_type index1 () const {
|
|
return it1_;
|
|
}
|
|
BOOST_UBLAS_INLINE
|
|
size_type index2 () const {
|
|
return it2_;
|
|
}
|
|
|
|
BOOST_UBLAS_INLINE
|
|
dual_iterator_type begin () const {
|
|
return (*this) ().find1 (1, 0, index2 ());
|
|
}
|
|
BOOST_UBLAS_INLINE
|
|
dual_iterator_type end () const {
|
|
return (*this) ().find1 (1, (*this) ().size1 (), index2 ());
|
|
}
|
|
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 ());
|
|
}
|
|
|
|
// Assignment
|
|
BOOST_UBLAS_INLINE
|
|
indexed_const_iterator2 &operator = (const indexed_const_iterator2 &it) {
|
|
// FIX: ICC needs full qualification?!
|
|
// assign (&it ());
|
|
container_const_reference<C>::assign (&it ());
|
|
it1_ = it.it1_;
|
|
it2_ = it.it2_;
|
|
return *this;
|
|
}
|
|
|
|
// Comparison
|
|
BOOST_UBLAS_INLINE
|
|
bool operator == (const indexed_const_iterator2 &it) const {
|
|
BOOST_UBLAS_CHECK (&(*this) () == &it (), external_logic ());
|
|
BOOST_UBLAS_CHECK (it1_ == it.it1_, external_logic ());
|
|
return it2_ == it.it2_;
|
|
}
|
|
BOOST_UBLAS_INLINE
|
|
bool operator < (const indexed_const_iterator2 &it) const {
|
|
BOOST_UBLAS_CHECK (&(*this) () == &it (), external_logic ());
|
|
BOOST_UBLAS_CHECK (it1_ == it.it1_, external_logic ());
|
|
return it2_ < it.it2_;
|
|
}
|
|
|
|
private:
|
|
size_type it1_;
|
|
size_type it2_;
|
|
|
|
friend class indexed_iterator2<container_type, iterator_category>;
|
|
};
|
|
|
|
}}}
|
|
|
|
#endif
|