ArrayIndexing.h

Go to the documentation of this file.

// -*- C++ -*-

#if !defined(__ArrayIndexing_h__)
#define __ArrayIndexing_h__

// If we are debugging the whole ads package.
#if defined(DEBUG_ads) && !defined(DEBUG_ArrayIndexing)
#define DEBUG_ArrayIndexing
#endif

#include "ArrayIndexIterator.h"

#include <numeric>
#include <iterator>

BEGIN_NAMESPACE_ADS


template<int N, typename T = double>
class ArrayIndexing :
  public ArrayIndexingBase<N> {
  //
  // Private types.
  //

private:

  typedef ArrayTypes<T> types;
  typedef ArrayIndexingBase<N> base_type;

  //
  // Public types.
  //

public:

  typedef typename types::value_type value_type;

  typedef typename types::parameter_type parameter_type;

  typedef typename types::unqualified_value_type unqualified_value_type;

  typedef typename types::pointer pointer;
  typedef typename types::const_pointer const_pointer;

  typedef typename types::reference reference;
  typedef typename types::const_reference const_reference;


  typedef typename types::size_type size_type;
  typedef typename types::difference_type difference_type;

  typedef FixedArray<N,int> index_type;
  typedef IndexRange<N,int> range_type;

  typedef ArrayIndexIterator<N> index_iterator;

private:

  //
  // Member data.
  //

  // The root for indexing, i.e., the location of (*this)(_ranges.lbounds()).
  pointer _root;

protected:

  //--------------------------------------------------------------------------
  // @{

  ArrayIndexing();

  ArrayIndexing(const ArrayIndexing& x);

  ArrayIndexing& 
  operator=(const ArrayIndexing& x);

  template<typename Type>
  ArrayIndexing(const index_type& extents, Type* data);

  template<typename Type>
  void
  rebuild(const index_type& extents, Type* data);

  template<typename Type>
  ArrayIndexing(const range_type& ranges, Type* data);

  template<typename Type>
  void
  rebuild(const range_type& ranges, Type* data);

  void
  swap(ArrayIndexing& x) {
    base_type::swap(x);
    std::swap(_root, x._root);
  }

  ~ArrayIndexing()
  {}

  // @}

public:

  //--------------------------------------------------------------------------
  // @{

  static
  int
  rank() {
    return base_type::rank();
  }

  // @}
  //--------------------------------------------------------------------------
  // @{

  const index_type&
  extents() const { 
    return base_type::extents();
  }

  size_type 
  extent(const int i) const { 
    return base_type::extent(i); 
  }

  const range_type&
  ranges() const { 
    return base_type::ranges();
  }

  const index_type&
  lbounds() const { 
    return base_type::lbounds();
  }

  const index_type&
  ubounds() const { 
    return base_type::ubounds();
  }

  int
  lbound(const int i) const { 
    return base_type::lbound(i);
  }

  int
  ubound(const int i) const { 
    return base_type::ubound(i);
  }

  const index_type& 
  strides() const {
    return base_type::strides();
  }

  index_iterator
  indices_begin() const {
    return index_iterator(*this);
  }

  index_iterator
  indices_end() const {
    index_iterator x(*this);
    x += computeProduct(extents());
    return x;
  }

  const_pointer 
  root() const {
    return _root;
  }

  // @}
  //-------------------------------------------------------------------------
  // @{

  parameter_type
  operator()(const index_type& mi) const { 
    return _root[base_type::root_offset(mi)]; 
  }


  parameter_type
  operator()(const int i0, const int i1) const 
  { 
    return _root[base_type::root_offset(i0, i1)]; 
  }


  parameter_type
  operator()(const int i0, const int i1, const int i2) const 
  { 
    return _root[base_type::root_offset(i0, i1, i2)]; 
  }


  parameter_type
  operator()(const ads::FixedArray<1,int>& index,
              const ads::FixedArray<1,int>& offset) const 
  {
    return _root[base_type::root_offset(index[0] + offset[0])]; 
  }


  parameter_type
  operator()(const ads::FixedArray<2,int>& index,
              const ads::FixedArray<2,int>& offset) const 
  {
    return _root[base_type::root_offset(index[0] + offset[0],
                                          index[1] + offset[1])]; 
  }


  parameter_type
  operator()(const ads::FixedArray<3,int>& index,
              const ads::FixedArray<3,int>& offset) const 
  {
    return _root[base_type::root_offset(index[0] + offset[0],
                                          index[1] + offset[1],
                                          index[2] + offset[2])]; 
  }

  // @}
  //--------------------------------------------------------------------------
  // @{

  int
  index(const index_type& mi) const 
  {
    return base_type::index(mi);
  }


  int
  index(const int i0, const int i1) const
  {
    return base_type::index(i0, i1);
  }


  int
  index(const int i0, const int i1, const int i2) const
  { 
    return base_type::index(i0, i1, i2);
  }


  void 
  index_to_indices(const int index, int& i, int& j) const
  {
    return base_type::index_to_indices(index, i, j);
  }


  void 
  index_to_indices(int index, int& i, int& j, int& k) const
  {
    return base_type::index_to_indices(index, i, j, k);
  }


  void 
  index_to_indices(const int index, ads::FixedArray<2,int>& multi_index) 
    const
  {
    return base_type::index_to_indices(index, multi_index);
  }


  void 
  index_to_indices(const int index, ads::FixedArray<3,int>& multi_index) 
    const
  {
    return base_type::index_to_indices(index, multi_index);
  }

  // @}
  //--------------------------------------------------------------------------
  // @{

  pointer
  root()
  {
    return _root;
  }

  // @}
  //--------------------------------------------------------------------------
  // @{

  reference 
  operator()(const index_type& mi) 
  { 
    return _root[base_type::root_offset(mi)]; 
  }


  reference 
  operator()(const int i0, const int i1) 
  { 
    return _root[base_type::root_offset(i0, i1)]; 
  }


  reference 
  operator()(const int i0, const int i1, const int i2) 
  { 
    return _root[base_type::root_offset(i0, i1, i2)];
  }

  // @}
  //--------------------------------------------------------------------------
  // @{

  void
  put(std::ostream& out) const
  {
    base_type::put(out);
  }

  void
  write(std::ostream& out) const
  {
    base_type::write(out);
  }


  void
  pretty_print(std::ostream& out) const;

  // @}
  //--------------------------------------------------------------------------
  // @{
  
  template<typename T2>
  bool
  operator==(const ArrayIndexing<N,T2>& x) const
  {
    return base_type::operator==(x);
  }

  // @}

private:

  //
  // Private member functions.
  //

  void
  compute_root(const const_pointer data);
};












