Array1.h

Go to the documentation of this file.

// -*- C++ -*-

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

#include "../defs.h"

BEGIN_NAMESPACE_ADS


template<typename T, bool A>
class Array<1,T,A> :
  public ArrayContainer<T,A>, public ArrayIndexing<1,T> {
private:

  //
  // Private types.
  //

  typedef ArrayTypes<T> types;
  typedef ArrayContainer<T,A> container_base;
  typedef ArrayIndexing<1,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<1,T2,A2>& x) :
    container_base(x),
    indexing_base(x.range(), data())
  {}

  // Copy constructor for an array of different rank.
  template<int N2,typename T2, bool A2>
  Array(const Array<N2,T2,A2>& x) :
    container_base(x.data(), x.data() + x.size()),
    indexing_base(index_type(x.size()), container_base::data())
  {}


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


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


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

  // CONTINUE Is this dangerous?
  // Array<1,int> a(10);
  // a = 0;
  // Now a is an array of size 0.
  explicit
  Array(const size_type size) :
    container_base(size),
    indexing_base(index_type(size), container_base::data())
  {}

  explicit
  Array(const size_type size, parameter_type value) :
    container_base(size),
    indexing_base(index_type(size), container_base::data()) {
    fill(value);
  }


  template<typename ForwardIterator>
  Array(ForwardIterator first, ForwardIterator last) :
    container_base(first, last),
    indexing_base(index_type(container_base::size()), 
                   container_base::data()) 
  {}


  template<typename ForwardIterator>
  void
  rebuild(ForwardIterator first, ForwardIterator last) {
    container_base::rebuild(first, last);
    indexing_base::rebuild(index_type(size()), data());
  }


  template<typename InputIterator>
  explicit
  Array(const size_type size, InputIterator first, InputIterator last) :
    container_base(first, last),
    indexing_base(index_type(size), container_base::data()) 
  {}

  explicit
  Array(const index_type& extent) :
    container_base(extent[0]),
    indexing_base(extent, container_base::data())
  {}

  explicit
  Array(const index_type& extent, parameter_type value) :
    container_base(extent[0]),
    indexing_base(extent, container_base::data()) {
    fill(value);
  }


  template<typename InputIterator>
  explicit
  Array(const index_type& extent, InputIterator first, InputIterator last) :
    container_base(first, last),
    indexing_base(extent, container_base::data())
  {}

  explicit
  Array(const range_type& range) :
    container_base(range.extent()),
    indexing_base(range, container_base::data())
  {}

  explicit
  Array(const range_type& range, parameter_type value) :
    container_base(range.extent()),
    indexing_base(range, container_base::data()) {
    fill(value);
  }


  template<typename InputIterator>
  explicit
  Array(const range_type& range, InputIterator first, InputIterator last) :
    container_base(first, last),
    indexing_base(range, container_base::data())
  {}


  Array(const size_type size, const void_pointer data) :
    container_base(reinterpret_cast<pointer_parameter>(data),
                    reinterpret_cast<pointer_parameter>(data) + size),
    indexing_base(index_type(size), container_base::data())
  {}


  Array(const range_type& range, const void_pointer data) :
    container_base(reinterpret_cast<pointer_parameter>(data),
                    reinterpret_cast<pointer_parameter>(data) + 
                    range.extent()),
    indexing_base(range, container_base::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::range;

  //using indexing_base::lbound;

  //using indexing_base::ubound;

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

  using indexing_base::operator();
  /*
  parameter_type
  operator()(const index_type& mi) const 
  {
    return indexing_base::operator()(mi);
  }
  */


  /*
  parameter_type
  operator()(const int i) const 
  {
    return indexing_base::operator()(i);
  }
  */

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

  using indexing_base::index;
  /*
  int
  index(const index_type& mi) const 
  {
    return indexing_base::index(mi);
  }
  */

  /*
  int
  index(const int i0) const
  {
    return indexing_base::index(i0);
  }
  */

  using indexing_base::index_to_indices;
  /*
  void 
  index_to_indices(int index, int& i) const
  {
    indexing_base::index_to_indices(index, i);
  }
  */


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

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


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

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

  //using container_base::begin;

  //using container_base::end;

  //using container_base::data;


  //using container_base::operator[];

  using container_base::negate;

  using container_base::fill;

  //using container_base::copy;

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

  //using indexing_base::root;

  //using indexing_base::operator();


  //using indexing_base::operator();

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

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


  void
  resize(const size_type size);


  void
  resize(const index_type& extent) {
    resize(extent[0]);
  }


  void
  resize(const range_type& range);

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

  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<1,T2,A2>& x) const {
    return indexing_base::operator==(x) && container_base::operator==(x);
  }

  // @}

  //-------------------------------------------------------------------------
  // Private member functions.
  //


  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>);

};

END_NAMESPACE_ADS

#define __Array1_ipp__
#include "Array1.ipp"
#undef __Array1_ipp__

---