Array.h

Go to the documentation of this file.

// -*- C++ -*-

#if !defined(__ads_Array_h__)
#define __ads_Array_h__

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

#ifdef DEBUG_Array
#ifndef DEBUG_ArrayContainer
#define DEBUG_ArrayContainer
#endif
#ifndef DEBUG_ArrayIndexing
#define DEBUG_ArrayIndexing
#endif
#endif

#include "ArrayContainer.h"
#include "ArrayIndexing.h"

BEGIN_NAMESPACE_ADS


//template<int N, typename T = double, bool A = true>
template<int N, typename T, bool A>
class Array :
  public ArrayContainer<T,A>, public ArrayIndexing<N,T> {
private:

  //
  // Private types.
  //

  typedef ArrayTypes<T> types;
  typedef ArrayContainer<T,A> container_base;
  typedef ArrayIndexing<N,T> indexing_base;

public:

  //
  // Public types.
  //

  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::iterator iterator;
  typedef typename types::const_iterator const_iterator;

  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 typename Loki::Select< A || Loki::TypeTraits<value_type>::isConst, 
                                 const void*, void* >::Result
  void_pointer;

  typedef typename indexing_base::index_type index_type;
  typedef typename indexing_base::range_type range_type;

private:


  typedef typename Loki::Select< A || Loki::TypeTraits<value_type>::isConst, 
                                 const_pointer, pointer >::Result
  pointer_parameter;

public:

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

  Array() :
    container_base(),
    indexing_base()
  {}


  Array(const Array& x) :
    container_base(x),
    indexing_base(x)
  {}

  // Copy constructor for an array of different type or allocation policy.
  template<typename T2, bool A2>
  Array(const Array<N,T2,A2>& x) :
    container_base(x),
    indexing_base(x.ranges(), data())
  {}


  Array& 
  operator=(const Array& other) {
    container_base::operator=(other);
    indexing_base::rebuild(other.ranges(), data());
    return *this;
  }


  template<typename T2, bool A2>
  Array& 
  operator=(const Array<N,T2,A2>& x) {
    container_base::operator=(x);
    indexing_base::rebuild(x.ranges(), data());
    return *this;
  }



  explicit
  Array(const size_type extent0, const size_type extent1) :
    container_base(extent0 * extent1),
    indexing_base(index_type(extent0, extent1), container_base::data()) {
    LOKI_STATIC_CHECK(N == 2, Dimension_must_be_2);
  }


  explicit
  Array(const size_type extent0, const size_type extent1, 
         const size_type extent2) :
    container_base(extent0 * extent1 * extent2),
    indexing_base(index_type(extent0, extent1, extent2), 
                   container_base::data()) {
    LOKI_STATIC_CHECK(N == 3, Dimension_must_be_3);
  }


  explicit
  Array(const index_type& extents) : 
    container_base(computeProduct(extents)),
    indexing_base(extents, container_base::data())
  {}

  explicit
  Array(const index_type& extents, parameter_type value) : 
    container_base(computeProduct(extents)),
    indexing_base(extents, container_base::data()) {
    fill(value);
  }


  template<typename InputIterator>
  explicit
  Array(const index_type& extents, InputIterator first, InputIterator last) :
    container_base(first, last),
    indexing_base(extents, container_base::data()) {
    assert(computeProduct(extents) == size());
  }


  explicit
  Array(const range_type& ranges) : 
    container_base(ranges.content()),
    indexing_base(ranges, container_base::data())
  {}

  explicit
  Array(const range_type& ranges, const value_type value) : 
    container_base(ranges.content()),
    indexing_base(ranges, container_base::data())
  {
    fill(value);
  }


  template<typename InputIterator>
  explicit
  Array(const range_type& ranges, InputIterator first, InputIterator last) :
    container_base(ranges.content()),
    indexing_base(ranges, container_base::data()) {
    copy(first, last);
  }

  Array(const index_type& extents, const void_pointer data) :
    container_base(reinterpret_cast<pointer_parameter>(data), 
                    reinterpret_cast<pointer_parameter>(data) + 
                    computeProduct(extents)),
    indexing_base(extents, reinterpret_cast<pointer_parameter>(data))
  {}

  void
  rebuild(const index_type& extents, const void_pointer data) {
    pointer d = reinterpret_cast<pointer_parameter>(data);
    container_base::rebuild(d, d + computeProduct(extents));
    indexing_base::rebuild(extents, d);
  }

  Array(const range_type& ranges, const void_pointer data) :
    container_base(reinterpret_cast<pointer_parameter>(data), 
                    reinterpret_cast<pointer_parameter>(data) + 
                    ranges.content()),
    indexing_base(ranges, reinterpret_cast<pointer_parameter>(data))
  {}

  void
  rebuild(const range_type& ranges, const void_pointer data) {
    container_base::rebuild(reinterpret_cast<pointer_parameter>(data), 
                            reinterpret_cast<pointer_parameter>(data) + 
                            ranges.content());
    indexing_base::rebuild(ranges, 
                           reinterpret_cast<pointer_parameter>(data));
  }

  ~Array()
  {}

  // @}

public:

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

  using container_base::size;

  using container_base::empty;

  using container_base::max_size;

  using container_base::begin;

  using container_base::end;


  using container_base::data;


  using container_base::operator[];

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

  using indexing_base::rank;

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

  using indexing_base::extents;

  using indexing_base::extent;

  using indexing_base::ranges;

  using indexing_base::lbounds;

  using indexing_base::ubounds;

  using indexing_base::lbound;

  using indexing_base::ubound;

  using indexing_base::strides;

  using indexing_base::root;

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

  using indexing_base::operator();


  /*
  parameter_type
  operator()(const int i0, const int i1) const 
  {
    return indexing_base::operator()(i0, i1);
  }
  */


  /*
  parameter_type
  operator()(const int i0, const int i1, const int i2) 
    const 
  {
    return indexing_base::operator()(i0, i1, i2);
  }
  */


  /*
  parameter_type
  operator()(const ads::FixedArray<1,int>& index,
              const ads::FixedArray<1,int>& offset) const 
  {
    return indexing_base::operator()(index, offset);
  }
  */


  /*
  parameter_type
  operator()(const ads::FixedArray<2,int>& index,
              const ads::FixedArray<2,int>& offset) const 
  {
    return indexing_base::operator()(index, offset);
  }
  */


  /*
  parameter_type
  operator()(const ads::FixedArray<3,int>& index,
              const ads::FixedArray<3,int>& offset) const 
  {
    return indexing_base::operator()(index, offset);
  }
  */

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

  using indexing_base::index;

  using indexing_base::index_to_indices;

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


  void 
  iterator_to_indices(const const_iterator iter, int& i, int& j) const {
    index_to_indices(iter - begin(), i, j);
  }


  void 
  iterator_to_indices(const const_iterator iter, 
                      int& i, int& j, int& k) const {
    index_to_indices(iter - begin(), i, j, k);
  }


  void 
  iterator_to_indices(const const_iterator iter, 
                      ads::FixedArray<2,int>& multi_index) const {
    index_to_indices(iter - begin(), multi_index);
  }


  void 
  iterator_to_indices(const const_iterator iter, 
                      ads::FixedArray<3,int>& multi_index) const {
    index_to_indices(iter - begin(), multi_index);
  }

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

  size_type 
  getMemoryUsage() const {
    return sizeof(Array) + sizeof(value_type) * size();
  }

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

  using container_base::negate;

  using container_base::fill;

  /*
  template<typename InputIterator>
  void
  copy(InputIterator start, InputIterator finish)
  {
    container_base::copy(start, finish);
  }
  */

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

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

  void
  swap(Array& x) {
    container_base::swap(x);
    indexing_base::swap(x);
  }

  void
  resize(const index_type& ext);

  void
  resize(const range_type& rng);

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

  Array& 
  operator=(parameter_type x) {
    container_base::operator=(x);
    return *this;
  }

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

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

  void
  get(std::istream& in) {
    get(in, Loki::Int2Type<A>());
  }


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


  void
  read(std::istream& in) {
    read(in, Loki::Int2Type<A>());
  }

  void
  write_elements_ascii(std::ostream& out) const {
    container_base::write_elements_ascii(out);
  }

  void
  write_elements_binary(std::ostream& out) const {
    container_base::write_elements_binary(out);
  }

  void
  read_elements_ascii(std::istream& in) {
    container_base::read_elements_ascii(in);
  }

  void
  read_elements_binary(std::istream& in) {
    container_base::read_elements_binary(in);
  }
  
  // @}
  //--------------------------------------------------------------------------
  // @{
  
  // Return true if this is equal to \c x.
  template<typename T2, bool A2>
  bool
  operator==(const Array<N,T2,A2>& x) const {
    return indexing_base::operator==(x) && container_base::operator==(x);
  }

  // @}

  //
  // Private member functions.
  //

private:


  void
  get(std::istream& in, Loki::Int2Type<true>);


  void
  get(std::istream& in, Loki::Int2Type<false>);


  void
  read(std::istream& in, Loki::Int2Type<true>);


  void
  read(std::istream& in, Loki::Int2Type<false>);

};


//
// Equality Operators
//

// CONTINUE: I don't think that I need this.  I have the member function.
#if 0

template<int N, typename T1, typename T2, bool A1, bool A2>
bool
operator==(const Array<N,T1,A1>& x, const Array<N,T2,A2>& y) {
  return x.operator==(y);
}
#endif


template<int N, typename T1, typename T2, bool A1, bool A2>
inline
bool
operator!=(const Array<N,T1,A1>& x, const Array<N,T2,A2>& y) { 
  return !(x == y); 
}


//
// File I/O
//


template<int N, typename T, bool A>
inline
std::istream&
operator>>(std::istream& in, Array<N,T,A>& x) {
  x.get(in);
  return in;
}



template<int N, typename T, bool A>
inline
std::ostream& 
operator<<(std::ostream& out, const Array<N,T,A>& x) {
  x.put(out);
  return out;
}

END_NAMESPACE_ADS

#define __Array_ipp__
#include "Array.ipp"
#undef __Array_ipp__

#define __Array1_h__
#include "Array1.h"
#undef __Array1_h__

#endif

---