# `const_multi_array_ref`

`const_multi_array_ref` is a multi-dimensional container adaptor. It provides the MultiArray interface over any contiguous block of elements. `const_multi_array_ref` exports the same interface as `multi_array`, with the exception of the constructors.

## Model Of.

`const_multi_array_ref` models MultiArray, CopyConstructible. and depending on the element type, it may also model EqualityComparable and LessThanComparable.

Detailed descriptions are provided here only for operations that are not described in the `multi_array` reference.

## Synopsis

    namespace boost {

    template <typename ValueType,
              std::size_t NumDims,
              typename Allocator = std::allocator<ValueType> >
    class const_multi_array_ref {
    public:
    // types:
      typedef ValueType                             element;
      typedef *implementation-defined*              value_type;
      typedef *implementation-defined*              reference;
      typedef *implementation-defined*              const_reference;
      typedef *implementation-defined*              difference_type;
      typedef *implementation-defined*              iterator;
      typedef *implementation-defined*              const_iterator;
      typedef *implementation-defined*              reverse_iterator;
      typedef *implementation-defined*              const_reverse_iterator;
      typedef multi_array_types::size_type          size_type;
      typedef multi_array_types::index              index;
      typedef multi_array_types::index_gen          index_gen;
      typedef multi_array_types::index_range        index_range;
      typedef multi_array_types::extent_gen         extent_gen;
      typedef multi_array_types::extent_range       extent_range;
      typedef *implementation-defined*              storage_order_type;

      // template typedefs
      template <std::size_t Dims> struct            subarray;
      template <std::size_t Dims> struct            const_subarray;
      template <std::size_t Dims> struct            array_view;
      template <std::size_t Dims> struct            const_array_view;

      // structors

      template <typename ExtentList>
      explicit const_multi_array_ref(const element* data, const ExtentList& sizes,
                           const storage_order_type& store = c_storage_order());
      explicit const_multi_array_ref(const element* data, const extents_tuple& ranges,
                           const storage_order_type& store = c_storage_order());
      const_multi_array_ref(const const_multi_array_ref& x);
      ~const_multi_array_ref();

      // iterators:
      const_iterator			begin() const;
      const_iterator			end() const;
      const_reverse_iterator		rbegin() const;
      const_reverse_iterator		rend() const;

      // capacity:
      size_type				size() const;
      size_type				num_elements() const;
      size_type				num_dimensions() const;

      // element access:
      template <typename IndexList>
        const element&		operator()(const IndexList& indices) const;
      const_reference		operator[](index i) const;
      const_array_view<Dims>::type	operator[](const indices_tuple& r) const;

      // queries
      const element*		data() const;
      const element*		origin() const;
      const size_type*		shape() const;
      const index*			strides() const;
      const index*			index_bases() const;
      const storage_order_type&     storage_order() const;

      // comparators
      bool operator==(const const_multi_array_ref& rhs);
      bool operator!=(const const_multi_array_ref& rhs);
      bool operator<(const const_multi_array_ref& rhs);
      bool operator>(const const_multi_array_ref& rhs);
      bool operator>=(const const_multi_array_ref& rhs);
      bool operator<=(const const_multi_array_ref& rhs);

      // modifiers:
      template <typename SizeList>
      void			reshape(const SizeList& sizes)
      template <typename BaseList>	void reindex(const BaseList& values);
      void				reindex(index value);
    };

## Constructors

    template <typename ExtentList>
    explicit const_multi_array_ref(const element* data,
                         const ExtentList& sizes,
                         const storage_order& store = c_storage_order());

  This constructs a `const_multi_array_ref` using the specified parameters. `sizes` specifies the shape of the constructed `const_multi_array_ref`. `store` specifies the storage order or layout in memory of the array dimensions.

  ## `ExtentList` Requirements

  `ExtentList` must model Collection.

  ## Preconditions

  `sizes.size() == NumDims;`

    explicit const_multi_array_ref(const element* data,
                         extent_gen::gen_type<NumDims>::type ranges,
                         const storage_order& store = c_storage_order());

  ## Effects

  This constructs a `const_multi_array_ref` using the specified parameters. `ranges` specifies the shape and index bases of the constructed const_multi_array_ref. It is the result of `NumDims` chained calls to `extent_gen::operator[]`. `store` specifies the storage order or layout in memory of the array dimensions.

    const_multi_array_ref(const const_multi_array_ref& x);

  ## Effects

  This constructs a shallow copy of `x`.