| // Copyright 2002 The Trustees of Indiana University. |
| |
| // Use, modification and distribution is subject to 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) |
| |
| // Boost.MultiArray Library |
| // Authors: Ronald Garcia |
| // Jeremy Siek |
| // Andrew Lumsdaine |
| // See http://www.boost.org/libs/multi_array for documentation. |
| |
| #ifndef SUBARRAY_RG071801_HPP |
| #define SUBARRAY_RG071801_HPP |
| |
| // |
| // subarray.hpp - used to implement standard operator[] on |
| // multi_arrays |
| // |
| |
| #include "boost/multi_array/base.hpp" |
| #include "boost/multi_array/concept_checks.hpp" |
| #include "boost/limits.hpp" |
| #include "boost/type.hpp" |
| #include <algorithm> |
| #include <cstddef> |
| #include <functional> |
| |
| namespace boost { |
| namespace detail { |
| namespace multi_array { |
| |
| // |
| // const_sub_array |
| // multi_array's proxy class to allow multiple overloads of |
| // operator[] in order to provide a clean multi-dimensional array |
| // interface. |
| template <typename T, std::size_t NumDims, typename TPtr> |
| class const_sub_array : |
| public boost::detail::multi_array::multi_array_impl_base<T,NumDims> |
| { |
| typedef boost::detail::multi_array::multi_array_impl_base<T,NumDims> super_type; |
| public: |
| typedef typename super_type::value_type value_type; |
| typedef typename super_type::const_reference const_reference; |
| typedef typename super_type::const_iterator const_iterator; |
| typedef typename super_type::const_reverse_iterator const_reverse_iterator; |
| typedef typename super_type::element element; |
| typedef typename super_type::size_type size_type; |
| typedef typename super_type::difference_type difference_type; |
| typedef typename super_type::index index; |
| typedef typename super_type::extent_range extent_range; |
| |
| // template typedefs |
| template <std::size_t NDims> |
| struct const_array_view { |
| typedef boost::detail::multi_array::const_multi_array_view<T,NDims> type; |
| }; |
| |
| template <std::size_t NDims> |
| struct array_view { |
| typedef boost::detail::multi_array::multi_array_view<T,NDims> type; |
| }; |
| |
| // Allow default copy constructor as well. |
| |
| template <typename OPtr> |
| const_sub_array (const const_sub_array<T,NumDims,OPtr>& rhs) : |
| base_(rhs.base_), extents_(rhs.extents_), strides_(rhs.strides_), |
| index_base_(rhs.index_base_) { |
| } |
| |
| // const_sub_array always returns const types, regardless of its own |
| // constness. |
| const_reference operator[](index idx) const { |
| return super_type::access(boost::type<const_reference>(), |
| idx,base_,shape(),strides(),index_bases()); |
| } |
| |
| template <typename IndexList> |
| const element& operator()(const IndexList& indices) const { |
| boost::function_requires< |
| CollectionConcept<IndexList> >(); |
| return super_type::access_element(boost::type<const element&>(), |
| indices,origin(), |
| shape(),strides(),index_bases()); |
| } |
| |
| // see generate_array_view in base.hpp |
| #if !defined(BOOST_MSVC) || BOOST_MSVC > 1300 |
| template <int NDims> |
| #else |
| template <int NumDims, int NDims> // else ICE |
| #endif // BOOST_MSVC |
| typename const_array_view<NDims>::type |
| operator[](const boost::detail::multi_array:: |
| index_gen<NumDims,NDims>& indices) |
| const { |
| typedef typename const_array_view<NDims>::type return_type; |
| return |
| super_type::generate_array_view(boost::type<return_type>(), |
| indices, |
| shape(), |
| strides(), |
| index_bases(), |
| base_); |
| } |
| |
| template <typename OPtr> |
| bool operator<(const const_sub_array<T,NumDims,OPtr>& rhs) const { |
| return std::lexicographical_compare(begin(),end(),rhs.begin(),rhs.end()); |
| } |
| |
| template <typename OPtr> |
| bool operator==(const const_sub_array<T,NumDims,OPtr>& rhs) const { |
| if(std::equal(shape(),shape()+num_dimensions(),rhs.shape())) |
| return std::equal(begin(),end(),rhs.begin()); |
| else return false; |
| } |
| |
| template <typename OPtr> |
| bool operator!=(const const_sub_array<T,NumDims,OPtr>& rhs) const { |
| return !(*this == rhs); |
| } |
| |
| template <typename OPtr> |
| bool operator>(const const_sub_array<T,NumDims,OPtr>& rhs) const { |
| return rhs < *this; |
| } |
| |
| template <typename OPtr> |
| bool operator<=(const const_sub_array<T,NumDims,OPtr>& rhs) const { |
| return !(*this > rhs); |
| } |
| |
| template <typename OPtr> |
| bool operator>=(const const_sub_array<T,NumDims,OPtr>& rhs) const { |
| return !(*this < rhs); |
| } |
| |
| const_iterator begin() const { |
| return const_iterator(*index_bases(),origin(), |
| shape(),strides(),index_bases()); |
| } |
| |
| const_iterator end() const { |
| return const_iterator(*index_bases()+(index)*shape(),origin(), |
| shape(),strides(),index_bases()); |
| } |
| |
| const_reverse_iterator rbegin() const { |
| return const_reverse_iterator(end()); |
| } |
| |
| const_reverse_iterator rend() const { |
| return const_reverse_iterator(begin()); |
| } |
| |
| TPtr origin() const { return base_; } |
| size_type size() const { return extents_[0]; } |
| size_type max_size() const { return num_elements(); } |
| bool empty() const { return size() == 0; } |
| size_type num_dimensions() const { return NumDims; } |
| const size_type* shape() const { return extents_; } |
| const index* strides() const { return strides_; } |
| const index* index_bases() const { return index_base_; } |
| |
| size_type num_elements() const { |
| return std::accumulate(shape(),shape() + num_dimensions(), |
| size_type(1), std::multiplies<size_type>()); |
| } |
| |
| |
| #ifndef BOOST_NO_MEMBER_TEMPLATE_FRIENDS |
| protected: |
| template <typename,std::size_t> friend class value_accessor_n; |
| template <typename,std::size_t,typename> friend class const_sub_array; |
| #else |
| public: // Should be protected |
| #endif |
| |
| const_sub_array (TPtr base, |
| const size_type* extents, |
| const index* strides, |
| const index* index_base) : |
| base_(base), extents_(extents), strides_(strides), |
| index_base_(index_base) { |
| } |
| |
| TPtr base_; |
| const size_type* extents_; |
| const index* strides_; |
| const index* index_base_; |
| private: |
| // const_sub_array cannot be assigned to (no deep copies!) |
| const_sub_array& operator=(const const_sub_array&); |
| }; |
| |
| |
| // |
| // sub_array |
| // multi_array's proxy class to allow multiple overloads of |
| // operator[] in order to provide a clean multi-dimensional array |
| // interface. |
| template <typename T, std::size_t NumDims> |
| class sub_array : public const_sub_array<T,NumDims,T*> |
| { |
| typedef const_sub_array<T,NumDims,T*> super_type; |
| public: |
| typedef typename super_type::element element; |
| typedef typename super_type::reference reference; |
| typedef typename super_type::index index; |
| typedef typename super_type::size_type size_type; |
| typedef typename super_type::iterator iterator; |
| typedef typename super_type::reverse_iterator reverse_iterator; |
| typedef typename super_type::const_reference const_reference; |
| typedef typename super_type::const_iterator const_iterator; |
| typedef typename super_type::const_reverse_iterator const_reverse_iterator; |
| |
| // template typedefs |
| template <std::size_t NDims> |
| struct const_array_view { |
| typedef boost::detail::multi_array::const_multi_array_view<T,NDims> type; |
| }; |
| |
| template <std::size_t NDims> |
| struct array_view { |
| typedef boost::detail::multi_array::multi_array_view<T,NDims> type; |
| }; |
| |
| // Assignment from other ConstMultiArray types. |
| template <typename ConstMultiArray> |
| sub_array& operator=(const ConstMultiArray& other) { |
| function_requires< boost::multi_array_concepts::ConstMultiArrayConcept< |
| ConstMultiArray, NumDims> >(); |
| |
| // make sure the dimensions agree |
| BOOST_ASSERT(other.num_dimensions() == this->num_dimensions()); |
| BOOST_ASSERT(std::equal(other.shape(),other.shape()+this->num_dimensions(), |
| this->shape())); |
| // iterator-based copy |
| std::copy(other.begin(),other.end(),begin()); |
| return *this; |
| } |
| |
| |
| sub_array& operator=(const sub_array& other) { |
| if (&other != this) { |
| // make sure the dimensions agree |
| BOOST_ASSERT(other.num_dimensions() == this->num_dimensions()); |
| BOOST_ASSERT(std::equal(other.shape(), |
| other.shape()+this->num_dimensions(), |
| this->shape())); |
| // iterator-based copy |
| std::copy(other.begin(),other.end(),begin()); |
| } |
| return *this; |
| } |
| |
| T* origin() { return this->base_; } |
| const T* origin() const { return this->base_; } |
| |
| reference operator[](index idx) { |
| return super_type::access(boost::type<reference>(), |
| idx,this->base_,this->shape(),this->strides(), |
| this->index_bases()); |
| } |
| |
| // see generate_array_view in base.hpp |
| #if !defined(BOOST_MSVC) || BOOST_MSVC > 1300 |
| template <int NDims> |
| #else |
| template <int NumDims, int NDims> // else ICE |
| #endif // BOOST_MSVC |
| typename array_view<NDims>::type |
| operator[](const boost::detail::multi_array:: |
| index_gen<NumDims,NDims>& indices) { |
| typedef typename array_view<NDims>::type return_type; |
| return |
| super_type::generate_array_view(boost::type<return_type>(), |
| indices, |
| this->shape(), |
| this->strides(), |
| this->index_bases(), |
| origin()); |
| } |
| |
| template <class IndexList> |
| element& operator()(const IndexList& indices) { |
| boost::function_requires< |
| CollectionConcept<IndexList> >(); |
| return super_type::access_element(boost::type<element&>(), |
| indices,origin(), |
| this->shape(),this->strides(), |
| this->index_bases()); |
| } |
| |
| iterator begin() { |
| return iterator(*this->index_bases(),origin(), |
| this->shape(),this->strides(),this->index_bases()); |
| } |
| |
| iterator end() { |
| return iterator(*this->index_bases()+(index)*this->shape(),origin(), |
| this->shape(),this->strides(),this->index_bases()); |
| } |
| |
| // RG - rbegin() and rend() written naively to thwart MSVC ICE. |
| reverse_iterator rbegin() { |
| reverse_iterator ri(end()); |
| return ri; |
| } |
| |
| reverse_iterator rend() { |
| reverse_iterator ri(begin()); |
| return ri; |
| } |
| |
| // |
| // proxies |
| // |
| |
| template <class IndexList> |
| const element& operator()(const IndexList& indices) const { |
| boost::function_requires< |
| CollectionConcept<IndexList> >(); |
| return super_type::operator()(indices); |
| } |
| |
| const_reference operator[](index idx) const { |
| return super_type::operator[](idx); |
| } |
| |
| // see generate_array_view in base.hpp |
| #if !defined(BOOST_MSVC) || BOOST_MSVC > 1300 |
| template <int NDims> |
| #else |
| template <int NumDims, int NDims> // else ICE |
| #endif // BOOST_MSVC |
| typename const_array_view<NDims>::type |
| operator[](const boost::detail::multi_array:: |
| index_gen<NumDims,NDims>& indices) |
| const { |
| return super_type::operator[](indices); |
| } |
| |
| const_iterator begin() const { |
| return super_type::begin(); |
| } |
| |
| const_iterator end() const { |
| return super_type::end(); |
| } |
| |
| const_reverse_iterator rbegin() const { |
| return super_type::rbegin(); |
| } |
| |
| const_reverse_iterator rend() const { |
| return super_type::rend(); |
| } |
| |
| #ifndef BOOST_NO_MEMBER_TEMPLATE_FRIENDS |
| private: |
| template <typename,std::size_t> friend class value_accessor_n; |
| #else |
| public: // should be private |
| #endif |
| |
| sub_array (T* base, |
| const size_type* extents, |
| const index* strides, |
| const index* index_base) : |
| super_type(base,extents,strides,index_base) { |
| } |
| |
| }; |
| |
| } // namespace multi_array |
| } // namespace detail |
| // |
| // traits classes to get sub_array types |
| // |
| template <typename Array, int N> |
| class subarray_gen { |
| typedef typename Array::element element; |
| public: |
| typedef boost::detail::multi_array::sub_array<element,N> type; |
| }; |
| |
| template <typename Array, int N> |
| class const_subarray_gen { |
| typedef typename Array::element element; |
| public: |
| typedef boost::detail::multi_array::const_sub_array<element,N> type; |
| }; |
| } // namespace boost |
| |
| #endif // SUBARRAY_RG071801_HPP |