epoc32/include/stdapis/boost/multi_array/view.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 BOOST_MULTI_ARRAY_VIEW_RG071301_HPP
williamr@2
    14
#define BOOST_MULTI_ARRAY_VIEW_RG071301_HPP
williamr@2
    15
williamr@2
    16
//
williamr@2
    17
// view.hpp - code for creating "views" of array data.
williamr@2
    18
//
williamr@2
    19
williamr@2
    20
#include "boost/multi_array/base.hpp"
williamr@2
    21
#include "boost/multi_array/concept_checks.hpp"
williamr@2
    22
#include "boost/multi_array/iterator.hpp"
williamr@2
    23
#include "boost/multi_array/storage_order.hpp"
williamr@2
    24
#include "boost/multi_array/subarray.hpp"
williamr@2
    25
#include "boost/multi_array/algorithm.hpp"
williamr@2
    26
#include "boost/type_traits/is_integral.hpp"
williamr@2
    27
#include "boost/array.hpp"
williamr@2
    28
#include "boost/limits.hpp"
williamr@2
    29
#include <algorithm>
williamr@2
    30
#include <cstddef>
williamr@2
    31
#include <functional>
williamr@2
    32
#include <numeric>
williamr@2
    33
williamr@2
    34
namespace boost {
williamr@2
    35
namespace detail {
williamr@2
    36
namespace multi_array {
williamr@2
    37
williamr@2
    38
// TPtr = const T* defaulted in base.hpp
williamr@2
    39
template <typename T, std::size_t NumDims, typename TPtr>
williamr@2
    40
class const_multi_array_view :
williamr@2
    41
    public boost::detail::multi_array::multi_array_impl_base<T,NumDims>
williamr@2
    42
{
williamr@2
    43
  typedef boost::detail::multi_array::multi_array_impl_base<T,NumDims> super_type;
williamr@2
    44
public: 
williamr@2
    45
  typedef typename super_type::value_type value_type;
williamr@2
    46
  typedef typename super_type::const_reference const_reference;
williamr@2
    47
  typedef typename super_type::const_iterator const_iterator;
williamr@2
    48
  typedef typename super_type::const_reverse_iterator const_reverse_iterator;
williamr@2
    49
  typedef typename super_type::element element;
williamr@2
    50
  typedef typename super_type::size_type size_type;
williamr@2
    51
  typedef typename super_type::difference_type difference_type;
williamr@2
    52
  typedef typename super_type::index index;
williamr@2
    53
  typedef typename super_type::extent_range extent_range;
williamr@2
    54
williamr@2
    55
  // template typedefs
williamr@2
    56
  template <std::size_t NDims>
williamr@2
    57
  struct const_array_view {
williamr@2
    58
    typedef boost::detail::multi_array::const_multi_array_view<T,NDims> type;
williamr@2
    59
  };
williamr@2
    60
williamr@2
    61
  template <std::size_t NDims>
williamr@2
    62
  struct array_view {
williamr@2
    63
    typedef boost::detail::multi_array::multi_array_view<T,NDims> type;
williamr@2
    64
  };
williamr@2
    65
williamr@2
    66
  template <typename OPtr>
williamr@2
    67
  const_multi_array_view(const 
williamr@2
    68
                         const_multi_array_view<T,NumDims,OPtr>& other) :
williamr@2
    69
    base_(other.base_), origin_offset_(other.origin_offset_),
williamr@2
    70
    num_elements_(other.num_elements_), extent_list_(other.extent_list_),
williamr@2
    71
    stride_list_(other.stride_list_), index_base_list_(other.index_base_list_)
williamr@2
    72
  { }
williamr@2
    73
williamr@2
    74
williamr@2
    75
  template <class BaseList>
williamr@2
    76
#ifdef BOOST_NO_SFINAE
williamr@2
    77
  void
williamr@2
    78
#else
williamr@2
    79
  typename
williamr@2
    80
  disable_if<typename boost::is_integral<BaseList>::type,void >::type
williamr@2
    81
#endif
williamr@2
    82
  reindex(const BaseList& values) {
williamr@2
    83
    boost::function_requires<
williamr@2
    84
      detail::multi_array::CollectionConcept<BaseList> >();
williamr@2
    85
    boost::detail::multi_array::
williamr@2
    86
      copy_n(values.begin(),num_dimensions(),index_base_list_.begin());
williamr@2
    87
    origin_offset_ =
williamr@2
    88
      this->calculate_indexing_offset(stride_list_,index_base_list_);
williamr@2
    89
  }
williamr@2
    90
williamr@2
    91
  void reindex(index value) {
williamr@2
    92
    index_base_list_.assign(value);
williamr@2
    93
    origin_offset_ =
williamr@2
    94
      this->calculate_indexing_offset(stride_list_,index_base_list_);
williamr@2
    95
  }
williamr@2
    96
williamr@2
    97
  size_type num_dimensions() const { return NumDims; }
williamr@2
    98
williamr@2
    99
  size_type size() const { return extent_list_.front(); }
williamr@2
   100
  size_type max_size() const { return num_elements(); }
williamr@2
   101
  bool empty() const { return size() == 0; }
williamr@2
   102
williamr@2
   103
  const size_type* shape() const {
williamr@2
   104
    return extent_list_.data();
williamr@2
   105
  }
williamr@2
   106
williamr@2
   107
  const index* strides() const {
williamr@2
   108
    return stride_list_.data();
williamr@2
   109
  }
williamr@2
   110
williamr@2
   111
  const T* origin() const { return base_+origin_offset_; }
williamr@2
   112
williamr@2
   113
  size_type num_elements() const { return num_elements_; }
williamr@2
   114
williamr@2
   115
  const index* index_bases() const {
williamr@2
   116
    return index_base_list_.data();
williamr@2
   117
  }
williamr@2
   118
williamr@2
   119
  template <typename IndexList>
williamr@2
   120
  const element& operator()(IndexList indices) const {
williamr@2
   121
    boost::function_requires<
williamr@2
   122
      detail::multi_array::CollectionConcept<IndexList> >();
williamr@2
   123
    return super_type::access_element(boost::type<const element&>(),
williamr@2
   124
                                      indices,origin(),
williamr@2
   125
                                      shape(),strides(),index_bases());
williamr@2
   126
  }
williamr@2
   127
williamr@2
   128
  // Only allow const element access
williamr@2
   129
  const_reference operator[](index idx) const {
williamr@2
   130
    return super_type::access(boost::type<const_reference>(),
williamr@2
   131
                              idx,origin(),
williamr@2
   132
                              shape(),strides(),
williamr@2
   133
                              index_bases());
williamr@2
   134
  }
williamr@2
   135
williamr@2
   136
  // see generate_array_view in base.hpp
williamr@2
   137
#if !defined(BOOST_MSVC) || BOOST_MSVC > 1300
williamr@2
   138
  template <int NDims>
williamr@2
   139
#else
williamr@2
   140
  template <int NumDims, int NDims> // else ICE
williamr@2
   141
#endif // BOOST_MSVC
williamr@2
   142
  typename const_array_view<NDims>::type 
williamr@2
   143
  operator[](const boost::detail::multi_array::
williamr@2
   144
             index_gen<NumDims,NDims>& indices)
williamr@2
   145
    const {
williamr@2
   146
    typedef typename const_array_view<NDims>::type return_type;
williamr@2
   147
    return
williamr@2
   148
      super_type::generate_array_view(boost::type<return_type>(),
williamr@2
   149
                                      indices,
williamr@2
   150
                                      shape(),
williamr@2
   151
                                      strides(),
williamr@2
   152
                                      index_bases(),
williamr@2
   153
                                      origin());
williamr@2
   154
  }
williamr@2
   155
  const_iterator begin() const {
williamr@2
   156
    return const_iterator(*index_bases(),origin(),
williamr@2
   157
                          shape(),strides(),index_bases());
williamr@2
   158
  }
williamr@2
   159
williamr@2
   160
  const_iterator end() const {
williamr@2
   161
    return const_iterator(*index_bases()+(index)*shape(),origin(),
williamr@2
   162
                          shape(),strides(),index_bases());
williamr@2
   163
  }
williamr@2
   164
  
williamr@2
   165
  const_reverse_iterator rbegin() const {
williamr@2
   166
    return const_reverse_iterator(end());
williamr@2
   167
  }
williamr@2
   168
williamr@2
   169
  const_reverse_iterator rend() const {
williamr@2
   170
    return const_reverse_iterator(begin());
williamr@2
   171
  }
williamr@2
   172
williamr@2
   173
williamr@2
   174
  template <typename OPtr>
williamr@2
   175
  bool operator==(const
williamr@2
   176
                  const_multi_array_view<T,NumDims,OPtr>& rhs)
williamr@2
   177
    const {
williamr@2
   178
    if(std::equal(extent_list_.begin(),
williamr@2
   179
                  extent_list_.end(),
williamr@2
   180
                  rhs.extent_list_.begin()))
williamr@2
   181
      return std::equal(begin(),end(),rhs.begin());
williamr@2
   182
    else return false;
williamr@2
   183
  }
williamr@2
   184
williamr@2
   185
  template <typename OPtr>
williamr@2
   186
  bool operator<(const
williamr@2
   187
                 const_multi_array_view<T,NumDims,OPtr>& rhs)
williamr@2
   188
    const {
williamr@2
   189
    return std::lexicographical_compare(begin(),end(),rhs.begin(),rhs.end());
williamr@2
   190
  }
williamr@2
   191
williamr@2
   192
  template <typename OPtr>
williamr@2
   193
  bool operator!=(const
williamr@2
   194
                  const_multi_array_view<T,NumDims,OPtr>& rhs)
williamr@2
   195
    const {
williamr@2
   196
    return !(*this == rhs);
williamr@2
   197
  }
williamr@2
   198
williamr@2
   199
  template <typename OPtr>
williamr@2
   200
  bool operator>(const
williamr@2
   201
                 const_multi_array_view<T,NumDims,OPtr>& rhs)
williamr@2
   202
    const {
williamr@2
   203
    return rhs < *this;
williamr@2
   204
  }
williamr@2
   205
williamr@2
   206
  template <typename OPtr>
williamr@2
   207
  bool operator<=(const
williamr@2
   208
                 const_multi_array_view<T,NumDims,OPtr>& rhs)
williamr@2
   209
    const {
williamr@2
   210
    return !(*this > rhs);
williamr@2
   211
  }
williamr@2
   212
williamr@2
   213
  template <typename OPtr>
williamr@2
   214
  bool operator>=(const
williamr@2
   215
                 const_multi_array_view<T,NumDims,OPtr>& rhs)
williamr@2
   216
    const {
williamr@2
   217
    return !(*this < rhs);
williamr@2
   218
  }
williamr@2
   219
williamr@2
   220
williamr@2
   221
#ifndef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
williamr@2
   222
protected:
williamr@2
   223
  template <typename,std::size_t> friend class multi_array_impl_base;
williamr@2
   224
  template <typename,std::size_t,typename> friend class const_multi_array_view;
williamr@2
   225
#else
williamr@2
   226
public: // should be protected
williamr@2
   227
#endif
williamr@2
   228
williamr@2
   229
  // This constructor is used by multi_array_impl_base::generate_array_view
williamr@2
   230
  // to create strides  
williamr@2
   231
  template <typename ExtentList, typename Index>
williamr@2
   232
  explicit const_multi_array_view(TPtr base,
williamr@2
   233
                           const ExtentList& extents,
williamr@2
   234
                           const boost::array<Index,NumDims>& strides): 
williamr@2
   235
    base_(base), origin_offset_(0) {
williamr@2
   236
williamr@2
   237
    index_base_list_.assign(0);
williamr@2
   238
williamr@2
   239
    // Get the extents and strides
williamr@2
   240
    boost::detail::multi_array::
williamr@2
   241
      copy_n(extents.begin(),NumDims,extent_list_.begin());
williamr@2
   242
    boost::detail::multi_array::
williamr@2
   243
      copy_n(strides.begin(),NumDims,stride_list_.begin());
williamr@2
   244
williamr@2
   245
    // Calculate the array size
williamr@2
   246
    num_elements_ = std::accumulate(extent_list_.begin(),extent_list_.end(),
williamr@2
   247
                            size_type(1),std::multiplies<size_type>());
williamr@2
   248
#if 0
williamr@2
   249
    assert(num_elements_ != 0);
williamr@2
   250
#endif
williamr@2
   251
  }
williamr@2
   252
williamr@2
   253
  typedef boost::array<size_type,NumDims> size_list;
williamr@2
   254
  typedef boost::array<index,NumDims> index_list;
williamr@2
   255
williamr@2
   256
  TPtr base_;
williamr@2
   257
  index origin_offset_;
williamr@2
   258
  size_type num_elements_;
williamr@2
   259
  size_list extent_list_;
williamr@2
   260
  index_list stride_list_;
williamr@2
   261
  index_list index_base_list_;
williamr@2
   262
williamr@2
   263
private:
williamr@2
   264
  // const_multi_array_view cannot be assigned to (no deep copies!)
williamr@2
   265
  const_multi_array_view& operator=(const const_multi_array_view& other);
williamr@2
   266
};
williamr@2
   267
williamr@2
   268
williamr@2
   269
template <typename T, std::size_t NumDims>
williamr@2
   270
class multi_array_view :
williamr@2
   271
  public const_multi_array_view<T,NumDims,T*>
williamr@2
   272
{
williamr@2
   273
  typedef const_multi_array_view<T,NumDims,T*> super_type;
williamr@2
   274
public: 
williamr@2
   275
  typedef typename super_type::value_type value_type;
williamr@2
   276
  typedef typename super_type::reference reference;
williamr@2
   277
  typedef typename super_type::iterator iterator;
williamr@2
   278
  typedef typename super_type::reverse_iterator reverse_iterator;
williamr@2
   279
  typedef typename super_type::const_reference const_reference;
williamr@2
   280
  typedef typename super_type::const_iterator const_iterator;
williamr@2
   281
  typedef typename super_type::const_reverse_iterator const_reverse_iterator;
williamr@2
   282
  typedef typename super_type::element element;
williamr@2
   283
  typedef typename super_type::size_type size_type;
williamr@2
   284
  typedef typename super_type::difference_type difference_type;
williamr@2
   285
  typedef typename super_type::index index;
williamr@2
   286
  typedef typename super_type::extent_range extent_range;
williamr@2
   287
williamr@2
   288
  // template typedefs
williamr@2
   289
  template <std::size_t NDims>
williamr@2
   290
  struct const_array_view {
williamr@2
   291
    typedef boost::detail::multi_array::const_multi_array_view<T,NDims> type;
williamr@2
   292
  };
williamr@2
   293
williamr@2
   294
  template <std::size_t NDims>
williamr@2
   295
  struct array_view {
williamr@2
   296
    typedef boost::detail::multi_array::multi_array_view<T,NDims> type;
williamr@2
   297
  };
williamr@2
   298
williamr@2
   299
  // Assignment from other ConstMultiArray types.
williamr@2
   300
  template <typename ConstMultiArray>
williamr@2
   301
  multi_array_view& operator=(const ConstMultiArray& other) {
williamr@2
   302
    function_requires< 
williamr@2
   303
      boost::detail::multi_array::
williamr@2
   304
      ConstMultiArrayConcept<ConstMultiArray,NumDims> >();
williamr@2
   305
williamr@2
   306
    // make sure the dimensions agree
williamr@2
   307
    assert(other.num_dimensions() == this->num_dimensions());
williamr@2
   308
    assert(std::equal(other.shape(),other.shape()+this->num_dimensions(),
williamr@2
   309
                      this->shape()));
williamr@2
   310
    // iterator-based copy
williamr@2
   311
    std::copy(other.begin(),other.end(),begin());
williamr@2
   312
    return *this;
williamr@2
   313
  }
williamr@2
   314
williamr@2
   315
williamr@2
   316
  multi_array_view& operator=(const multi_array_view& other) {
williamr@2
   317
    if (&other != this) {
williamr@2
   318
      // make sure the dimensions agree
williamr@2
   319
      assert(other.num_dimensions() == this->num_dimensions());
williamr@2
   320
      assert(std::equal(other.shape(),other.shape()+this->num_dimensions(),
williamr@2
   321
                        this->shape()));
williamr@2
   322
      // iterator-based copy
williamr@2
   323
      std::copy(other.begin(),other.end(),begin());
williamr@2
   324
    }
williamr@2
   325
    return *this;
williamr@2
   326
  }
williamr@2
   327
williamr@2
   328
  element* origin() { return this->base_+this->origin_offset_; }
williamr@2
   329
williamr@2
   330
  template <class IndexList>
williamr@2
   331
  element& operator()(const IndexList& indices) {
williamr@2
   332
    boost::function_requires<
williamr@2
   333
      detail::multi_array::CollectionConcept<IndexList> >();
williamr@2
   334
    return super_type::access_element(boost::type<element&>(),
williamr@2
   335
                                      indices,origin(),
williamr@2
   336
                                      this->shape(),this->strides(),
williamr@2
   337
                                      this->index_bases());
williamr@2
   338
  }
williamr@2
   339
williamr@2
   340
williamr@2
   341
  reference operator[](index idx) {
williamr@2
   342
    return super_type::access(boost::type<reference>(),
williamr@2
   343
                              idx,origin(),
williamr@2
   344
                              this->shape(),this->strides(),
williamr@2
   345
                              this->index_bases());
williamr@2
   346
  }
williamr@2
   347
williamr@2
   348
williamr@2
   349
  // see generate_array_view in base.hpp
williamr@2
   350
#if !defined(BOOST_MSVC) || BOOST_MSVC > 1300
williamr@2
   351
  template <int NDims>
williamr@2
   352
#else
williamr@2
   353
  template <int NumDims, int NDims> // else ICE
williamr@2
   354
#endif // BOOST_MSVC
williamr@2
   355
  typename array_view<NDims>::type 
williamr@2
   356
  operator[](const boost::detail::multi_array::
williamr@2
   357
             index_gen<NumDims,NDims>& indices) {
williamr@2
   358
    typedef typename array_view<NDims>::type return_type;
williamr@2
   359
    return
williamr@2
   360
      super_type::generate_array_view(boost::type<return_type>(),
williamr@2
   361
                                      indices,
williamr@2
   362
                                      this->shape(),
williamr@2
   363
                                      this->strides(),
williamr@2
   364
                                      this->index_bases(),
williamr@2
   365
                                      origin());
williamr@2
   366
  }
williamr@2
   367
  
williamr@2
   368
  
williamr@2
   369
  iterator begin() {
williamr@2
   370
    return iterator(*this->index_bases(),origin(),
williamr@2
   371
                    this->shape(),this->strides(),
williamr@2
   372
                    this->index_bases());
williamr@2
   373
  }
williamr@2
   374
williamr@2
   375
  iterator end() {
williamr@2
   376
    return iterator(*this->index_bases()+(index)*this->shape(),origin(),
williamr@2
   377
                    this->shape(),this->strides(),
williamr@2
   378
                    this->index_bases());
williamr@2
   379
  }
williamr@2
   380
williamr@2
   381
  reverse_iterator rbegin() {
williamr@2
   382
    return reverse_iterator(end());
williamr@2
   383
  }
williamr@2
   384
williamr@2
   385
  reverse_iterator rend() {
williamr@2
   386
    return reverse_iterator(begin());
williamr@2
   387
  }
williamr@2
   388
williamr@2
   389
  // Using declarations don't seem to work for g++
williamr@2
   390
  // These are the proxies to work around this.
williamr@2
   391
williamr@2
   392
  const element* origin() const { return super_type::origin(); }
williamr@2
   393
williamr@2
   394
  template <class IndexList>
williamr@2
   395
  const element& operator()(const IndexList& indices) const {
williamr@2
   396
    boost::function_requires<
williamr@2
   397
      detail::multi_array::CollectionConcept<IndexList> >();
williamr@2
   398
    return super_type::operator()(indices);
williamr@2
   399
  }
williamr@2
   400
williamr@2
   401
  const_reference operator[](index idx) const {
williamr@2
   402
    return super_type::operator[](idx);
williamr@2
   403
  }
williamr@2
   404
williamr@2
   405
  // see generate_array_view in base.hpp
williamr@2
   406
#if !defined(BOOST_MSVC) || BOOST_MSVC > 1300
williamr@2
   407
  template <int NDims>
williamr@2
   408
#else
williamr@2
   409
  template <int NumDims, int NDims> // else ICE
williamr@2
   410
#endif // BOOST_MSVC
williamr@2
   411
  typename const_array_view<NDims>::type 
williamr@2
   412
  operator[](const boost::detail::multi_array::
williamr@2
   413
             index_gen<NumDims,NDims>& indices)
williamr@2
   414
    const {
williamr@2
   415
    return super_type::operator[](indices);
williamr@2
   416
  }
williamr@2
   417
  
williamr@2
   418
  const_iterator begin() const {
williamr@2
   419
    return super_type::begin();
williamr@2
   420
  }
williamr@2
   421
williamr@2
   422
  const_iterator end() const {
williamr@2
   423
    return super_type::end();
williamr@2
   424
  }
williamr@2
   425
williamr@2
   426
  const_reverse_iterator rbegin() const {
williamr@2
   427
    return super_type::rbegin();
williamr@2
   428
  }
williamr@2
   429
williamr@2
   430
  const_reverse_iterator rend() const {
williamr@2
   431
    return super_type::rend();
williamr@2
   432
  }
williamr@2
   433
williamr@2
   434
#ifndef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
williamr@2
   435
private:
williamr@2
   436
  template <typename,std::size_t> friend class multi_array_impl_base;
williamr@2
   437
#else
williamr@2
   438
public: // should be private
williamr@2
   439
#endif
williamr@2
   440
williamr@2
   441
  // constructor used by multi_array_impl_base::generate_array_view to
williamr@2
   442
  // generate array views
williamr@2
   443
  template <typename ExtentList, typename Index>
williamr@2
   444
  explicit multi_array_view(T* base,
williamr@2
   445
                            const ExtentList& extents,
williamr@2
   446
                            const boost::array<Index,NumDims>& strides) :
williamr@2
   447
    super_type(base,extents,strides) { }
williamr@2
   448
williamr@2
   449
};
williamr@2
   450
williamr@2
   451
} // namespace multi_array
williamr@2
   452
} // namespace detail
williamr@2
   453
williamr@2
   454
//
williamr@2
   455
// traits classes to get array_view types
williamr@2
   456
//
williamr@2
   457
template <typename Array, int N>
williamr@2
   458
class array_view_gen {
williamr@2
   459
  typedef typename Array::element element;
williamr@2
   460
public:
williamr@2
   461
  typedef boost::detail::multi_array::multi_array_view<element,N> type;
williamr@2
   462
};
williamr@2
   463
williamr@2
   464
template <typename Array, int N>
williamr@2
   465
class const_array_view_gen {
williamr@2
   466
  typedef typename Array::element element;
williamr@2
   467
public:
williamr@2
   468
  typedef boost::detail::multi_array::const_multi_array_view<element,N> type;  
williamr@2
   469
};
williamr@2
   470
williamr@2
   471
} // namespace boost
williamr@2
   472
williamr@2
   473
#endif // BOOST_MULTI_ARRAY_VIEW_RG071301_HPP
williamr@2
   474