epoc32/include/stdapis/boost/multi_array/base.hpp
author William Roberts <williamr@symbian.org>
Tue, 16 Mar 2010 16:12:26 +0000
branchSymbian2
changeset 2 2fe1408b6811
permissions -rw-r--r--
Final list of Symbian^2 public API header files
williamr@2
     1
// Copyright 2002 The Trustees of Indiana University.
williamr@2
     2
williamr@2
     3
// Use, modification and distribution is subject to the Boost Software 
williamr@2
     4
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
williamr@2
     5
// http://www.boost.org/LICENSE_1_0.txt)
williamr@2
     6
williamr@2
     7
//  Boost.MultiArray Library
williamr@2
     8
//  Authors: Ronald Garcia
williamr@2
     9
//           Jeremy Siek
williamr@2
    10
//           Andrew Lumsdaine
williamr@2
    11
//  See http://www.boost.org/libs/multi_array for documentation.
williamr@2
    12
williamr@2
    13
#ifndef BASE_RG071801_HPP
williamr@2
    14
#define BASE_RG071801_HPP
williamr@2
    15
williamr@2
    16
//
williamr@2
    17
// base.hpp - some implementation base classes for from which
williamr@2
    18
// functionality is acquired
williamr@2
    19
//
williamr@2
    20
williamr@2
    21
#include "boost/multi_array/extent_range.hpp"
williamr@2
    22
#include "boost/multi_array/extent_gen.hpp"
williamr@2
    23
#include "boost/multi_array/index_range.hpp"
williamr@2
    24
#include "boost/multi_array/index_gen.hpp"
williamr@2
    25
#include "boost/multi_array/storage_order.hpp"
williamr@2
    26
#include "boost/multi_array/types.hpp"
williamr@2
    27
#include "boost/config.hpp"
williamr@2
    28
#include "boost/multi_array/concept_checks.hpp" //for ignore_unused_...
williamr@2
    29
#include "boost/mpl/eval_if.hpp"
williamr@2
    30
#include "boost/mpl/if.hpp"
williamr@2
    31
#include "boost/mpl/size_t.hpp"
williamr@2
    32
#include "boost/mpl/aux_/msvc_eti_base.hpp"
williamr@2
    33
#include "boost/iterator/reverse_iterator.hpp"
williamr@2
    34
#include "boost/static_assert.hpp"
williamr@2
    35
#include "boost/type.hpp"
williamr@2
    36
#include "boost/assert.hpp"
williamr@2
    37
#include <cstddef>
williamr@2
    38
#include <memory>
williamr@2
    39
williamr@2
    40