// CONTINUE Move to a separate file.
//--------------------------------------------------------------------------
// 1-D specialization
//--------------------------------------------------------------------------


template<typename T>
class ArrayIndexing<1,T> :
  public ArrayIndexingBase<1>
{
  //
  // Private types.
  //

private:

  typedef ArrayTypes<T> types;
  typedef ArrayIndexingBase<1> base_type;

  //
  // Public types.
  //

public:

  typedef typename types::value_type value_type;

  typedef typename types::parameter_type parameter_type;

  typedef typename types::unqualified_value_type unqualified_value_type;

  typedef typename types::pointer pointer;
  typedef typename types::const_pointer const_pointer;

  typedef typename types::reference reference;
  typedef typename types::const_reference const_reference;


  typedef typename types::size_type size_type;
  typedef typename types::difference_type difference_type;

  typedef FixedArray<1,int> index_type;
  typedef IndexRange<1,int> range_type;

  typedef ArrayIndexIterator<1> index_iterator;

  //
  // Member data.
  //

private:

  // The root for indexing, i.e., the location of (*this)(_range.lbound()).
  // Note that if _range.lbound() != 0 then _root does not point to the 
  // beginning of the data.
  pointer _root;

  // CONTINUE
  // Not implemented.
  ArrayIndexing& operator=(const ArrayIndexing&);
  
protected:

  //--------------------------------------------------------------------------
  // @{

  ArrayIndexing() :
    base_type(),
    _root(0)
  {}

  ArrayIndexing(const ArrayIndexing& x) :
    base_type(x),
    _root(x._root)
  {}

  // CONTINUE: Maybe I should get rid of this.  
#if 0

  ArrayIndexing& 
  operator=(const ArrayIndexing& x) {
    if (&x != this) {
      base_type::operator=(x);
      _root = x._root;
    }
    return *this;
  }
#endif

  explicit
  ArrayIndexing(const index_type& extent, const pointer data) :
    base_type(extent),
    _root(data)
  {}

  void
  rebuild(const index_type& extent, const pointer data) {
    base_type::rebuild(extent);
    _root = data;
  }

  explicit
  ArrayIndexing(const size_type size, const pointer data) :
    base_type(size),
    _root(data)
  {}

  void
  rebuild(const size_type size, const pointer data) {
    base_type::rebuild(size);
    _root = data;
  }

  explicit
  ArrayIndexing(const range_type& range, const pointer data) :
    base_type(range),
    _root(data - range.lbound())
  {}

  void
  rebuild(const range_type& range, const pointer data) {
    base_type::rebuild(range);
    _root = data - range.lbound();
  }

  void
  swap(ArrayIndexing& x) {
    base_type::swap(x);
    std::swap(_root, x._root);
  }

  ~ArrayIndexing()
  {}

  // @}

public:

  //--------------------------------------------------------------------------
  // @{

  static
  int
  rank() {
    return base_type::rank();
  }

  // @}
  //--------------------------------------------------------------------------
  // @{

  index_type
  extents() const {
    return base_type::extents();
  }

  size_type 
  extent(const int i) const { 
    return base_type::extent(i);
  }

  const range_type&
  ranges() const { 
    return base_type::ranges();
  }

  const index_type&
  lbounds() const { 
    return base_type::lbounds();
  }

  const index_type&
  ubounds() const { 
    return base_type::ubounds();
  }

  int
  lbound(const int i) const { 
    return base_type::lbound(i);
  }

  int
  ubound(const int i) const { 
    return base_type::ubound(i);
  }

  index_type
  strides() const {
    return base_type::strides();
  }

  index_iterator
  indices_begin() const {
    return index_iterator(*this);
  }

  index_iterator
  indices_end() const {
    index_iterator x(*this);
    x += extents()[0];
    return x;
  }

  const_pointer 
  root() const {
    return _root;
  }

  // @}
  //-------------------------------------------------------------------------
  // @{

  // CONTINUE
  parameter_type
  operator()(const index_type& mi) const {
    return operator()(mi[0]);
  }


  parameter_type
  operator()(const int i) const { 
#ifdef DEBUG_ArrayIndexing
    assert(range().is_in(i));
#endif 
    return _root[i]; 
  }

  // @}
  //--------------------------------------------------------------------------
  // @{

  const range_type&
  range() const {
    return base_type::range();
  }

  int
  lbound() const {
    return base_type::lbound();
  }

  int
  ubound() const {
    return base_type::ubound();
  }

  // @}
  //--------------------------------------------------------------------------
  // @{

  int
  index(const index_type& mi) const {
    return base_type::index(mi);
  }

  int
  index(const int i0) const {
    return base_type::index(i0);
  }

  void 
  index_to_indices(int index, int& i) const {
    base_type::index_to_indices(index, i);
  }

  void
  index_to_indices(int index, ads::FixedArray<1,int>& multi_index) const {
    base_type::index_to_indices(index, multi_index);
  }

  // @}
  //--------------------------------------------------------------------------
  // @{

  pointer
  root() {
    return _root;
  }

  // @}
  //--------------------------------------------------------------------------
  // @{

  reference 
  operator()(const index_type& mi) { 
    return operator()(mi[0]);
  }


  reference 
  operator()(const int i) { 
#ifdef DEBUG_ArrayIndexing
    assert(range().is_in(i));
#endif 
    return _root[i]; 
  }

  // @}
  //--------------------------------------------------------------------------
  // @{

  void
  put(std::ostream& out) const {
    base_type::put(out);
  }

  void
  write(std::ostream& out) const {
    base_type::write(out);
  }


  void
  pretty_print(std::ostream& out) const;

  // @}
  //--------------------------------------------------------------------------
  // @{
  
  template<typename T2>
  bool
  operator==(const ArrayIndexing<1,T2>& x) const {
    return base_type::operator==(x);
  }

  // @}
};

END_NAMESPACE_ADS

#define __ArrayIndexing_ipp__
#include "ArrayIndexing.ipp"
#undef __ArrayIndexing_ipp__

#endif

---