StaticArrayOfArrays.h

Go to the documentation of this file.

// -*- C++ -*-

#if !defined(__ads_StaticArrayOfArrays_h__)
#define __ads_StaticArrayOfArrays_h__

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

#include "Array.h"

BEGIN_NAMESPACE_ADS


template<typename T = double>
class StaticArrayOfArrays :
  public ArrayContainer<T> {

  //
  // Private types.
  //

private:

  typedef ArrayTypes<T> Types;
  typedef ArrayContainer<T> Base;

  //
  // 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::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;

  //
  // Data.
  //

private:

  Array<1,iterator> _pointers;

public:

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

  StaticArrayOfArrays() :
    Base(),
    _pointers(1) {
    // begin is qualified for the benefit of the icc compiler.
    _pointers[0] = Base::begin();
  }

  template<typename IntForwardIter, typename ValueForwardIter>
  StaticArrayOfArrays(IntForwardIter sizesBeginning, IntForwardIter sizesEnd,
                      ValueForwardIter valuesBeginning, 
                      ValueForwardIter valuesEnd);

  template<typename IntForwardIter>
  void
  rebuild(const size_type numberOfElements, 
          IntForwardIter sizesBeginning, IntForwardIter sizesEnd);

  template<typename IntForwardIter, typename ValueForwardIter>
  void
  rebuild(IntForwardIter sizesBeginning, IntForwardIter sizesEnd,
          ValueForwardIter valuesBeginning, ValueForwardIter valuesEnd) {
    rebuild(std::distance(valuesBeginning, valuesEnd), sizesBeginning, 
            sizesEnd);
    std::copy(valuesBeginning, valuesEnd, begin());
  }

  StaticArrayOfArrays(const StaticArrayOfArrays& other) :
    Base(other),
    _pointers(other._pointers) {
    _pointers += begin() - other.begin();
  }

  ~StaticArrayOfArrays()
  {}

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

  StaticArrayOfArrays& 
  operator=(const StaticArrayOfArrays& other) {
    if (&other != this) {
      Base::operator=(other);
      _pointers = other._pointers;
      _pointers += begin() - other.begin();
    }
    return *this;
  }

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

  size_type
  getNumberOfArrays() const {
    return _pointers.size() - 1;
  }

  // CONTINUE: I do this to placate the icc compiler.
  //using Base::size;
  size_type 
  size() const {
    return Base::size();
  }

  using Base::empty;

  using Base::max_size;

  size_type 
  getMemoryUsage() const {
    return Base::getMemoryUsage() + _pointers.getMemoryUsage();
  }

  // CONTINUE: I do this to placate the icc compiler.
  //using Base::begin;
  const_iterator 
  begin() const { 
    return Base::begin();
  }

  // CONTINUE: I do this to placate the icc compiler.
  //using Base::end;
  const_iterator 
  end() const { 
    return Base::end();
  }

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

  size_type
  size(const int n) const {
    return size_type(_pointers[n + 1] - _pointers[n]);
  }

  bool 
  empty(const int n) const { 
    return size(n) == 0;
  }

  const_iterator 
  begin(const int n) const { 
    return _pointers[n];
  }

  const_iterator 
  end(const int n) const { 
    return _pointers[n + 1];
  }

  // CONTINUE: Inherit different functionality from Base.
  const_iterator
  operator[](const int n) const {
    return begin(n);
  }

  const_iterator
  operator()(const int n) const {
    return operator[](n);
  }

  parameter_type
  operator()(const int n, const int m) const {
#ifdef DEBUG_StaticArrayOfArrays
    assert(0 <= m && m < size(n));
#endif
    return *(begin(n) + m);
  }

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

  // CONTINUE: I do this to placate the icc compiler.
  //using Base::begin;
  iterator 
  begin() { 
    return Base::begin();
  }

  // CONTINUE: I do this to placate the icc compiler.
  //using Base::end;
  iterator 
  end() { 
    return Base::end();
  }

  using Base::negate;

  void
  swap(StaticArrayOfArrays& other) {
    if (&other != this) {
      Base::swap(other);
      _pointers.swap(other._pointers);
    }
  }

  void
  clear() {
    Base::resize(0);
    _pointers.resize(1);
    _pointers[0] = begin();
  }

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

  iterator 
  begin(const int n) { 
    return _pointers[n];
  }

  iterator 
  end(const int n) { 
    return _pointers[n + 1];
  }

  iterator
  operator[](const int n) {
    return begin(n);
  }

  iterator
  operator()(const int n) {
    return operator[](n);
  }

  reference
  operator()(const int n, const int m) {
#ifdef DEBUG_StaticArrayOfArrays
    assert(0 <= m && m < size(n));
#endif
    return *(begin(n) + m);
  }

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

  StaticArrayOfArrays& 
  operator=(parameter_type x) {
    Base::operator=(x);
    return *this;
  }

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

  bool
  operator==(const StaticArrayOfArrays<T>& x) const {
    if (Base::operator!=(x)) {
      return false;
    }
    for (int n = 0; n != getNumberOfArrays(); ++n) {
      if (size(n) != x.size(n)) {
        return false;
      }
    }
    return true;
  }

  bool
  operator!=(const StaticArrayOfArrays<T>& x) const {
    return ! operator==(x);
  }

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

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

  void
  get(std::istream& in);

  // @}
};

//
// File I/O.
//


template<typename T>
inline
std::ostream&
operator<<(std::ostream& out, const StaticArrayOfArrays<T>& x) {
  x.put(out);
  return out;
}


template<typename T>
inline
std::istream&
operator>>(std::istream& in, StaticArrayOfArrays<T>& x) {
  x.get(in);
  return in;
}

END_NAMESPACE_ADS

#define __StaticArrayOfArrays_ipp__
#include "StaticArrayOfArrays.ipp"
#undef __StaticArrayOfArrays_ipp__

#endif

---