<sect2 id="const_multi_array_ref">
<title><literal>const_multi_array_ref</literal></title>

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


<formalpara>
      <title>Model Of.</title>
<para>
<literal>const_multi_array_ref</literal> models
<link linkend="MultiArray">MultiArray</link>,
<ulink url="../../../libs/utility/CopyConstructible.html">CopyConstructible</ulink>.
and depending on the element type, it may also model
<ulink url="http://www.sgi.com/tech/stl/EqualityComparable.html">EqualityComparable</ulink> and <ulink url="http://www.sgi.com/tech/stl/LessThanComparable.html">LessThanComparable</ulink>. 

Detailed descriptions are provided here only for operations that are
not described in the <literal>multi_array</literal> reference.
</para>
</formalpara>

<formalpara>
<title>Synopsis</title>

<programlisting>
<![CDATA[
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);
};
]]>
</programlisting>
</formalpara>

<formalpara>
<title>Constructors</title>

<variablelist>
<varlistentry>
<term><programlisting>template &lt;typename ExtentList&gt;
explicit const_multi_array_ref(const element* data, 
                     const ExtentList&amp; sizes,
                     const storage_order&amp; store = c_storage_order());
</programlisting></term>
<listitem>

<para>
This constructs a <literal>const_multi_array_ref</literal> using the specified
parameters.  <literal>sizes</literal> specifies the shape of the
constructed <literal>const_multi_array_ref</literal>.  <literal>store</literal>
specifies the storage order or layout in memory of the array
dimensions.
</para>

<formalpara><title><literal>ExtentList</literal> Requirements</title>
<para>
<literal>ExtentList</literal> must model <ulink url="../../utility/Collection.html">Collection</ulink>.
</para>
</formalpara>

<formalpara><title>Preconditions</title>
<para><literal>sizes.size() == NumDims;</literal></para>
</formalpara>

</listitem>
</varlistentry>

<varlistentry>
<term>
<programlisting><![CDATA[explicit const_multi_array_ref(const element* data,
                     extent_gen::gen_type<NumDims>::type ranges,
                     const storage_order& store = c_storage_order());]]>
</programlisting></term> 
<listitem>
<formalpara><title>Effects</title>
<para>
This constructs a <literal>const_multi_array_ref</literal> using the specified
    parameters.  <literal>ranges</literal> specifies the shape and
index bases of the constructed const_multi_array_ref. It is the result of 
<literal>NumDims</literal> chained calls to 
    <literal>extent_gen::operator[]</literal>. <literal>store</literal>
specifies the storage order or layout in memory of the array
dimensions. 
</para>
</formalpara>
</listitem>
</varlistentry> 


<varlistentry>
<term><programlisting>
<![CDATA[const_multi_array_ref(const const_multi_array_ref& x);]]>
</programlisting></term>
<listitem>
<formalpara>
<title>Effects</title>
		  <para>This constructs a shallow copy of <literal>x</literal>.
</para></formalpara>
</listitem>
</varlistentry>

</variablelist>

</formalpara>

</sect2>