namespace boost {
williamr@2
    41
williamr@2
    42
/////////////////////////////////////////////////////////////////////////
williamr@2
    43
// class declarations
williamr@2
    44
/////////////////////////////////////////////////////////////////////////
williamr@2
    45
williamr@2
    46
template<typename T, std::size_t NumDims,
williamr@2
    47
  typename Allocator = std::allocator<T> >
williamr@2
    48
class multi_array;
williamr@2
    49
williamr@2
    50
// This is a public interface for use by end users!
williamr@2
    51
namespace multi_array_types {
williamr@2
    52
  typedef boost::detail::multi_array::size_type size_type;
williamr@2
    53
  typedef std::ptrdiff_t difference_type;
williamr@2
    54
  typedef boost::detail::multi_array::index index;
williamr@2
    55
  typedef detail::multi_array::index_range<index,size_type> index_range;
williamr@2
    56
  typedef detail::multi_array::extent_range<index,size_type> extent_range;
williamr@2
    57
  typedef detail::multi_array::index_gen<0,0> index_gen;
williamr@2
    58
  typedef detail::multi_array::extent_gen<0> extent_gen;
williamr@2
    59
}
williamr@2
    60
williamr@2
    61
williamr@2
    62
// boost::extents and boost::indices are now a part of the public
williamr@2
    63
// interface.  That way users don't necessarily have to create their 
williamr@2
    64
// own objects.  On the other hand, one may not want the overhead of 
williamr@2
    65
// object creation in small-memory environments.  Thus, the objects
williamr@2
    66
// can be left undefined by defining BOOST_MULTI_ARRAY_NO_GENERATORS 
williamr@2
    67
// before loading multi_array.hpp.
williamr@2
    68
#if !BOOST_MULTI_ARRAY_NO_GENERATORS
williamr@2
    69
namespace {
williamr@2
    70
  multi_array_types::extent_gen extents;
williamr@2
    71
  multi_array_types::index_gen indices;
williamr@2
    72
}
williamr@2
    73
#endif // BOOST_MULTI_ARRAY_NO_GENERATORS
williamr@2
    74
williamr@2
    75
namespace detail {
williamr@2
    76
namespace multi_array {
williamr@2
    77
williamr@2
    78
template <typename T, std::size_t NumDims>
williamr@2
    79
class sub_array;
williamr@2
    80
williamr@2
    81
template <typename T, std::size_t NumDims, typename TPtr = const T*>
williamr@2
    82
class const_sub_array;
williamr@2
    83
williamr@2
    84
template <typename T, typename TPtr, typename NumDims, typename Reference>
williamr@2
    85
class array_iterator;
williamr@2
    86
williamr@2
    87
template <typename T, std::size_t NumDims, typename TPtr = const T*>
williamr@2
    88
class const_multi_array_view;
williamr@2
    89
williamr@2
    90
template <typename T, std::size_t NumDims>
williamr@2
    91
class multi_array_view;
williamr@2
    92
williamr@2
    93
/////////////////////////////////////////////////////////////////////////
williamr@2
    94
// class interfaces
williamr@2
    95
/////////////////////////////////////////////////////////////////////////
williamr@2
    96
williamr@2
    97
class multi_array_base {
williamr@2
    98
public:
williamr@2
    99
  typedef multi_array_types::size_type size_type;
williamr@2
   100
  typedef multi_array_types::difference_type difference_type;
williamr@2
   101
  typedef multi_array_types::index index;
williamr@2
   102
  typedef multi_array_types::index_range index_range;
williamr@2
   103
  typedef multi_array_types::extent_range extent_range;
williamr@2
   104
  typedef multi_array_types::index_gen index_gen;
williamr@2
   105
  typedef multi_array_types::extent_gen extent_gen;
williamr@2
   106
};
williamr@2
   107
williamr@2
   108
//
williamr@2
   109
// value_accessor_n
williamr@2
   110
//  contains the routines for accessing elements from
williamr@2
   111
//  N-dimensional views.
williamr@2
   112
//
williamr@2
   113
template<typename T, std::size_t NumDims>
williamr@2
   114
class value_accessor_n : public multi_array_base {
williamr@2
   115
  typedef multi_array_base super_type;
williamr@2
   116
public:
williamr@2
   117
  typedef typename super_type::index index;
williamr@2
   118
williamr@2
   119
  // 
williamr@2
   120
  // public typedefs used by classes that inherit from this base
williamr@2
   121
  //
williamr@2
   122
  typedef T element;
williamr@2
   123
  typedef boost::multi_array<T,NumDims-1> value_type;
williamr@2
   124
  typedef sub_array<T,NumDims-1> reference;
williamr@2
   125
  typedef const_sub_array<T,NumDims-1> const_reference;
williamr@2
   126
williamr@2
   127
protected:
williamr@2
   128
  // used by array operator[] and iterators to get reference types.
williamr@2
   129
  template <typename Reference, typename TPtr>
williamr@2
   130
  Reference access(boost::type<Reference>,index idx,TPtr base,
williamr@2
   131
                   const size_type* extents,
williamr@2
   132
                   const index* strides,
williamr@2
   133
                   const index* index_bases) const {
williamr@2
   134
williamr@2
   135
    BOOST_ASSERT(idx - index_bases[0] >= 0);
williamr@2
   136
    BOOST_ASSERT(size_type(idx - index_bases[0]) < extents[0]);
williamr@2
   137
    // return a sub_array<T,NDims-1> proxy object
williamr@2
   138
    TPtr newbase = base + idx * strides[0];
williamr@2
   139
    return Reference(newbase,extents+1,strides+1,index_bases+1);
williamr@2
   140
williamr@2
   141
  }
williamr@2
   142
williamr@2
   143
  value_accessor_n() { }
williamr@2
   144
  ~value_accessor_n() { }
williamr@2
   145
};
williamr@2
   146
williamr@2
   147
williamr@2
   148
williamr@2
   149
//
williamr@2
   150
// value_accessor_one
williamr@2
   151
//  contains the routines for accessing reference elements from
williamr@2
   152
//  1-dimensional views.
williamr@2
   153
//
williamr@2
   154
template<typename T>
williamr@2
   155
class value_accessor_one : public multi_array_base {
williamr@2
   156
  typedef multi_array_base super_type;
williamr@2
   157
public:
williamr@2
   158
  typedef typename super_type::index index;
williamr@2
   159
  //
williamr@2
   160
  // public typedefs for use by classes that inherit it.
williamr@2
   161
  //
williamr@2
   162
  typedef T element;
williamr@2
   163
  typedef T value_type;
williamr@2
   164
  typedef T& reference;
williamr@2
   165
  typedef T const& const_reference;
williamr@2
   166
williamr@2
   167
protected:
williamr@2
   168
  // used by array operator[] and iterators to get reference types.
williamr@2
   169
  template <typename Reference, typename TPtr>
williamr@2
   170
  Reference access(boost::type<Reference>,index idx,TPtr base,
williamr@2
   171
                   const size_type* extents,
williamr@2
   172
                   const index* strides,
williamr@2
   173
                   const index* index_bases) const {
williamr@2
   174
williamr@2
   175
    ignore_unused_variable_warning(index_bases);
williamr@2
   176
    ignore_unused_variable_warning(extents);
williamr@2
   177
    BOOST_ASSERT(idx - index_bases[0] >= 0);
williamr@2
   178
    BOOST_ASSERT(size_type(idx - index_bases[0]) < extents[0]);
williamr@2
   179
    return *(base + idx * strides[0]);
williamr@2
   180
  }
williamr@2
   181
williamr@2
   182
  value_accessor_one() { }
williamr@2
   183
  ~value_accessor_one() { }
williamr@2
   184
};
williamr@2
   185
williamr@2
   186
williamr@2
   187
/////////////////////////////////////////////////////////////////////////
williamr@2
   188
// choose value accessor begins
williamr@2
   189
//
williamr@2
   190
williamr@2
   191
template <typename T, std::size_t NumDims>
williamr@2
   192
struct choose_value_accessor_n {
williamr@2
   193
  typedef value_accessor_n<T,NumDims> type;
williamr@2
   194
};
williamr@2
   195
williamr@2
   196
template <typename T>
williamr@2
   197
struct choose_value_accessor_one {
williamr@2
   198
  typedef value_accessor_one<T> type;
williamr@2
   199
};
williamr@2
   200
williamr@2
   201
template <typename T, typename NumDims>
williamr@2
   202
struct value_accessor_generator {
williamr@2
   203
    BOOST_STATIC_CONSTANT(std::size_t, dimensionality = NumDims::value);
williamr@2
   204
    
williamr@2
   205
  typedef typename
williamr@2
   206
  mpl::eval_if_c<(dimensionality == 1),
williamr@2
   207
                  choose_value_accessor_one<T>,
williamr@2
   208
                  choose_value_accessor_n<T,dimensionality>
williamr@2
   209
  >::type type;
williamr@2
   210
};
williamr@2
   211
williamr@2
   212
#if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
williamr@2
   213
williamr@2
   214
struct eti_value_accessor
williamr@2
   215
{
williamr@2
   216
  typedef int index;
williamr@2
   217
  typedef int size_type;
williamr@2
   218
  typedef int element;
williamr@2
   219
  typedef int index_range;
williamr@2
   220
  typedef int value_type;
williamr@2
   221
  typedef int reference;
williamr@2
   222
  typedef int const_reference;
williamr@2
   223
};
williamr@2
   224
    
williamr@2
   225
template <>
williamr@2
   226
struct value_accessor_generator<int,int>
williamr@2
   227
{
williamr@2
   228
  typedef eti_value_accessor type;
williamr@2
   229
};
williamr@2
   230
williamr@2
   231
template <class T, class NumDims>
williamr@2
   232
struct associated_types
williamr@2
   233
  : mpl::aux::msvc_eti_base<
williamr@2
   234
        typename value_accessor_generator<T,NumDims>::type
williamr@2
   235
    >::type
williamr@2
   236
{};
williamr@2
   237
williamr@2
   238
template <>
williamr@2
   239
struct associated_types<int,int> : eti_value_accessor {};
williamr@2
   240
williamr@2
   241
#else
williamr@2
   242
williamr@2
   243
template <class T, class NumDims>
williamr@2
   244
struct associated_types
williamr@2
   245
  : value_accessor_generator<T,NumDims>::type
williamr@2
   246
{};
williamr@2
   247
williamr@2
   248
#endif
williamr@2
   249
williamr@2
   250
//
williamr@2
   251
// choose value accessor ends
williamr@2
   252
/////////////////////////////////////////////////////////////////////////
williamr@2
   253
williamr@2
   254
williamr@2
   255
williamr@2
   256
////////////////////////////////////////////////////////////////////////
williamr@2
   257
// multi_array_base
williamr@2
   258
////////////////////////////////////////////////////////////////////////
williamr@2
   259
template <typename T, std::size_t NumDims>
williamr@2
   260
class multi_array_impl_base
williamr@2
   261
  :
williamr@2
   262
#if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
williamr@2
   263
      public mpl::aux::msvc_eti_base<
williamr@2
   264
          typename value_accessor_generator<T,mpl::size_t<NumDims> >::type
williamr@2
   265
       >::type
williamr@2
   266
#else
williamr@2
   267
      public value_accessor_generator<T,mpl::size_t<NumDims> >::type
williamr@2
   268
#endif 
williamr@2
   269
{
williamr@2
   270
  typedef associated_types<T,mpl::size_t<NumDims> > types;
williamr@2
   271
public:
williamr@2
   272
  typedef typename types::index index;
williamr@2
   273
  typedef typename types::size_type size_type;
williamr@2
   274
  typedef typename types::element element;
williamr@2
   275
  typedef typename types::index_range index_range;
williamr@2
   276
  typedef typename types::value_type value_type;
williamr@2
   277
  typedef typename types::reference reference;
williamr@2
   278
  typedef typename types::const_reference const_reference;
williamr@2
   279
williamr@2
   280
  template <std::size_t NDims>
williamr@2
   281
  struct subarray {
williamr@2
   282
    typedef boost::detail::multi_array::sub_array<T,NDims> type;
williamr@2
   283
  };
williamr@2
   284
williamr@2
   285
  template <std::size_t NDims>
williamr@2
   286
  struct const_subarray {
williamr@2
   287
    typedef boost::detail::multi_array::const_sub_array<T,NDims> type;
williamr@2
   288
  };
williamr@2
   289
williamr@2
   290
  template <std::size_t NDims>
williamr@2
   291
  struct array_view {
williamr@2
   292
    typedef boost::detail::multi_array::multi_array_view<T,NDims> type;
williamr@2
   293
  };
williamr@2
   294
williamr@2
   295
  template <std::size_t NDims>
williamr@2
   296
  struct const_array_view {
williamr@2
   297
  public:
williamr@2
   298
    typedef boost::detail::multi_array::const_multi_array_view<T,NDims> type;
williamr@2
   299
  };
williamr@2
   300
williamr@2
   301
  //
williamr@2
   302
  // iterator support
williamr@2
   303
  //
williamr@2
   304
  typedef array_iterator<T,T*,mpl::size_t<NumDims>,reference> iterator;
williamr@2
   305
  typedef array_iterator<T,T const*,mpl::size_t<NumDims>,const_reference> const_iterator;
williamr@2
   306
williamr@2
   307
  typedef ::boost::reverse_iterator<iterator> reverse_iterator;
williamr@2
   308
  typedef ::boost::reverse_iterator<const_iterator> const_reverse_iterator;
williamr@2
   309
williamr@2
   310
  BOOST_STATIC_CONSTANT(std::size_t, dimensionality = NumDims);
williamr@2
   311
protected:
williamr@2
   312
williamr@2
   313
  multi_array_impl_base() { }
williamr@2
   314
  ~multi_array_impl_base() { }
williamr@2
   315
williamr@2
   316
  // Used by operator() in our array classes
williamr@2
   317
  template <typename Reference, typename IndexList, typename TPtr>
williamr@2
   318
  Reference access_element(boost::type<Reference>,
williamr@2
   319
                           const IndexList& indices,
williamr@2
   320
                           TPtr base,
williamr@2
   321
                           const size_type* extents,
williamr@2
   322
                           const index* strides,
williamr@2
   323
                           const index* index_bases) const {
williamr@2
   324
williamr@2
   325
    ignore_unused_variable_warning(index_bases);
williamr@2
   326
    ignore_unused_variable_warning(extents);
williamr@2
   327
#if !defined(NDEBUG) && !defined(BOOST_DISABLE_ASSERTS)
williamr@2
   328
    for (size_type i = 0; i != NumDims; ++i) {
williamr@2
   329
      BOOST_ASSERT(indices[i] - index_bases[i] >= 0);
williamr@2
   330
      BOOST_ASSERT(size_type(indices[i] - index_bases[i]) < extents[i]);
williamr@2
   331
    }
williamr@2
   332
#endif
williamr@2
   333
williamr@2
   334
    index offset = 0;
williamr@2
   335
    for (size_type n = 0; n != NumDims; ++n) 
williamr@2
   336
      offset += indices[n] * strides[n];
williamr@2
   337
    
williamr@2
   338
    return base[offset];
williamr@2
   339
  }
williamr@2
   340
williamr@2
   341
  template <typename StrideList, typename ExtentList>
williamr@2
   342
  void compute_strides(StrideList& stride_list, ExtentList& extent_list,
williamr@2
   343
                       const general_storage_order<NumDims>& storage)
williamr@2
   344
  {
williamr@2
   345
    // invariant: stride = the stride for dimension n
williamr@2
   346
    index stride = 1;
williamr@2
   347
    for (size_type n = 0; n != NumDims; ++n) {
williamr@2
   348
      index stride_sign = +1;
williamr@2
   349
      
williamr@2
   350
      if (!storage.ascending(storage.ordering(n)))
williamr@2
   351
        stride_sign = -1;
williamr@2
   352
      
williamr@2
   353
      // The stride for this dimension is the product of the
williamr@2
   354
      // lengths of the ranks minor to it.
williamr@2
   355
      stride_list[storage.ordering(n)] = stride * stride_sign;
williamr@2
   356
      
williamr@2
   357
      stride *= extent_list[storage.ordering(n)];
williamr@2
   358
    } 
williamr@2
   359
  }
williamr@2
   360
williamr@2
   361
  // This calculates the offset to the array base pointer due to:
williamr@2
   362
  // 1. dimensions stored in descending order
williamr@2
   363
  // 2. non-zero dimension index bases
williamr@2
   364
  template <typename StrideList, typename ExtentList, typename BaseList>
williamr@2
   365
  index
williamr@2
   366
  calculate_origin_offset(const StrideList& stride_list,
williamr@2
   367
                          const ExtentList& extent_list,
williamr@2
   368
                          const general_storage_order<NumDims>& storage,
williamr@2
   369
                          const BaseList& index_base_list)
williamr@2
   370
  {
williamr@2
   371
    return
williamr@2
   372
      calculate_descending_dimension_offset(stride_list,extent_list,
williamr@2
   373
                                            storage) +
williamr@2
   374
      calculate_indexing_offset(stride_list,index_base_list);
williamr@2
   375
  }
williamr@2
   376
williamr@2
   377
  // This calculates the offset added to the base pointer that are
williamr@2
   378
  // caused by descending dimensions
williamr@2
   379
  template <typename StrideList, typename ExtentList>
williamr@2
   380
  index
williamr@2
   381
  calculate_descending_dimension_offset(const StrideList& stride_list,
williamr@2
   382
                                const ExtentList& extent_list,
williamr@2
   383
                                const general_storage_order<NumDims>& storage)
williamr@2
   384
  {
williamr@2
   385
    index offset = 0;
williamr@2
   386
    if (!storage.all_dims_ascending()) 
williamr@2
   387
      for (size_type n = 0; n != NumDims; ++n)
williamr@2
   388
        if (!storage.ascending(n))
williamr@2
   389
          offset -= (extent_list[n] - 1) * stride_list[n];
williamr@2
   390
williamr@2
   391
    return offset;
williamr@2
   392
  }
williamr@2
   393
williamr@2
   394
  // This is used to reindex array_views, which are no longer
williamr@2
   395
  // concerned about storage order (specifically, whether dimensions
williamr@2
   396
  // are ascending or descending) since the viewed array handled it.
williamr@2
   397
williamr@2
   398
  template <typename StrideList, typename BaseList>
williamr@2
   399
  index
williamr@2
   400
  calculate_indexing_offset(const StrideList& stride_list,
williamr@2
   401
                          const BaseList& index_base_list)
williamr@2
   402
  {
williamr@2
   403
    index offset = 0;
williamr@2
   404
    for (size_type n = 0; n != NumDims; ++n)
williamr@2
   405
        offset -= stride_list[n] * index_base_list[n];
williamr@2
   406
    return offset;
williamr@2
   407
  }
williamr@2
   408
williamr@2
   409
  // Slicing using an index_gen.
williamr@2
   410
  // Note that populating an index_gen creates a type that encodes
williamr@2
   411
  // both the number of dimensions in the current Array (NumDims), and 
williamr@2
   412
  // the Number of dimensions for the resulting view.  This allows the 
williamr@2
   413
  // compiler to fail if the dimensions aren't completely accounted
williamr@2
   414
  // for.  For reasons unbeknownst to me, a BOOST_STATIC_ASSERT
williamr@2
   415
  // within the member function template does not work. I should add a 
williamr@2
   416
  // note to the documentation specifying that you get a damn ugly
williamr@2
   417
  // error message if you screw up in your slicing code.
williamr@2
   418
  template <typename ArrayRef, int NDims, typename TPtr>
williamr@2
   419
  ArrayRef
williamr@2
   420
  generate_array_view(boost::type<ArrayRef>,
williamr@2
   421
                      const boost::detail::multi_array::
williamr@2
   422
                      index_gen<NumDims,NDims>& indices,
williamr@2
   423
                      const size_type* extents,
williamr@2
   424
                      const index* strides,
williamr@2
   425
                      const index* index_bases,
williamr@2
   426
                      TPtr base) const {
williamr@2
   427
williamr@2
   428
    boost::array<index,NDims> new_strides;
williamr@2
   429
    boost::array<index,NDims> new_extents;
williamr@2
   430
williamr@2
   431
    index offset = 0;
williamr@2
   432
    size_type dim = 0;
williamr@2
   433
    for (size_type n = 0; n != NumDims; ++n) {
williamr@2
   434
      const index default_start = index_bases[n];
williamr@2
   435
      const index default_finish = default_start+extents[n];
williamr@2
   436
      const index_range& current_range = indices.ranges_[n];
williamr@2
   437
      index start = current_range.get_start(default_start);
williamr@2
   438
      index finish = current_range.get_finish(default_finish);
williamr@2
   439
      index index_factor = current_range.stride();
williamr@2
   440
      index len = (finish - start + (index_factor - 1)) / index_factor;
williamr@2
   441
williamr@2
   442
      BOOST_ASSERT(index_bases[n] <= start &&
williamr@2
   443
                   start <= index_bases[n]+index(extents[n]));
williamr@2
   444
      BOOST_ASSERT(index_bases[n] <= finish &&
williamr@2
   445
                   finish <= index_bases[n]+index(extents[n]));
williamr@2
   446
      BOOST_ASSERT(index_factor > 0);
williamr@2
   447
williamr@2
   448
      // the array data pointer is modified to account for non-zero
williamr@2
   449
      // bases during slicing (see [Garcia] for the math involved)
williamr@2
   450
      offset += start * strides[n];
williamr@2
   451
williamr@2
   452
      if (!current_range.is_degenerate()) {
williamr@2
   453
williamr@2
   454
        // The index_factor for each dimension is included into the
williamr@2
   455
        // strides for the array_view (see [Garcia] for the math involved).
williamr@2
   456
        new_strides[dim] = index_factor * strides[n];
williamr@2
   457
        
williamr@2
   458
        // calculate new extents
williamr@2
   459
        new_extents[dim] = len;
williamr@2
   460
        ++dim;
williamr@2
   461
      }
williamr@2
   462
    }
williamr@2
   463
    BOOST_ASSERT(dim == NDims);
williamr@2
   464
williamr@2
   465
    return
williamr@2
   466
      ArrayRef(base+offset,
williamr@2
   467
               new_extents,
williamr@2
   468
               new_strides);
williamr@2
   469
  }
williamr@2
   470
                     
williamr@2
   471
williamr@2
   472
};
williamr@2
   473
williamr@2
   474
} // namespace multi_array
williamr@2
   475
} // namespace detail
williamr@2
   476
williamr@2
   477
} // namespace boost
williamr@2
   478
williamr@2
   479
#endif // BASE_RG071801_HPP