SparseArray2.h

Go to the documentation of this file.

// -*- C++ -*-

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

#include "../defs.h"

#include "../functor/select.h"

BEGIN_NAMESPACE_ADS



template<typename T>
class SparseArray<2,T> : public SparseArray<1,T> {
  //
  // Private types.
  //

private:

  typedef ArrayTypes<T> Types;
  typedef SparseArray<1,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;

  typedef FixedArray<2,int> index_type;

  //
  // Data.
  //

private:

  Array<1,int> _offsets;

  //
  // Using
  //

public:

  // Accessors.
  using Base::size;
  using Base::empty;
  using Base::max_size;
  using Base::begin;
  using Base::end;
  using Base::data;
  using Base::operator[];
  using Base::getNull;

  // Manipulators.
  //using Base::begin;
  //using Base::end;
  //using Base::data;
  using Base::negate;

  // File I/O.
  using Base::write_elements_ascii;
  using Base::write_elements_binary;
  using Base::read_elements_ascii;
  using Base::read_elements_binary;

private:

  // Using base data.
  using Base::_indices;
  using Base::_null;

public:

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

  SparseArray() :
    Base(),
    _offsets()
  {}


  template<typename IndexBiDirIter, typename ValueForwardIter>
  SparseArray(IndexBiDirIter indicesBeginning, IndexBiDirIter indicesEnd,
              ValueForwardIter valuesBeginning, ValueForwardIter valuesEnd,
              parameter_type nullValue = value_type());

  template<typename T2, bool A>
  SparseArray(const Array<2,T2,A>& array, parameter_type nullValue);

  SparseArray(const SparseArray& x) :
    Base(x),
    _offsets(x._offsets)
  {}

  ~SparseArray()
  {}

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

  SparseArray& 
  operator=(const SparseArray& other) {
    if (&other != this) {
      Base::operator=(other);
      _offsets = other._offsets;
    }
    return *this;
  }

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

  static
  int
  getRank() {
    return 2;
  }

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

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

  bool
  isNull(const index_type& index) const;

  bool
  isNonNull(const index_type& index) const {
    return ! isNull(index);
  }

  parameter_type
  operator()(const index_type& index) const;

  bool
  operator==(const SparseArray& x) const {
    return Base::operator==(x) && _offsets == x._offsets;
  }

  bool
  operator!=(const SparseArray& x) const {
    return ! operator==(x);
  }

  template<typename T2, bool A>
  void
  fill(ads::Array<2,T2,A>* array) const;

  template<typename T2, bool A>
  void
  fillNonNull(ads::Array<2,T2,A>* array) const;

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

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

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

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

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

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

  void
  get(std::istream& in);

  // @}
};

END_NAMESPACE_ADS

#define __ads_SparseArray2_ipp__
#include "SparseArray2.ipp"
#undef __ads_SparseArray2_ipp__

---