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