ArrayIndexingBase1.h

Go to the documentation of this file.

// -*- C++ -*-

#if !defined(__ArrayIndexingBase1_h__)
#error This file is an implementation detail of the class ArrayIndexingBase.
#endif

#include "../defs.h"

BEGIN_NAMESPACE_ADS

template <>
class ArrayIndexingBase<1> {
  //
  // Public types.
  //

public:


  typedef int size_type;

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

  //
  // Member data.
  //

private:

  // The index range.
  range_type _range;

protected:

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

  ArrayIndexingBase() :
    _range()
  {}

  ArrayIndexingBase(const ArrayIndexingBase& x) :
    _range(x._range)
  {}

  ArrayIndexingBase& 
  operator=(const ArrayIndexingBase& x) {
    if (&x != this) {
      _range = x._range;
    }
    return *this;
  }

  explicit
  ArrayIndexingBase(const index_type& extent) :
    _range(0, extent[0])
  {}

  void
  rebuild(const index_type& extent) {
    _range.set_lbound(0);
    _range.set_ubound(extent[0]);
  }

  explicit
  ArrayIndexingBase(const size_type size) :
    _range(0, size)
  {}

  void
  rebuild(const size_type size) {
    _range.set_lbound(0);
    _range.set_ubound(size);
  }

  explicit
  ArrayIndexingBase(const range_type& range) :
    _range(range)
  {}

  void
  rebuild(const range_type& range) {
    _range = range;
  }

  void
  swap(ArrayIndexingBase& x) {
    _range.swap(x._range);
  }

  ~ArrayIndexingBase()
  {}

  // @}

public:

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

  static
  int
  rank() {
    return 1;
  }

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

  index_type
  extents() const {
    return index_type(_range.ubound() - _range.lbound());
  }

#ifdef DEBUG_ArrayIndexingBase
  size_type 
  extent(const int i) const {
    assert(i == 0);
    return _range.ubound() - _range.lbound();
  }
#else
  size_type 
  extent(const int) const {
    return _range.ubound() - _range.lbound();
  }
#endif

  const range_type&
  ranges() const { 
    return _range; 
  }

  const index_type&
  lbounds() const { 
    return _range.lbounds();
  }

  const index_type&
  ubounds() const { 
    return _range.ubounds();
  }

  int
  lbound(const int i) const { 
    return _range.lbound(i);
  }

  int
  ubound(const int i) const { 
    return _range.ubound(i);
  }

  index_type
  strides() const {
    return index_type(1);
  }

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

  const range_type&
  range() const {
    return _range;
  }

  int
  lbound() const {
    return _range.lbound();
  }

  int
  ubound() const {
    return _range.ubound();
  }

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

  int
  index(const index_type& mi) const {
    return mi[0] - lbound();
  }

  int
  index(const int i0) const {
    return i0 - lbound();
  }

  void 
  index_to_indices(int index, int& i) const {
    i = index + lbound();
  }

  void
  index_to_indices(int index, ads::FixedArray<1,int>& multi_index) const {
    multi_index[0] = index + lbound();
  }

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

  void
  put(std::ostream& out) const {
    out << range() << '\n';
  }

  void
  write(std::ostream& out) const {
    out.write(reinterpret_cast<const char*>(&_range), 
               sizeof(range_type));
  }

  // @}
  //--------------------------------------------------------------------------
  // @{
  
  bool
  operator==(const ArrayIndexingBase& x) const {
    return ranges() == x.ranges();
  }

  // @}
};

END_NAMESPACE_ADS

---