Chris@16: //
Chris@16: //  Copyright (c) 2000-2002
Chris@16: //  Joerg Walter, Mathias Koch
Chris@16: //
Chris@16: //  Distributed under the Boost Software License, Version 1.0. (See
Chris@16: //  accompanying file LICENSE_1_0.txt or copy at
Chris@16: //  http://www.boost.org/LICENSE_1_0.txt)
Chris@16: //
Chris@16: //  The authors gratefully acknowledge the support of
Chris@16: //  GeNeSys mbH & Co. KG in producing this work.
Chris@16: //
Chris@16: 
Chris@16: #ifndef BOOST_UBLAS_STORAGE_H
Chris@16: #define BOOST_UBLAS_STORAGE_H
Chris@16: 
Chris@16: #include <algorithm>
Chris@16: #ifdef BOOST_UBLAS_SHALLOW_ARRAY_ADAPTOR
Chris@16: #include <boost/shared_array.hpp>
Chris@16: #endif
Chris@16: 
Chris@16: #include <boost/serialization/array.hpp>
Chris@16: #include <boost/serialization/collection_size_type.hpp>
Chris@16: #include <boost/serialization/nvp.hpp>
Chris@16: 
Chris@16: #include <boost/numeric/ublas/exception.hpp>
Chris@16: #include <boost/numeric/ublas/traits.hpp>
Chris@16: #include <boost/numeric/ublas/detail/iterator.hpp>
Chris@16: 
Chris@16: 
Chris@16: namespace boost { namespace numeric { namespace ublas {
Chris@16: 
Chris@16: 
Chris@16:     // Base class for Storage Arrays - see the Barton Nackman trick
Chris@16:     template<class E>
Chris@16:     class storage_array:
Chris@16:         private nonassignable {
Chris@16:     };
Chris@16: 
Chris@16: 
Chris@16:     // Unbounded array - with allocator
Chris@16:     template<class T, class ALLOC>
Chris@16:     class unbounded_array:
Chris@16:         public storage_array<unbounded_array<T, ALLOC> > {
Chris@16: 
Chris@16:         typedef unbounded_array<T, ALLOC> self_type;
Chris@16:     public:
Chris@16:         typedef ALLOC allocator_type;
Chris@16:         typedef typename ALLOC::size_type size_type;
Chris@16:         typedef typename ALLOC::difference_type difference_type;
Chris@16:         typedef T value_type;
Chris@16:         typedef const T &const_reference;
Chris@16:         typedef T &reference;
Chris@16:         typedef const T *const_pointer;
Chris@16:         typedef T *pointer;
Chris@16:         typedef const_pointer const_iterator;
Chris@16:         typedef pointer iterator;
Chris@16: 
Chris@16:         // Construction and destruction
Chris@16:         explicit BOOST_UBLAS_INLINE
Chris@16:         unbounded_array (const ALLOC &a = ALLOC()):
Chris@16:             alloc_ (a), size_ (0) {
Chris@16:             data_ = 0;
Chris@16:         }
Chris@16:         explicit BOOST_UBLAS_INLINE
Chris@16:         unbounded_array (size_type size, const ALLOC &a = ALLOC()):
Chris@16:             alloc_(a), size_ (size) {
Chris@16:           if (size_) {
Chris@16:               data_ = alloc_.allocate (size_);
Chris@16:               if (! detail::has_trivial_constructor<T>::value) {
Chris@16:                   for (pointer d = data_; d != data_ + size_; ++d)
Chris@16:                       alloc_.construct(d, value_type());
Chris@16:               }
Chris@16:           }
Chris@16:           else
Chris@16:               data_ = 0;
Chris@16:         }
Chris@16:         // No value initialised, but still be default constructed
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         unbounded_array (size_type size, const value_type &init, const ALLOC &a = ALLOC()):
Chris@16:             alloc_ (a), size_ (size) {
Chris@16:             if (size_) {
Chris@16:                 data_ = alloc_.allocate (size_);
Chris@16:                 std::uninitialized_fill (begin(), end(), init);
Chris@16:             }
Chris@16:             else
Chris@16:                 data_ = 0;
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         unbounded_array (const unbounded_array &c):
Chris@16:             storage_array<unbounded_array<T, ALLOC> >(),
Chris@16:             alloc_ (c.alloc_), size_ (c.size_) {
Chris@16:             if (size_) {
Chris@16:                 data_ = alloc_.allocate (size_);
Chris@16:                 std::uninitialized_copy (c.begin(), c.end(), begin());
Chris@16:             }
Chris@16:             else
Chris@16:                 data_ = 0;
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         ~unbounded_array () {
Chris@16:             if (size_) {
Chris@16:                 if (! detail::has_trivial_destructor<T>::value) {
Chris@16:                     // std::_Destroy (begin(), end(), alloc_);
Chris@16:                     const iterator i_end = end();
Chris@16:                     for (iterator i = begin (); i != i_end; ++i) {
Chris@16:                         iterator_destroy (i); 
Chris@16:                     }
Chris@16:                 }
Chris@16:                 alloc_.deallocate (data_, size_);
Chris@16:             }
Chris@16:         }
Chris@16: 
Chris@16:         // Resizing
Chris@16:     private:
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         void resize_internal (const size_type size, const value_type init, const bool preserve) {
Chris@16:             if (size != size_) {
Chris@16:                 pointer p_data = data_;
Chris@16:                 if (size) {
Chris@16:                     data_ = alloc_.allocate (size);
Chris@16:                     if (preserve) {
Chris@16:                         pointer si = p_data;
Chris@16:                         pointer di = data_;
Chris@16:                         if (size < size_) {
Chris@16:                             for (; di != data_ + size; ++di) {
Chris@16:                                 alloc_.construct (di, *si);
Chris@16:                                 ++si;
Chris@16:                             }
Chris@16:                         }
Chris@16:                         else {
Chris@101:                             for (; si != p_data + size_; ++si) {
Chris@16:                                 alloc_.construct (di, *si);
Chris@16:                                 ++di;
Chris@16:                             }
Chris@16:                             for (; di != data_ + size; ++di) {
Chris@16:                                 alloc_.construct (di, init);
Chris@16:                             }
Chris@16:                         }
Chris@16:                     }
Chris@16:                     else {
Chris@16:                         if (! detail::has_trivial_constructor<T>::value) {
Chris@16:                             for (pointer di = data_; di != data_ + size; ++di)
Chris@16:                                 alloc_.construct (di, value_type());
Chris@16:                         }
Chris@16:                     }
Chris@16:                 }
Chris@16: 
Chris@16:                 if (size_) {
Chris@16:                     if (! detail::has_trivial_destructor<T>::value) {
Chris@16:                         for (pointer si = p_data; si != p_data + size_; ++si)
Chris@16:                             alloc_.destroy (si);
Chris@16:                     }
Chris@16:                     alloc_.deallocate (p_data, size_);
Chris@16:                 }
Chris@16: 
Chris@16:                 if (!size)
Chris@16:                     data_ = 0;
Chris@16:                 size_ = size;
Chris@16:             }
Chris@16:         }
Chris@16:     public:
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         void resize (size_type size) {
Chris@16:             resize_internal (size, value_type (), false);
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         void resize (size_type size, value_type init) {
Chris@16:             resize_internal (size, init, true);
Chris@16:         }
Chris@16:                     
Chris@16:         // Random Access Container
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         size_type max_size () const {
Chris@16:             return ALLOC ().max_size();
Chris@16:         }
Chris@16:         
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         bool empty () const {
Chris@16:             return size_ == 0;
Chris@16:         }
Chris@16:             
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         size_type size () const {
Chris@16:             return size_;
Chris@16:         }
Chris@16: 
Chris@16:         // Element access
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         const_reference operator [] (size_type i) const {
Chris@16:             BOOST_UBLAS_CHECK (i < size_, bad_index ());
Chris@16:             return data_ [i];
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         reference operator [] (size_type i) {
Chris@16:             BOOST_UBLAS_CHECK (i < size_, bad_index ());
Chris@16:             return data_ [i];
Chris@16:         }
Chris@16: 
Chris@16:         // Assignment
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         unbounded_array &operator = (const unbounded_array &a) {
Chris@16:             if (this != &a) {
Chris@16:                 resize (a.size_);
Chris@16:                 std::copy (a.data_, a.data_ + a.size_, data_);
Chris@16:             }
Chris@16:             return *this;
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         unbounded_array &assign_temporary (unbounded_array &a) {
Chris@16:             swap (a);
Chris@16:             return *this;
Chris@16:         }
Chris@16: 
Chris@16:         // Swapping
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         void swap (unbounded_array &a) {
Chris@16:             if (this != &a) {
Chris@16:                 std::swap (size_, a.size_);
Chris@16:                 std::swap (data_, a.data_);
Chris@16:             }
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         friend void swap (unbounded_array &a1, unbounded_array &a2) {
Chris@16:             a1.swap (a2);
Chris@16:         }
Chris@16: 
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         const_iterator begin () const {
Chris@16:             return data_;
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@101:         const_iterator cbegin () const {
Chris@101:             return begin ();
Chris@101:         }
Chris@101:         BOOST_UBLAS_INLINE
Chris@16:         const_iterator end () const {
Chris@16:             return data_ + size_;
Chris@16:         }
Chris@101:         BOOST_UBLAS_INLINE
Chris@101:         const_iterator cend () const {
Chris@101:             return end ();
Chris@101:         }
Chris@16: 
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         iterator begin () {
Chris@16:             return data_;
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         iterator end () {
Chris@16:             return data_ + size_;
Chris@16:         }
Chris@16: 
Chris@16:         // Reverse iterators
Chris@16:         typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
Chris@16:         typedef std::reverse_iterator<iterator> reverse_iterator;
Chris@16: 
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         const_reverse_iterator rbegin () const {
Chris@16:             return const_reverse_iterator (end ());
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@101:         const_reverse_iterator crbegin () const {
Chris@101:             return rbegin ();
Chris@101:         }
Chris@101:         BOOST_UBLAS_INLINE
Chris@16:         const_reverse_iterator rend () const {
Chris@16:             return const_reverse_iterator (begin ());
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@101:         const_reverse_iterator crend () const {
Chris@101:             return rend ();
Chris@101:         }
Chris@101:         BOOST_UBLAS_INLINE
Chris@16:         reverse_iterator rbegin () {
Chris@16:             return reverse_iterator (end ());
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         reverse_iterator rend () {
Chris@16:             return reverse_iterator (begin ());
Chris@16:         }
Chris@16: 
Chris@16:         // Allocator
Chris@16:         allocator_type get_allocator () {
Chris@16:             return alloc_;
Chris@16:         }
Chris@16: 
Chris@16:     private:
Chris@16:         friend class boost::serialization::access;
Chris@16: 
Chris@16:         // Serialization
Chris@16:         template<class Archive>
Chris@101:         void serialize(Archive & ar, const unsigned int /*version*/)
Chris@16:         { 
Chris@16:             serialization::collection_size_type s(size_);
Chris@16:             ar & serialization::make_nvp("size",s);
Chris@16:             if ( Archive::is_loading::value ) {
Chris@16:                 resize(s);
Chris@16:             }
Chris@16:             ar & serialization::make_array(data_, s);
Chris@16:         }
Chris@16: 
Chris@16:     private:
Chris@16:         // Handle explict destroy on a (possibly indexed) iterator
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         static void iterator_destroy (iterator &i) {
Chris@16:             (&(*i)) -> ~value_type ();
Chris@16:         }
Chris@16:         ALLOC alloc_;
Chris@16:         size_type size_;
Chris@16:         pointer data_;
Chris@16:     };
Chris@16: 
Chris@16:     // Bounded array - with allocator for size_type and difference_type
Chris@16:     template<class T, std::size_t N, class ALLOC>
Chris@16:     class bounded_array:
Chris@16:         public storage_array<bounded_array<T, N, ALLOC> > {
Chris@16: 
Chris@16:         typedef bounded_array<T, N, ALLOC> self_type;
Chris@16:     public:
Chris@16:         // No allocator_type as ALLOC is not used for allocation
Chris@16:         typedef typename ALLOC::size_type size_type;
Chris@16:         typedef typename ALLOC::difference_type difference_type;
Chris@16:         typedef T value_type;
Chris@16:         typedef const T &const_reference;
Chris@16:         typedef T &reference;
Chris@16:         typedef const T *const_pointer;
Chris@16:         typedef T *pointer;
Chris@16:         typedef const_pointer const_iterator;
Chris@16:         typedef pointer iterator;
Chris@16: 
Chris@16:         // Construction and destruction
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         bounded_array ():
Chris@16:             size_ (0) /*, data_ ()*/ {   // size 0 - use bounded_vector to default construct with size N
Chris@16:         }
Chris@16:         explicit BOOST_UBLAS_INLINE
Chris@16:         bounded_array (size_type size):
Chris@16:             size_ (size) /*, data_ ()*/ {
Chris@16:             BOOST_UBLAS_CHECK (size_ <= N, bad_size ());
Chris@16:             // data_ (an array) elements are already default constructed
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         bounded_array (size_type size, const value_type &init):
Chris@16:             size_ (size) /*, data_ ()*/ {
Chris@16:             BOOST_UBLAS_CHECK (size_ <= N, bad_size ());
Chris@16:             // ISSUE elements should be value constructed here, but we must fill instead as already default constructed
Chris@16:             std::fill (begin(), end(), init) ;
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         bounded_array (const bounded_array &c):
Chris@16:             size_ (c.size_)  {
Chris@16:             // ISSUE elements should be copy constructed here, but we must copy instead as already default constructed
Chris@16:             std::copy (c.begin(), c.end(), begin());
Chris@16:         }
Chris@16:         
Chris@16:         // Resizing
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         void resize (size_type size) {
Chris@16:             BOOST_UBLAS_CHECK (size <= N, bad_size ());
Chris@16:             size_ = size;
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         void resize (size_type size, value_type init) {
Chris@16:             BOOST_UBLAS_CHECK (size <= N, bad_size ());
Chris@16:             if (size > size_)
Chris@16:                 std::fill (data_ + size_, data_ + size, init);
Chris@16:             size_ = size;
Chris@16:         }
Chris@16: 
Chris@16:         // Random Access Container
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         size_type max_size () const {
Chris@101:             return N;
Chris@16:         }
Chris@16:         
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         bool empty () const {
Chris@16:             return size_ == 0;
Chris@16:         }
Chris@16:             
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         size_type size () const {
Chris@16:             return size_;
Chris@16:         }
Chris@16: 
Chris@16:         // Element access
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         const_reference operator [] (size_type i) const {
Chris@16:             BOOST_UBLAS_CHECK (i < size_, bad_index ());
Chris@16:             return data_ [i];
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         reference operator [] (size_type i) {
Chris@16:             BOOST_UBLAS_CHECK (i < size_, bad_index ());
Chris@16:             return data_ [i];
Chris@16:         }
Chris@16: 
Chris@16:         // Assignment
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         bounded_array &operator = (const bounded_array &a) {
Chris@16:             if (this != &a) {
Chris@16:                 resize (a.size_);
Chris@16:                 std::copy (a.data_, a.data_ + a.size_, data_);
Chris@16:             }
Chris@16:             return *this;
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         bounded_array &assign_temporary (bounded_array &a) { 
Chris@16:             *this = a;
Chris@16:             return *this;
Chris@16:         }
Chris@16: 
Chris@16:         // Swapping
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         void swap (bounded_array &a) {
Chris@16:             if (this != &a) {
Chris@16:                 std::swap (size_, a.size_);
Chris@16:                 std::swap_ranges (data_, data_ + (std::max) (size_, a.size_), a.data_);
Chris@16:             }
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         friend void swap (bounded_array &a1, bounded_array &a2) {
Chris@16:             a1.swap (a2);
Chris@16:         }
Chris@16: 
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         const_iterator begin () const {
Chris@16:             return data_;
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@101:         const_iterator cbegin () const {
Chris@101:             return begin ();
Chris@101:         }
Chris@101:         BOOST_UBLAS_INLINE
Chris@16:         const_iterator end () const {
Chris@16:             return data_ + size_;
Chris@16:         }
Chris@101:         BOOST_UBLAS_INLINE
Chris@101:         const_iterator cend () const {
Chris@101:             return end ();
Chris@101:         }
Chris@16: 
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         iterator begin () {
Chris@16:             return data_;
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         iterator end () {
Chris@16:             return data_ + size_;
Chris@16:         }
Chris@16: 
Chris@16:         // Reverse iterators
Chris@16:         typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
Chris@16:         typedef std::reverse_iterator<iterator> reverse_iterator;
Chris@16: 
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         const_reverse_iterator rbegin () const {
Chris@16:             return const_reverse_iterator (end ());
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@101:         const_reverse_iterator crbegin () const {
Chris@101:             return rbegin ();
Chris@101:         }
Chris@101:         BOOST_UBLAS_INLINE
Chris@16:         const_reverse_iterator rend () const {
Chris@16:             return const_reverse_iterator (begin ());
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@101:         const_reverse_iterator crend () const {
Chris@101:             return rend ();
Chris@101:         }
Chris@101:         BOOST_UBLAS_INLINE
Chris@16:         reverse_iterator rbegin () {
Chris@16:             return reverse_iterator (end ());
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         reverse_iterator rend () {
Chris@16:             return reverse_iterator (begin ());
Chris@16:         }
Chris@16: 
Chris@16:     private:
Chris@16:         // Serialization
Chris@16:         friend class boost::serialization::access;
Chris@16: 
Chris@16:         template<class Archive>
Chris@101:         void serialize(Archive & ar, const unsigned int /*version*/)
Chris@16:         {
Chris@16:             serialization::collection_size_type s(size_);
Chris@16:             ar & serialization::make_nvp("size", s);
Chris@16:             if ( Archive::is_loading::value ) {
Chris@16:                 if (s > N) bad_size("too large size in bounded_array::load()\n").raise();
Chris@16:                 resize(s);
Chris@16:             }
Chris@16:             ar & serialization::make_array(data_, s);
Chris@16:         }
Chris@16: 
Chris@16:     private:
Chris@16:         size_type size_;
Chris@16: // MSVC does not like arrays of size 0 in base classes.  Hence, this conditionally changes the size to 1
Chris@16: #ifdef _MSC_VER
Chris@16:         BOOST_UBLAS_BOUNDED_ARRAY_ALIGN value_type data_ [(N>0)?N:1];
Chris@16: #else
Chris@16:         BOOST_UBLAS_BOUNDED_ARRAY_ALIGN value_type data_ [N];
Chris@16: #endif
Chris@16:     };
Chris@16: 
Chris@16: 
Chris@16:     // Array adaptor with normal deep copy semantics of elements
Chris@16:     template<class T>
Chris@16:     class array_adaptor:
Chris@16:         public storage_array<array_adaptor<T> > {
Chris@16: 
Chris@16:         typedef array_adaptor<T> self_type;
Chris@16:     public:
Chris@16:         typedef std::size_t size_type;
Chris@16:         typedef std::ptrdiff_t difference_type;
Chris@16:         typedef T value_type;
Chris@16:         typedef const T &const_reference;
Chris@16:         typedef T &reference;
Chris@16:         typedef const T *const_pointer;
Chris@16:         typedef T *pointer;
Chris@16: 
Chris@16:         // Construction and destruction
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         array_adaptor ():
Chris@16:             size_ (0), own_ (true), data_ (new value_type [0]) {
Chris@16:         }
Chris@16:         explicit BOOST_UBLAS_INLINE
Chris@16:         array_adaptor (size_type size):
Chris@16:             size_ (size), own_ (true), data_ (new value_type [size]) {
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         array_adaptor (size_type size, const value_type &init):
Chris@16:             size_ (size), own_ (true), data_ (new value_type [size]) {
Chris@16:             std::fill (data_, data_ + size_, init);
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         array_adaptor (size_type size, pointer data):
Chris@16:             size_ (size), own_ (false), data_ (data) {}
Chris@101: 
Chris@101:         template <size_t N>
Chris@101:         BOOST_UBLAS_INLINE array_adaptor (T (&data)[N]):
Chris@101:             size_ (N), own_ (false), data_ (data) {}
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         array_adaptor (const array_adaptor &a):
Chris@16:             storage_array<self_type> (),
Chris@16:             size_ (a.size_), own_ (true), data_ (new value_type [a.size_]) {
Chris@16:             *this = a;
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         ~array_adaptor () {
Chris@16:             if (own_) {
Chris@16:                 delete [] data_;
Chris@16:             }
Chris@16:         }
Chris@16: 
Chris@16:         // Resizing
Chris@16:     private:
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         void resize_internal (size_type size, value_type init, bool preserve = true) {
Chris@16:            if (size != size_) {
Chris@16:                 pointer data = new value_type [size];
Chris@16:                 if (preserve) {
Chris@16:                     std::copy (data_, data_ + (std::min) (size, size_), data);
Chris@16:                     std::fill (data + (std::min) (size, size_), data + size, init);
Chris@16:                 }
Chris@16:                 if (own_)
Chris@16:                     delete [] data_;
Chris@16:                 size_ = size;
Chris@16:                 own_ = true;
Chris@16:                 data_ = data;
Chris@16:             }
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         void resize_internal (size_type size, pointer data, value_type init, bool preserve = true) {
Chris@16:             if (data != data_) {
Chris@16:                 if (preserve) {
Chris@16:                     std::copy (data_, data_ + (std::min) (size, size_), data);
Chris@16:                     std::fill (data + (std::min) (size, size_), data + size, init);
Chris@16:                 }
Chris@16:                 if (own_)
Chris@16:                     delete [] data_;
Chris@16:                 own_ = false;
Chris@16:                 data_ = data;
Chris@16:             }
Chris@16:             else {
Chris@16:                 std::fill (data + (std::min) (size, size_), data + size, init);
Chris@16:             }
Chris@16:             size_ = size;
Chris@16:         }
Chris@16:     public:
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         void resize (size_type size) {
Chris@16:             resize_internal (size, value_type (), false);
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         void resize (size_type size, value_type init) {
Chris@16:             resize_internal (size, init, true);
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         void resize (size_type size, pointer data) {
Chris@16:             resize_internal (size, data, value_type (), false);
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         void resize (size_type size, pointer data, value_type init) {
Chris@16:             resize_internal (size, data, init, true);
Chris@16:         }
Chris@16: 
Chris@101:         template <size_t N>
Chris@101:         BOOST_UBLAS_INLINE void resize (T (&data)[N]) {
Chris@101:             resize_internal (N, data, value_type (), false);
Chris@101:         }
Chris@101: 
Chris@101:         template <size_t N>
Chris@101:         BOOST_UBLAS_INLINE void resize (T (&data)[N], value_type init) {
Chris@101:             resize_internal (N, data, init, true);
Chris@101:         }
Chris@101: 
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         size_type size () const {
Chris@16:             return size_;
Chris@16:         }
Chris@16: 
Chris@16:         // Element access
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         const_reference operator [] (size_type i) const {
Chris@16:             BOOST_UBLAS_CHECK (i < size_, bad_index ());
Chris@16:             return data_ [i];
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         reference operator [] (size_type i) {
Chris@16:             BOOST_UBLAS_CHECK (i < size_, bad_index ());
Chris@16:             return data_ [i];
Chris@16:         }
Chris@16: 
Chris@16:         // Assignment
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         array_adaptor &operator = (const array_adaptor &a) {
Chris@16:             if (this != &a) {
Chris@16:                 resize (a.size_);
Chris@16:                 std::copy (a.data_, a.data_ + a.size_, data_);
Chris@16:             }
Chris@16:             return *this;
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         array_adaptor &assign_temporary (array_adaptor &a) {
Chris@16:             if (own_ && a.own_)
Chris@16:                 swap (a);
Chris@16:             else
Chris@16:                 *this = a;
Chris@16:             return *this;
Chris@16:         }
Chris@16: 
Chris@16:         // Swapping
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         void swap (array_adaptor &a) {
Chris@16:             if (this != &a) {
Chris@16:                 std::swap (size_, a.size_);
Chris@16:                 std::swap (own_, a.own_);
Chris@16:                 std::swap (data_, a.data_);
Chris@16:             }
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         friend void swap (array_adaptor &a1, array_adaptor &a2) {
Chris@16:             a1.swap (a2);
Chris@16:         }
Chris@16: 
Chris@16:         // Iterators simply are pointers.
Chris@16: 
Chris@16:         typedef const_pointer const_iterator;
Chris@16: 
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         const_iterator begin () const {
Chris@16:             return data_;
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@101:         const_iterator cbegin () const {
Chris@101:             return begin ();
Chris@101:         }
Chris@101:         BOOST_UBLAS_INLINE
Chris@16:         const_iterator end () const {
Chris@16:             return data_ + size_;
Chris@16:         }
Chris@101:         BOOST_UBLAS_INLINE
Chris@101:         const_iterator cend () const {
Chris@101:             return end ();
Chris@101:         }
Chris@16: 
Chris@16:         typedef pointer iterator;
Chris@16: 
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         iterator begin () {
Chris@16:             return data_;
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         iterator end () {
Chris@16:             return data_ + size_;
Chris@16:         }
Chris@16: 
Chris@16:         // Reverse iterators
Chris@16:         typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
Chris@16:         typedef std::reverse_iterator<iterator> reverse_iterator;
Chris@16: 
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         const_reverse_iterator rbegin () const {
Chris@16:             return const_reverse_iterator (end ());
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@101:         const_reverse_iterator crbegin () const {
Chris@101:             return rbegin ();
Chris@101:         }
Chris@101:         BOOST_UBLAS_INLINE
Chris@16:         const_reverse_iterator rend () const {
Chris@16:             return const_reverse_iterator (begin ());
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@101:         const_reverse_iterator crend () const {
Chris@101:             return rend ();
Chris@101:         }
Chris@101:         BOOST_UBLAS_INLINE
Chris@16:         reverse_iterator rbegin () {
Chris@16:             return reverse_iterator (end ());
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         reverse_iterator rend () {
Chris@16:             return reverse_iterator (begin ());
Chris@16:         }
Chris@16: 
Chris@16:     private:
Chris@16:         size_type size_;
Chris@16:         bool own_;
Chris@16:         pointer data_;
Chris@16:     };
Chris@16: 
Chris@16: #ifdef BOOST_UBLAS_SHALLOW_ARRAY_ADAPTOR
Chris@16:     // Array adaptor with shallow (reference) copy semantics of elements.
Chris@16:     // shared_array is used to maintain reference counts.
Chris@16:     // This class breaks the normal copy semantics for a storage container and is very dangerous!
Chris@16:     template<class T>
Chris@16:     class shallow_array_adaptor:
Chris@16:         public storage_array<shallow_array_adaptor<T> > {
Chris@16: 
Chris@16:         typedef shallow_array_adaptor<T> self_type;
Chris@16: 
Chris@16:         template<class TT>
Chris@16:         struct leaker {
Chris@16:             typedef void result_type;
Chris@16:             typedef TT *argument_type;
Chris@16: 
Chris@16:             BOOST_UBLAS_INLINE
Chris@101:             result_type operator () (argument_type /* x */) {}
Chris@16:         };
Chris@16: 
Chris@16:     public:
Chris@16:         typedef std::size_t size_type;
Chris@16:         typedef std::ptrdiff_t difference_type;
Chris@16:         typedef T value_type;
Chris@16:         typedef const T &const_reference;
Chris@16:         typedef T &reference;
Chris@16:         typedef const T *const_pointer;
Chris@16:         typedef T *pointer;
Chris@16: 
Chris@16:         // Construction and destruction
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         shallow_array_adaptor ():
Chris@16:             size_ (0), own_ (true), data_ (new value_type [0]) {
Chris@16:         }
Chris@16:         explicit BOOST_UBLAS_INLINE
Chris@16:         shallow_array_adaptor (size_type size):
Chris@16:             size_ (size), own_ (true), data_ (new value_type [size]) {
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         shallow_array_adaptor (size_type size, const value_type &init):
Chris@16:             size_ (size), own_ (true), data_ (new value_type [size]) {
Chris@16:             std::fill (data_.get (), data_.get () + size_, init);
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         shallow_array_adaptor (size_type size, pointer data):
Chris@16:             size_ (size), own_ (false), data_ (data, leaker<value_type> ()) {}
Chris@101:         BOOST_UBLAS_INLINE
Chris@101:         template <size_t N>
Chris@101:         shallow_array_adaptor (T (&data)[N]):
Chris@101:             size_ (N), own_ (false), data_ (data, leaker<value_type> ()) {}
Chris@16: 
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         shallow_array_adaptor (const shallow_array_adaptor &a):
Chris@16:             storage_array<self_type> (),
Chris@16:             size_ (a.size_), own_ (a.own_), data_ (a.data_) {}
Chris@16: 
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         ~shallow_array_adaptor () {
Chris@16:         }
Chris@16: 
Chris@16:         // Resizing
Chris@16:     private:
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         void resize_internal (size_type size, value_type init, bool preserve = true) {
Chris@16:             if (size != size_) {
Chris@16:                 shared_array<value_type> data (new value_type [size]);
Chris@16:                 if (preserve) {
Chris@16:                     std::copy (data_.get (), data_.get () + (std::min) (size, size_), data.get ());
Chris@16:                     std::fill (data.get () + (std::min) (size, size_), data.get () + size, init);
Chris@16:                 }
Chris@16:                 size_ = size;
Chris@101:                 own_ = true;
Chris@16:                 data_ = data;
Chris@16:             }
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         void resize_internal (size_type size, pointer data, value_type init, bool preserve = true) {
Chris@16:             if (preserve) {
Chris@16:                 std::copy (data_.get (), data_.get () + (std::min) (size, size_), data);
Chris@16:                 std::fill (data + (std::min) (size, size_), data + size, init);
Chris@16:             }
Chris@16:             size_ = size;
Chris@101:             own_ = false;
Chris@101:             data_.reset(data, leaker<value_type> ());
Chris@16:         }
Chris@16:     public:
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         void resize (size_type size) {
Chris@16:             resize_internal (size, value_type (), false);
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         void resize (size_type size, value_type init) {
Chris@16:             resize_internal (size, init, true);
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         void resize (size_type size, pointer data) {
Chris@16:             resize_internal (size, data, value_type (), false);
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         void resize (size_type size, pointer data, value_type init) {
Chris@16:             resize_internal (size, data, init, true);
Chris@16:         }
Chris@101:         BOOST_UBLAS_INLINE
Chris@101:         template <size_t N>
Chris@101:         void resize (T (&data)[N]) {
Chris@101:             resize_internal (N, data, value_type (), false);
Chris@101:         }
Chris@101:         BOOST_UBLAS_INLINE
Chris@101:         template <size_t N>
Chris@101:         void resize (T (&data)[N], value_type init) {
Chris@101:             resize_internal (N, data, init, true);
Chris@101:         }
Chris@16: 
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         size_type size () const {
Chris@16:             return size_;
Chris@16:         }
Chris@16: 
Chris@16:         // Element access
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         const_reference operator [] (size_type i) const {
Chris@16:             BOOST_UBLAS_CHECK (i < size_, bad_index ());
Chris@16:             return data_ [i];
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         reference operator [] (size_type i) {
Chris@16:             BOOST_UBLAS_CHECK (i < size_, bad_index ());
Chris@16:             return data_ [i];
Chris@16:         }
Chris@16: 
Chris@16:         // Assignment
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         shallow_array_adaptor &operator = (const shallow_array_adaptor &a) {
Chris@16:             if (this != &a) {
Chris@16:                 resize (a.size_);
Chris@16:                 std::copy (a.data_.get (), a.data_.get () + a.size_, data_.get ());
Chris@16:             }
Chris@16:             return *this;
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         shallow_array_adaptor &assign_temporary (shallow_array_adaptor &a) {
Chris@16:             if (own_ && a.own_)
Chris@16:                 swap (a);
Chris@16:             else
Chris@16:                 *this = a;
Chris@16:             return *this;
Chris@16:         }
Chris@16: 
Chris@16:         // Swapping
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         void swap (shallow_array_adaptor &a) {
Chris@16:             if (this != &a) {
Chris@16:                 std::swap (size_, a.size_);
Chris@16:                 std::swap (own_, a.own_);
Chris@16:                 std::swap (data_, a.data_);
Chris@16:             }
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         friend void swap (shallow_array_adaptor &a1, shallow_array_adaptor &a2) {
Chris@16:             a1.swap (a2);
Chris@16:         }
Chris@16: 
Chris@16:         // Iterators simply are pointers.
Chris@16: 
Chris@16:         typedef const_pointer const_iterator;
Chris@16: 
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         const_iterator begin () const {
Chris@16:             return data_.get ();
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@101:         const_iterator cbegin () const {
Chris@101:             return begin ();
Chris@101:         }
Chris@101:         BOOST_UBLAS_INLINE
Chris@16:         const_iterator end () const {
Chris@16:             return data_.get () + size_;
Chris@16:         }
Chris@101:         BOOST_UBLAS_INLINE
Chris@101:         const_iterator cend () const {
Chris@101:             return end ();
Chris@101:         }
Chris@16: 
Chris@16:         typedef pointer iterator;
Chris@16: 
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         iterator begin () {
Chris@16:             return data_.get ();
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         iterator end () {
Chris@16:             return data_.get () + size_;
Chris@16:         }
Chris@16: 
Chris@16:         // Reverse iterators
Chris@16:         typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
Chris@16:         typedef std::reverse_iterator<iterator> reverse_iterator;
Chris@16: 
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         const_reverse_iterator rbegin () const {
Chris@16:             return const_reverse_iterator (end ());
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@101:         const_reverse_iterator crbegin () const {
Chris@101:             return rbegin ();
Chris@101:         }
Chris@101:         BOOST_UBLAS_INLINE
Chris@16:         const_reverse_iterator rend () const {
Chris@16:             return const_reverse_iterator (begin ());
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@101:         const_reverse_iterator crend () const {
Chris@101:             return rend ();
Chris@101:         }
Chris@101:         BOOST_UBLAS_INLINE
Chris@16:         reverse_iterator rbegin () {
Chris@16:             return reverse_iterator (end ());
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         reverse_iterator rend () {
Chris@16:             return reverse_iterator (begin ());
Chris@16:         }
Chris@16: 
Chris@16:     private:
Chris@16:         size_type size_;
Chris@16:         bool own_;
Chris@16:         shared_array<value_type> data_;
Chris@16:     };
Chris@16: 
Chris@16: #endif
Chris@16: 
Chris@16: 
Chris@16:     // Range class
Chris@16:     template <class Z, class D>
Chris@16:     class basic_range {
Chris@16:         typedef basic_range<Z, D> self_type;
Chris@16:     public:
Chris@16:         typedef Z size_type;
Chris@16:         typedef D difference_type;
Chris@16:         typedef size_type value_type;
Chris@16:         typedef value_type const_reference;
Chris@16:         typedef const_reference reference;
Chris@16:         typedef const value_type *const_pointer;
Chris@16:         typedef value_type *pointer;
Chris@16: 
Chris@16:         // Construction and destruction
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         basic_range ():
Chris@16:             start_ (0), size_ (0) {}
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         basic_range (size_type start, size_type stop):
Chris@16:             start_ (start), size_ (stop - start) {
Chris@16:             BOOST_UBLAS_CHECK (start_ <= stop, bad_index ());
Chris@16:         }
Chris@16: 
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         size_type start () const {
Chris@16:             return start_;
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         size_type size () const {
Chris@16:             return size_;
Chris@16:         }
Chris@16: 
Chris@16:         // Random Access Container
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         size_type max_size () const {
Chris@16:             return size_;
Chris@16:         }
Chris@16:         
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         bool empty () const {
Chris@16:             return size_ == 0;
Chris@16:         }
Chris@16:             
Chris@16:         // Element access
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         const_reference operator () (size_type i) const {
Chris@16:             BOOST_UBLAS_CHECK (i < size_, bad_index ());
Chris@16:             return start_ + i;
Chris@16:         }
Chris@16: 
Chris@16:         // Composition
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         basic_range compose (const basic_range &r) const {
Chris@16:             return basic_range (start_ + r.start_, start_ + r.start_ + r.size_);
Chris@16:         }
Chris@16: 
Chris@16:         // Comparison
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         bool operator == (const basic_range &r) const {
Chris@16:             return start_ == r.start_ && size_ == r.size_;
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         bool operator != (const basic_range &r) const {
Chris@16:             return ! (*this == r);
Chris@16:         }
Chris@16: 
Chris@16:         // Iterator types
Chris@16:     private:
Chris@16:         // Use and index
Chris@16:         typedef size_type const_subiterator_type;
Chris@16: 
Chris@16:     public:
Chris@16: #ifdef BOOST_UBLAS_USE_INDEXED_ITERATOR
Chris@16:         typedef indexed_const_iterator<self_type, std::random_access_iterator_tag> const_iterator;
Chris@16: #else
Chris@16:         class const_iterator:
Chris@16:             public container_const_reference<basic_range>,
Chris@16:             public random_access_iterator_base<std::random_access_iterator_tag,
Chris@16:                                                const_iterator, value_type> {
Chris@16:         public:
Chris@16:             typedef typename basic_range::value_type value_type;
Chris@16:             typedef typename basic_range::difference_type difference_type;
Chris@16:             typedef typename basic_range::const_reference reference;
Chris@16:             typedef typename basic_range::const_pointer pointer;
Chris@16: 
Chris@16:             // Construction and destruction
Chris@16:             BOOST_UBLAS_INLINE
Chris@16:             const_iterator ():
Chris@16:                 container_const_reference<basic_range> (), it_ () {}
Chris@16:             BOOST_UBLAS_INLINE
Chris@16:             const_iterator (const basic_range &r, const const_subiterator_type &it):
Chris@16:                 container_const_reference<basic_range> (r), it_ (it) {}
Chris@16: 
Chris@16:             // Arithmetic
Chris@16:             BOOST_UBLAS_INLINE
Chris@16:             const_iterator &operator ++ () {
Chris@16:                 ++ it_;
Chris@16:                 return *this;
Chris@16:             }
Chris@16:             BOOST_UBLAS_INLINE
Chris@16:             const_iterator &operator -- () {
Chris@16:                 BOOST_UBLAS_CHECK (it_ > 0, bad_index ());
Chris@16:                 -- it_;
Chris@16:                 return *this;
Chris@16:             }
Chris@16:             BOOST_UBLAS_INLINE
Chris@16:             const_iterator &operator += (difference_type n) {
Chris@16:                 BOOST_UBLAS_CHECK (n >= 0 || it_ >= size_type(-n), bad_index ());
Chris@16:                 it_ += n;
Chris@16:                 return *this;
Chris@16:             }
Chris@16:             BOOST_UBLAS_INLINE
Chris@16:             const_iterator &operator -= (difference_type n) {
Chris@16:                 BOOST_UBLAS_CHECK (n <= 0 || it_ >= size_type(n), bad_index ());
Chris@16:                 it_ -= n;
Chris@16:                 return *this;
Chris@16:             }
Chris@16:             BOOST_UBLAS_INLINE
Chris@16:             difference_type operator - (const const_iterator &it) const {
Chris@16:                 return it_ - it.it_;
Chris@16:             }
Chris@16: 
Chris@16:             // Dereference
Chris@16:             BOOST_UBLAS_INLINE
Chris@16:             const_reference operator * () const {
Chris@16:                 BOOST_UBLAS_CHECK ((*this) ().start () <= it_, bad_index ());
Chris@16:                 BOOST_UBLAS_CHECK (it_ < (*this) ().start () + (*this) ().size (), bad_index ());
Chris@16:                 return it_;
Chris@16:             }
Chris@16: 
Chris@16:             BOOST_UBLAS_INLINE
Chris@16:             const_reference operator [] (difference_type n) const {
Chris@16:                 return *(*this + n);
Chris@16:             }
Chris@16: 
Chris@16:             // Index
Chris@16:             BOOST_UBLAS_INLINE
Chris@16:             size_type index () const {
Chris@16:                 BOOST_UBLAS_CHECK ((*this) ().start () <= it_, bad_index ());
Chris@16:                 BOOST_UBLAS_CHECK (it_ < (*this) ().start () + (*this) ().size (), bad_index ());
Chris@16:                 return it_ - (*this) ().start ();
Chris@16:             }
Chris@16: 
Chris@16:             // Assignment
Chris@16:             BOOST_UBLAS_INLINE
Chris@16:             const_iterator &operator = (const const_iterator &it) {
Chris@16:                 // Comeau recommends...
Chris@16:                 this->assign (&it ());
Chris@16:                 it_ = it.it_;
Chris@16:                 return *this;
Chris@16:             }
Chris@16: 
Chris@16:             // Comparison
Chris@16:             BOOST_UBLAS_INLINE
Chris@16:             bool operator == (const const_iterator &it) const {
Chris@16:                 BOOST_UBLAS_CHECK ((*this) () == it (), external_logic ());
Chris@16:                 return it_ == it.it_;
Chris@16:             }
Chris@16:             BOOST_UBLAS_INLINE
Chris@16:             bool operator < (const const_iterator &it) const {
Chris@16:                 BOOST_UBLAS_CHECK ((*this) () == it (), external_logic ());
Chris@16:                 return it_ < it.it_;
Chris@16:             }
Chris@16: 
Chris@16:         private:
Chris@16:             const_subiterator_type it_;
Chris@16:         };
Chris@16: #endif
Chris@16: 
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         const_iterator begin () const {
Chris@16:             return const_iterator (*this, start_);
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@101:         const_iterator cbegin () const {
Chris@101:             return begin ();
Chris@101:         }
Chris@101:         BOOST_UBLAS_INLINE
Chris@16:         const_iterator end () const {
Chris@16:             return const_iterator (*this, start_ + size_);
Chris@16:         }
Chris@101:         BOOST_UBLAS_INLINE
Chris@101:         const_iterator cend () const {
Chris@101:             return end ();
Chris@101:         }
Chris@16: 
Chris@16:         // Reverse iterator
Chris@16:         typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
Chris@16: 
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         const_reverse_iterator rbegin () const {
Chris@16:             return const_reverse_iterator (end ());
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@101:         const_reverse_iterator crbegin () const {
Chris@101:             return rbegin ();
Chris@101:         }
Chris@101:         BOOST_UBLAS_INLINE
Chris@16:         const_reverse_iterator rend () const {
Chris@16:             return const_reverse_iterator (begin ());
Chris@16:         }
Chris@101:         BOOST_UBLAS_INLINE
Chris@101:         const_reverse_iterator crend () const {
Chris@101:             return rend ();
Chris@101:         }
Chris@16: 
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         basic_range preprocess (size_type size) const {
Chris@16:             if (this != &all_)
Chris@16:                 return *this;
Chris@16:             return basic_range (0, size);
Chris@16:         }
Chris@16:         static
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         const basic_range &all () {
Chris@16:             return all_;
Chris@16:         }
Chris@16: 
Chris@16:     private:
Chris@16:         size_type start_;
Chris@16:         size_type size_;
Chris@16:         static const basic_range all_;
Chris@16:     };
Chris@16: 
Chris@16:     template <class Z, class D>
Chris@16:     const basic_range<Z,D> basic_range<Z,D>::all_  (0, size_type (-1));
Chris@16: 
Chris@16: 
Chris@16:     // Slice class
Chris@16:     template <class Z, class D>
Chris@16:     class basic_slice {
Chris@16:         typedef basic_slice<Z, D> self_type;
Chris@16:     public:
Chris@16:         typedef Z size_type;
Chris@16:         typedef D difference_type;
Chris@16:         typedef size_type value_type;
Chris@16:         typedef value_type const_reference;
Chris@16:         typedef const_reference reference;
Chris@16:         typedef const value_type *const_pointer;
Chris@16:         typedef value_type *pointer;
Chris@16: 
Chris@16:         // Construction and destruction
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         basic_slice ():
Chris@16:             start_ (0), stride_ (0), size_ (0) {}
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         basic_slice (size_type start, difference_type stride, size_type size):
Chris@16:             start_ (start), stride_ (stride), size_ (size) {}
Chris@16: 
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         size_type start () const {
Chris@16:             return start_;
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         difference_type stride () const {
Chris@16:             return stride_;
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         size_type size () const {
Chris@16:             return size_;
Chris@16:         }
Chris@16: 
Chris@16:         // Random Access Container
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         size_type max_size () const {
Chris@16:             return size_;
Chris@16:         }
Chris@16:         
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         bool empty () const {
Chris@16:             return size_ == 0;
Chris@16:         }
Chris@16:             
Chris@16:         // Element access
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         const_reference operator () (size_type i) const {
Chris@16:             BOOST_UBLAS_CHECK (i < size_, bad_index ());
Chris@16:             BOOST_UBLAS_CHECK (stride_ >= 0 || start_ >= i * -stride_, bad_index ());
Chris@16:             return start_ + i * stride_;
Chris@16:         }
Chris@16: 
Chris@16:         // Composition
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         basic_slice compose (const basic_range<size_type, difference_type> &r) const {
Chris@16:             BOOST_UBLAS_CHECK (stride_ >=0 || start_ >= -stride_ * r.start(), bad_index ());
Chris@16:             return basic_slice (start_ + stride_ * r.start (), stride_, r.size ());
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         basic_slice compose (const basic_slice &s) const {
Chris@16:             BOOST_UBLAS_CHECK (stride_ >=0 || start_ >= -stride_ * s.start_, bad_index ());
Chris@16:             return basic_slice (start_ + stride_ * s.start_, stride_ * s.stride_, s.size_);
Chris@16:         }
Chris@16: 
Chris@16:         // Comparison
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         bool operator == (const basic_slice &s) const {
Chris@16:             return start_ == s.start_ && stride_ == s.stride_ && size_ == s.size_; 
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         bool operator != (const basic_slice &s) const {
Chris@16:             return ! (*this == s);
Chris@16:         }
Chris@16: 
Chris@16:         // Iterator types
Chris@16:     private:
Chris@16:         // Use and index
Chris@16:         typedef size_type const_subiterator_type;
Chris@16: 
Chris@16:     public:
Chris@16: #ifdef BOOST_UBLAS_USE_INDEXED_ITERATOR
Chris@16:         typedef indexed_const_iterator<self_type, std::random_access_iterator_tag> const_iterator;
Chris@16: #else
Chris@16:         class const_iterator:
Chris@16:             public container_const_reference<basic_slice>,
Chris@16:             public random_access_iterator_base<std::random_access_iterator_tag,
Chris@16:                                                const_iterator, value_type> {
Chris@16:         public:
Chris@16:             typedef typename basic_slice::value_type value_type;
Chris@16:             typedef typename basic_slice::difference_type difference_type;
Chris@16:             typedef typename basic_slice::const_reference reference;
Chris@16:             typedef typename basic_slice::const_pointer pointer;
Chris@16: 
Chris@16:             // Construction and destruction
Chris@16:             BOOST_UBLAS_INLINE
Chris@16:             const_iterator ():
Chris@16:                 container_const_reference<basic_slice> (), it_ () {}
Chris@16:             BOOST_UBLAS_INLINE
Chris@16:             const_iterator (const basic_slice &s, const const_subiterator_type &it):
Chris@16:                 container_const_reference<basic_slice> (s), it_ (it) {}
Chris@16: 
Chris@16:             // Arithmetic
Chris@16:             BOOST_UBLAS_INLINE
Chris@16:             const_iterator &operator ++ () {
Chris@16:                 ++it_;
Chris@16:                 return *this;
Chris@16:             }
Chris@16:             BOOST_UBLAS_INLINE
Chris@16:             const_iterator &operator -- () {
Chris@16:                 BOOST_UBLAS_CHECK (it_ > 0, bad_index ());
Chris@16:                 --it_;
Chris@16:                 return *this;
Chris@16:             }
Chris@16:             BOOST_UBLAS_INLINE
Chris@16:             const_iterator &operator += (difference_type n) {
Chris@16:                 BOOST_UBLAS_CHECK (n >= 0 || it_ >= size_type(-n), bad_index ());
Chris@16:                 it_ += n;
Chris@16:                 return *this;
Chris@16:             }
Chris@16:             BOOST_UBLAS_INLINE
Chris@16:             const_iterator &operator -= (difference_type n) {
Chris@16:                 BOOST_UBLAS_CHECK (n <= 0 || it_ >= size_type(n), bad_index ());
Chris@16:                 it_ -= n;
Chris@16:                 return *this;
Chris@16:             }
Chris@16:             BOOST_UBLAS_INLINE
Chris@16:             difference_type operator - (const const_iterator &it) const {
Chris@16:                 return it_ - it.it_;
Chris@16:             }
Chris@16: 
Chris@16:             // Dereference
Chris@16:             BOOST_UBLAS_INLINE
Chris@16:             const_reference operator * () const {
Chris@16:                 BOOST_UBLAS_CHECK (it_ < (*this) ().size (), bad_index ());
Chris@16:                 return (*this) ().start () + it_* (*this) ().stride ();
Chris@16:             }
Chris@16: 
Chris@16:             BOOST_UBLAS_INLINE
Chris@16:             const_reference operator [] (difference_type n) const {
Chris@16:                 return *(*this + n);
Chris@16:             }
Chris@16: 
Chris@16:             // Index
Chris@16:             BOOST_UBLAS_INLINE
Chris@16:             size_type index () const {
Chris@16:                 BOOST_UBLAS_CHECK (it_ < (*this) ().size (), bad_index ());
Chris@16:                 return it_;
Chris@16:             }
Chris@16: 
Chris@16:             // Assignment
Chris@16:             BOOST_UBLAS_INLINE
Chris@16:             const_iterator &operator = (const const_iterator &it) {
Chris@16:                 // Comeau recommends...
Chris@16:                 this->assign (&it ());
Chris@16:                 it_ = it.it_;
Chris@16:                 return *this;
Chris@16:             }
Chris@16: 
Chris@16:             // Comparison
Chris@16:             BOOST_UBLAS_INLINE
Chris@16:             bool operator == (const const_iterator &it) const {
Chris@16:                 BOOST_UBLAS_CHECK ((*this) () == it (), external_logic ());
Chris@16:                 return it_ == it.it_;
Chris@16:             }
Chris@16:             BOOST_UBLAS_INLINE
Chris@16:             bool operator < (const const_iterator &it) const {
Chris@16:                 BOOST_UBLAS_CHECK ((*this) () == it (), external_logic ());
Chris@16:                 return it_ < it.it_;
Chris@16:             }
Chris@16: 
Chris@16:         private:
Chris@16:             const_subiterator_type it_;
Chris@16:         };
Chris@16: #endif
Chris@16: 
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         const_iterator begin () const {
Chris@16:             return const_iterator (*this, 0);
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@101:         const_iterator cbegin () const {
Chris@101:             return begin ();
Chris@101:         }
Chris@101:         BOOST_UBLAS_INLINE
Chris@16:         const_iterator end () const {
Chris@16:             return const_iterator (*this, size_);
Chris@16:         }
Chris@101:         BOOST_UBLAS_INLINE
Chris@101:         const_iterator cend () const {
Chris@101:             return end ();
Chris@101:         }
Chris@16: 
Chris@16:         // Reverse iterator
Chris@16:         typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
Chris@16: 
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         const_reverse_iterator rbegin () const {
Chris@16:             return const_reverse_iterator (end ());
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@101:         const_reverse_iterator crbegin () const {
Chris@101:             return rbegin ();
Chris@101:         }
Chris@101:         BOOST_UBLAS_INLINE
Chris@16:         const_reverse_iterator rend () const {
Chris@16:             return const_reverse_iterator (begin ());
Chris@16:         }
Chris@101:         BOOST_UBLAS_INLINE
Chris@101:         const_reverse_iterator crend () const {
Chris@101:             return rend ();
Chris@101:         }
Chris@16: 
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         basic_slice preprocess (size_type size) const {
Chris@16:             if (this != &all_)
Chris@16:                 return *this;
Chris@16:             return basic_slice (0, 1, size);
Chris@16:         }
Chris@16:         static
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         const basic_slice &all () {
Chris@16:             return all_;
Chris@16:         }
Chris@16: 
Chris@16:     private:
Chris@16:         size_type start_;
Chris@16:         difference_type stride_;
Chris@16:         size_type size_;
Chris@16:         static const basic_slice all_;
Chris@16:     };
Chris@16: 
Chris@16:     template <class Z, class D>
Chris@16:     const basic_slice<Z,D> basic_slice<Z,D>::all_  (0, 1, size_type (-1));
Chris@16: 
Chris@16: 
Chris@16:     // Indirect array class
Chris@16:     template<class A>
Chris@16:     class indirect_array {
Chris@16:         typedef indirect_array<A> self_type;
Chris@16:     public:
Chris@16:         typedef A array_type;
Chris@16:         typedef const A const_array_type;
Chris@16:         typedef typename A::size_type size_type;
Chris@16:         typedef typename A::difference_type difference_type;
Chris@16:         typedef typename A::value_type value_type;
Chris@16:         typedef typename A::const_reference const_reference;
Chris@16:         typedef typename A::reference reference;
Chris@16:         typedef typename A::const_pointer const_pointer;
Chris@16:         typedef typename A::pointer pointer;
Chris@16: 
Chris@16:         // Construction and destruction
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         indirect_array ():
Chris@16:             size_ (), data_ () {}
Chris@16:         explicit BOOST_UBLAS_INLINE
Chris@16:         indirect_array (size_type size):
Chris@16:             size_ (size), data_ (size) {}
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         indirect_array (size_type size, const array_type &data):
Chris@16:             size_ (size), data_ (data) {}
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         indirect_array (pointer start, pointer stop):
Chris@16:             size_ (stop - start), data_ (stop - start) {
Chris@16:             std::copy (start, stop, data_.begin ());
Chris@16:         }
Chris@16: 
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         size_type size () const {
Chris@16:             return size_;
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         const_array_type data () const {
Chris@16:             return data_;
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         array_type data () {
Chris@16:             return data_;
Chris@16:         }
Chris@16: 
Chris@16:         // Random Access Container
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         size_type max_size () const {
Chris@16:             return size_;
Chris@16:         }
Chris@16:         
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         bool empty () const {
Chris@16:             return data_.size () == 0;
Chris@16:         }
Chris@16:             
Chris@16:         // Element access
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         const_reference operator () (size_type i) const {
Chris@16:             BOOST_UBLAS_CHECK (i < size_, bad_index ());
Chris@16:             return data_ [i];
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         reference operator () (size_type i) {
Chris@16:             BOOST_UBLAS_CHECK (i < size_, bad_index ());
Chris@16:             return data_ [i];
Chris@16:         }
Chris@16: 
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         const_reference operator [] (size_type i) const {
Chris@16:             return (*this) (i);
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         reference operator [] (size_type i) {
Chris@16:             return (*this) (i);
Chris@16:         }
Chris@16: 
Chris@16:         // Composition
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         indirect_array compose (const basic_range<size_type, difference_type> &r) const {
Chris@16:             BOOST_UBLAS_CHECK (r.start () + r.size () <= size_, bad_size ());
Chris@16:             array_type data (r.size ());
Chris@16:             for (size_type i = 0; i < r.size (); ++ i)
Chris@16:                 data [i] = data_ [r.start () + i];
Chris@16:             return indirect_array (r.size (), data);
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         indirect_array compose (const basic_slice<size_type, difference_type> &s) const {
Chris@16:             BOOST_UBLAS_CHECK (s.start () + s.stride () * (s.size () - (s.size () > 0)) <= size (), bad_size ());
Chris@16:             array_type data (s.size ());
Chris@16:             for (size_type i = 0; i < s.size (); ++ i)
Chris@16:                 data [i] = data_ [s.start () + s.stride () * i];
Chris@16:             return indirect_array (s.size (), data);
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         indirect_array compose (const indirect_array &ia) const {
Chris@16:             array_type data (ia.size_);
Chris@16:             for (size_type i = 0; i < ia.size_; ++ i) {
Chris@16:                 BOOST_UBLAS_CHECK (ia.data_ [i] <= size_, bad_size ());
Chris@16:                 data [i] = data_ [ia.data_ [i]];
Chris@16:             }
Chris@16:             return indirect_array (ia.size_, data);
Chris@16:         }
Chris@16: 
Chris@16:         // Comparison
Chris@16:         template<class OA>
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         bool operator == (const indirect_array<OA> &ia) const {
Chris@16:             if (size_ != ia.size_)
Chris@16:                 return false;
Chris@16:             for (size_type i = 0; i < BOOST_UBLAS_SAME (size_, ia.size_); ++ i)
Chris@16:                 if (data_ [i] != ia.data_ [i])
Chris@16:                     return false;
Chris@16:             return true;
Chris@16:         }
Chris@16:         template<class OA>
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         bool operator != (const indirect_array<OA> &ia) const {
Chris@16:             return ! (*this == ia);
Chris@16:         }
Chris@16: 
Chris@16:         // Iterator types
Chris@16:     private:
Chris@16:         // Use a index difference
Chris@16:         typedef difference_type const_subiterator_type;
Chris@16: 
Chris@16:     public:
Chris@16: #ifdef BOOST_UBLAS_USE_INDEXED_ITERATOR
Chris@16:         typedef indexed_const_iterator<indirect_array, std::random_access_iterator_tag> const_iterator;
Chris@16: #else
Chris@16:         class const_iterator:
Chris@16:             public container_const_reference<indirect_array>,
Chris@16:             public random_access_iterator_base<std::random_access_iterator_tag,
Chris@16:                                                const_iterator, value_type> {
Chris@16:         public:
Chris@16:             typedef typename indirect_array::value_type value_type;
Chris@16:             typedef typename indirect_array::difference_type difference_type;
Chris@16:             typedef typename indirect_array::const_reference reference;
Chris@16:             typedef typename indirect_array::const_pointer pointer;
Chris@16: 
Chris@16:             // Construction and destruction
Chris@16:             BOOST_UBLAS_INLINE
Chris@16:             const_iterator ():
Chris@16:                 container_const_reference<indirect_array> (), it_ () {}
Chris@16:             BOOST_UBLAS_INLINE
Chris@16:             const_iterator (const indirect_array &ia, const const_subiterator_type &it):
Chris@16:                 container_const_reference<indirect_array> (ia), it_ (it) {}
Chris@16: 
Chris@16:             // Arithmetic
Chris@16:             BOOST_UBLAS_INLINE
Chris@16:             const_iterator &operator ++ () {
Chris@16:                 ++ it_;
Chris@16:                 return *this;
Chris@16:             }
Chris@16:             BOOST_UBLAS_INLINE
Chris@16:             const_iterator &operator -- () {
Chris@16:                 -- it_;
Chris@16:                 return *this;
Chris@16:             }
Chris@16:             BOOST_UBLAS_INLINE
Chris@16:             const_iterator &operator += (difference_type n) {
Chris@16:                 it_ += n;
Chris@16:                 return *this;
Chris@16:             }
Chris@16:             BOOST_UBLAS_INLINE
Chris@16:             const_iterator &operator -= (difference_type n) {
Chris@16:                 it_ -= n;
Chris@16:                 return *this;
Chris@16:             }
Chris@16:             BOOST_UBLAS_INLINE
Chris@16:             difference_type operator - (const const_iterator &it) const {
Chris@16:                 return it_ - it.it_;
Chris@16:             }
Chris@16: 
Chris@16:             // Dereference
Chris@16:             BOOST_UBLAS_INLINE
Chris@16:             const_reference operator * () const {
Chris@16:                 return (*this) () (it_);
Chris@16:             }
Chris@16: 
Chris@16:             BOOST_UBLAS_INLINE
Chris@16:             const_reference operator [] (difference_type n) const {
Chris@16:                 return *(*this + n);
Chris@16:             }
Chris@16: 
Chris@16:             // Index
Chris@16:             BOOST_UBLAS_INLINE
Chris@16:             size_type index () const {
Chris@16:                 return it_;
Chris@16:             }
Chris@16: 
Chris@16:             // Assignment
Chris@16:             BOOST_UBLAS_INLINE
Chris@16:             const_iterator &operator = (const const_iterator &it) {
Chris@16:                 // Comeau recommends...
Chris@16:                 this->assign (&it ());
Chris@16:                 it_ = it.it_;
Chris@16:                 return *this;
Chris@16:             }
Chris@16: 
Chris@16:             // Comparison
Chris@16:             BOOST_UBLAS_INLINE
Chris@16:             bool operator == (const const_iterator &it) const {
Chris@16:                 BOOST_UBLAS_CHECK ((*this) () == it (), external_logic ());
Chris@16:                 return it_ == it.it_;
Chris@16:             }
Chris@16:             BOOST_UBLAS_INLINE
Chris@16:             bool operator < (const const_iterator &it) const {
Chris@16:                 BOOST_UBLAS_CHECK ((*this) () == it (), external_logic ());
Chris@16:                 return it_ < it.it_;
Chris@16:             }
Chris@16: 
Chris@16:         private:
Chris@16:             const_subiterator_type it_;
Chris@16:         };
Chris@16: #endif
Chris@16: 
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         const_iterator begin () const {
Chris@16:             return const_iterator (*this, 0);
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@101:         const_iterator cbegin () const {
Chris@101:             return begin ();
Chris@101:         }
Chris@101:         BOOST_UBLAS_INLINE
Chris@16:         const_iterator end () const {
Chris@16:             return const_iterator (*this, size_);
Chris@16:         }
Chris@101:         BOOST_UBLAS_INLINE
Chris@101:         const_iterator cend () const {
Chris@101:             return end ();
Chris@101:         }
Chris@16: 
Chris@16:         // Reverse iterator
Chris@16:         typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
Chris@16: 
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         const_reverse_iterator rbegin () const {
Chris@16:             return const_reverse_iterator (end ());
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@101:         const_reverse_iterator crbegin () const {
Chris@101:             return rbegin ();
Chris@101:         }
Chris@101:         BOOST_UBLAS_INLINE
Chris@16:         const_reverse_iterator rend () const {
Chris@16:             return const_reverse_iterator (begin ());
Chris@16:         }
Chris@101:         BOOST_UBLAS_INLINE
Chris@101:         const_reverse_iterator crend () const {
Chris@101:             return rend ();
Chris@101:         }
Chris@16: 
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         indirect_array preprocess (size_type size) const {
Chris@16:             if (this != &all_)
Chris@16:                 return *this;
Chris@16:             indirect_array ia (size);
Chris@16:             for (size_type i = 0; i < size; ++ i)
Chris@16:                ia (i) = i;
Chris@16:             return ia;
Chris@16:         }
Chris@16:         static
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         const indirect_array &all () {
Chris@16:             return all_;
Chris@16:         }
Chris@16: 
Chris@16:     private:
Chris@16:         size_type size_;
Chris@16:         array_type data_;
Chris@16:         static const indirect_array all_;
Chris@16:     };
Chris@16: 
Chris@16:     template<class A>
Chris@16:     const indirect_array<A> indirect_array<A>::all_;
Chris@16: 
Chris@16: 
Chris@16: 
Chris@16:     // Gunter Winkler contributed the classes index_pair, index_pair_array,
Chris@16:     // index_triple and index_triple_array to enable inplace sort of parallel arrays.
Chris@16: 
Chris@16:     template <class V>
Chris@16:     class index_pair :
Chris@16:         public container_reference<V> {
Chris@16: 
Chris@16:         typedef index_pair<V> self_type;
Chris@16:     public:
Chris@16:         typedef typename V::size_type size_type;
Chris@16: 
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         index_pair(V& v, size_type i) :
Chris@16:             container_reference<V>(v), i_(i),
Chris@16:             v1_(v.data1_[i]), v2_(v.data2_[i]),
Chris@16:             dirty_(false), is_copy_(false) {}
Chris@16:          BOOST_UBLAS_INLINE
Chris@16:         index_pair(const self_type& rhs) :
Chris@16:             container_reference<V>(rhs()), i_(0),
Chris@16:             v1_(rhs.v1_), v2_(rhs.v2_),
Chris@16:             dirty_(false), is_copy_(true) {}
Chris@16:          BOOST_UBLAS_INLINE
Chris@16:         ~index_pair() {
Chris@16:             if (dirty_ && (!is_copy_) ) {
Chris@16:                 (*this)().data1_[i_] = v1_;
Chris@16:                 (*this)().data2_[i_] = v2_;
Chris@16:             }
Chris@16:         }
Chris@16: 
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         self_type& operator=(const self_type& rhs) {
Chris@16:             v1_ = rhs.v1_;
Chris@16:             v2_ = rhs.v2_;
Chris@16:             dirty_ = true;
Chris@16:             return *this;
Chris@16:         }
Chris@16: 
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         void swap(self_type& rhs) {
Chris@16:             self_type tmp(rhs);
Chris@16:             rhs = *this;
Chris@16:             *this = tmp;
Chris@16:         }
Chris@101: 
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         friend void swap(self_type& lhs, self_type& rhs) {
Chris@16:             lhs.swap(rhs);
Chris@16:         }
Chris@16: 
Chris@101:         friend void swap(self_type lhs, self_type rhs) { // For gcc 4.8 and c++11
Chris@101:             lhs.swap(rhs);
Chris@101:         }
Chris@101: 
Chris@101: 
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         bool equal(const self_type& rhs) const {
Chris@16:             return (v1_ == rhs.v1_);
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         bool less(const self_type& rhs) const {
Chris@16:             return (v1_ < rhs.v1_);
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         friend bool operator == (const self_type& lhs, const self_type& rhs) {
Chris@16:             return lhs.equal(rhs);
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         friend bool operator != (const self_type& lhs, const self_type& rhs) {
Chris@16:             return !lhs.equal(rhs);
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         friend bool operator < (const self_type& lhs, const self_type& rhs) {
Chris@16:             return lhs.less(rhs);
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         friend bool operator >= (const self_type& lhs, const self_type& rhs) {
Chris@16:             return !lhs.less(rhs);
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         friend bool operator > (const self_type& lhs, const self_type& rhs) {
Chris@16:             return rhs.less(lhs);
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         friend bool operator <= (const self_type& lhs, const self_type& rhs) {
Chris@16:             return !rhs.less(lhs);
Chris@16:         }
Chris@16: 
Chris@16:     private:
Chris@16:         size_type i_;
Chris@16:         typename V::value1_type v1_;
Chris@16:         typename V::value2_type v2_;
Chris@16:         bool dirty_;
Chris@16:         bool is_copy_;
Chris@16:      };
Chris@16: 
Chris@16:     template <class V1, class V2>
Chris@16:     class index_pair_array:
Chris@16:         private boost::noncopyable {
Chris@16: 
Chris@16:         typedef index_pair_array<V1, V2> self_type;
Chris@16:     public:
Chris@16:         typedef typename V1::value_type value1_type;
Chris@16:         typedef typename V2::value_type value2_type;
Chris@16: 
Chris@16:         typedef typename V1::size_type size_type;
Chris@16:         typedef typename V1::difference_type difference_type;
Chris@16:         typedef index_pair<self_type> value_type;
Chris@16:         // There is nothing that can be referenced directly. Always return a copy of the index_pair
Chris@16:         typedef value_type reference;
Chris@16:         typedef const value_type const_reference;
Chris@16: 
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         index_pair_array(size_type size, V1& data1, V2& data2) :
Chris@16:               size_(size),data1_(data1),data2_(data2) {}
Chris@16: 
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         size_type size() const {
Chris@16:             return size_;
Chris@16:         }
Chris@16: 
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         const_reference operator () (size_type i) const {
Chris@16:             return value_type((*this), i);
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         reference operator () (size_type i) {
Chris@16:             return value_type((*this), i);
Chris@16:         }
Chris@16: 
Chris@16:         typedef indexed_iterator<self_type, std::random_access_iterator_tag> iterator;
Chris@16:         typedef indexed_const_iterator<self_type, std::random_access_iterator_tag> const_iterator;
Chris@16: 
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         iterator begin() {
Chris@16:             return iterator( (*this), 0);
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         iterator end() {
Chris@16:             return iterator( (*this), size());
Chris@16:         }
Chris@16: 
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         const_iterator begin() const {
Chris@16:             return const_iterator( (*this), 0);
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@101:         const_iterator cbegin () const {
Chris@101:             return begin ();
Chris@101:         }
Chris@101:         BOOST_UBLAS_INLINE
Chris@16:         const_iterator end() const {
Chris@16:             return const_iterator( (*this), size());
Chris@16:         }
Chris@101:         BOOST_UBLAS_INLINE
Chris@101:         const_iterator cend () const {
Chris@101:             return end ();
Chris@101:         }
Chris@16: 
Chris@16:         // unnecessary function:
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         bool equal(size_type i1, size_type i2) const {
Chris@16:             return data1_[i1] == data1_[i2];
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         bool less(size_type i1, size_type i2) const {
Chris@16:             return data1_[i1] < data1_[i2];
Chris@16:         }
Chris@16: 
Chris@16:         // gives a large speedup
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         friend void iter_swap(const iterator& lhs, const iterator& rhs) {
Chris@16:             const size_type i1 = lhs.index();
Chris@16:             const size_type i2 = rhs.index();
Chris@16:             std::swap(lhs().data1_[i1], rhs().data1_[i2]);
Chris@16:             std::swap(lhs().data2_[i1], rhs().data2_[i2]);
Chris@16:         }
Chris@16: 
Chris@16:     private:
Chris@16:         size_type size_;
Chris@16:         V1& data1_;
Chris@16:         V2& data2_;
Chris@16: 
Chris@16:         // friend class value_type;
Chris@16:         friend class index_pair<self_type>;
Chris@16:     };
Chris@16: 
Chris@16:     template <class M>
Chris@16:     class index_triple :
Chris@16:         public container_reference<M> {
Chris@16: 
Chris@16:         typedef index_triple<M> self_type;
Chris@16:     public:
Chris@16:         typedef typename M::size_type size_type;
Chris@16: 
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         index_triple(M& m, size_type i) :
Chris@16:             container_reference<M>(m), i_(i),
Chris@16:             v1_(m.data1_[i]), v2_(m.data2_[i]), v3_(m.data3_[i]),
Chris@16:             dirty_(false), is_copy_(false) {}
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         index_triple(const self_type& rhs) :
Chris@16:             container_reference<M>(rhs()), i_(0),
Chris@16:             v1_(rhs.v1_), v2_(rhs.v2_), v3_(rhs.v3_),
Chris@16:             dirty_(false), is_copy_(true) {}
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         ~index_triple() {
Chris@16:             if (dirty_ && (!is_copy_) ) {
Chris@16:                 (*this)().data1_[i_] = v1_;
Chris@16:                 (*this)().data2_[i_] = v2_;
Chris@16:                 (*this)().data3_[i_] = v3_;
Chris@16:             }
Chris@16:         }
Chris@16: 
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         self_type& operator=(const self_type& rhs) {
Chris@16:             v1_ = rhs.v1_;
Chris@16:             v2_ = rhs.v2_;
Chris@16:             v3_ = rhs.v3_;
Chris@16:             dirty_ = true;
Chris@16:             return *this;
Chris@16:         }
Chris@16: 
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         void swap(self_type& rhs) {
Chris@16:             self_type tmp(rhs);
Chris@16:             rhs = *this;
Chris@16:             *this = tmp;
Chris@16:         }
Chris@101: 
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         friend void swap(self_type& lhs, self_type& rhs) {
Chris@16:             lhs.swap(rhs);
Chris@16:         }
Chris@16: 
Chris@101:         friend void swap(self_type lhs, self_type rhs) { // For gcc 4.8 and c++11
Chris@101:             lhs.swap(rhs);
Chris@101:         }
Chris@101: 
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         bool equal(const self_type& rhs) const {
Chris@16:             return ((v1_ == rhs.v1_) && (v2_ == rhs.v2_));
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         bool less(const self_type& rhs) const {
Chris@16:             return ((v1_ < rhs.v1_) ||
Chris@16:                     (v1_ == rhs.v1_ && v2_ < rhs.v2_));
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         friend bool operator == (const self_type& lhs, const self_type& rhs) {
Chris@16:             return lhs.equal(rhs);
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         friend bool operator != (const self_type& lhs, const self_type& rhs) {
Chris@16:             return !lhs.equal(rhs);
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         friend bool operator < (const self_type& lhs, const self_type& rhs) {
Chris@16:             return lhs.less(rhs);
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         friend bool operator >= (const self_type& lhs, const self_type& rhs) {
Chris@16:             return !lhs.less(rhs);
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         friend bool operator > (const self_type& lhs, const self_type& rhs) {
Chris@16:             return rhs.less(lhs);
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         friend bool operator <= (const self_type& lhs, const self_type& rhs) {
Chris@16:             return !rhs.less(lhs);
Chris@16:         }
Chris@16: 
Chris@16:     private:
Chris@16:         size_type i_;
Chris@16:         typename M::value1_type v1_;
Chris@16:         typename M::value2_type v2_;
Chris@16:         typename M::value3_type v3_;
Chris@16:         bool dirty_;
Chris@16:         bool is_copy_;
Chris@16:     };
Chris@16: 
Chris@16:     template <class V1, class V2, class V3>
Chris@16:     class index_triple_array:
Chris@16:         private boost::noncopyable {
Chris@16: 
Chris@16:         typedef index_triple_array<V1, V2, V3> self_type;
Chris@16:     public:
Chris@16:         typedef typename V1::value_type value1_type;
Chris@16:         typedef typename V2::value_type value2_type;
Chris@16:         typedef typename V3::value_type value3_type;
Chris@16: 
Chris@16:         typedef typename V1::size_type size_type;
Chris@16:         typedef typename V1::difference_type difference_type;
Chris@16:         typedef index_triple<self_type> value_type;
Chris@16:         // There is nothing that can be referenced directly. Always return a copy of the index_triple
Chris@16:         typedef value_type reference;
Chris@16:         typedef const value_type const_reference;
Chris@16: 
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         index_triple_array(size_type size, V1& data1, V2& data2, V3& data3) :
Chris@16:               size_(size),data1_(data1),data2_(data2),data3_(data3) {}
Chris@16: 
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         size_type size() const {
Chris@16:             return size_;
Chris@16:         }
Chris@16: 
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         const_reference operator () (size_type i) const {
Chris@16:             return value_type((*this), i);
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         reference operator () (size_type i) {
Chris@16:             return value_type((*this), i);
Chris@16:         }
Chris@16: 
Chris@16:         typedef indexed_iterator<self_type, std::random_access_iterator_tag> iterator;
Chris@16:         typedef indexed_const_iterator<self_type, std::random_access_iterator_tag> const_iterator;
Chris@16: 
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         iterator begin() {
Chris@16:             return iterator( (*this), 0);
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         iterator end() {
Chris@16:             return iterator( (*this), size());
Chris@16:         }
Chris@16: 
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         const_iterator begin() const {
Chris@16:             return const_iterator( (*this), 0);
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@101:         const_iterator cbegin () const {
Chris@101:             return begin ();
Chris@101:         }
Chris@101:         BOOST_UBLAS_INLINE
Chris@16:         const_iterator end() const {
Chris@16:             return const_iterator( (*this), size());
Chris@16:         }
Chris@101:         BOOST_UBLAS_INLINE
Chris@101:         const_iterator cend () const {
Chris@101:             return end ();
Chris@101:         }
Chris@16: 
Chris@16:         // unnecessary function:
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         bool equal(size_type i1, size_type i2) const {
Chris@16:             return ((data1_[i1] == data1_[i2]) && (data2_[i1] == data2_[i2]));
Chris@16:         }
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         bool less(size_type i1, size_type i2) const {
Chris@16:             return ((data1_[i1] < data1_[i2]) ||
Chris@16:                     (data1_[i1] == data1_[i2] && data2_[i1] < data2_[i2]));
Chris@16:         }
Chris@16: 
Chris@16:         // gives a large speedup
Chris@16:         BOOST_UBLAS_INLINE
Chris@16:         friend void iter_swap(const iterator& lhs, const iterator& rhs) {
Chris@16:             const size_type i1 = lhs.index();
Chris@16:             const size_type i2 = rhs.index();
Chris@16:             std::swap(lhs().data1_[i1], rhs().data1_[i2]);
Chris@16:             std::swap(lhs().data2_[i1], rhs().data2_[i2]);
Chris@16:             std::swap(lhs().data3_[i1], rhs().data3_[i2]);
Chris@16:         }
Chris@16: 
Chris@16:     private:
Chris@16:         size_type size_;
Chris@16:         V1& data1_;
Chris@16:         V2& data2_;
Chris@16:         V3& data3_;
Chris@16: 
Chris@16:         // friend class value_type;
Chris@16:         friend class index_triple<self_type>;
Chris@16:     };
Chris@16: 
Chris@16: }}}
Chris@16: 
Chris@16: #endif