SparseArraySigned1.h

Go to the documentation of this file.

// -*- C++ -*-

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

#include "../defs.h"

BEGIN_NAMESPACE_ADS



template<typename T>
class SparseArraySigned<1,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 int index_type;

  //
  // Data.
  //

protected:

  int _sign;

  //
  // Using
  //

public:

  // Static members.
  using Base::getRank;

  // 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;
  using Base::isNull;
  using Base::isNonNull;
  using Base::fillNonNull;
  using Base::getIndices;

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

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

protected:

  // Data.
  using Base::_indices;
  using Base::_null;

  //
  // Friends.
  //

  friend void merge<>(const SparseArraySigned<1,T>& a, 
                      const SparseArraySigned<1,T>& b, 
                      SparseArraySigned<1,T>* c);

  friend void removeUnecessaryElements<>(SparseArraySigned<1,T>* a);

  friend void computeUnion<>(const SparseArraySigned<1,T>& a, 
                             const SparseArraySigned<1,T>& b, 
                             SparseArraySigned<1,T>* c);

  friend void computeIntersection<>(const SparseArraySigned<1,T>& a, 
                                    const SparseArraySigned<1,T>& b, 
                                    SparseArraySigned<1,T>* c);

public:

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

  SparseArraySigned(parameter_type nullValue 
                    = std::numeric_limits<value_type>::max()) :
    Base(nullValue),
    _sign(1)
  {}

  template<typename IndexForwardIter, typename ValueForwardIter>
  SparseArraySigned(IndexForwardIter indicesBeginning, 
                    IndexForwardIter indicesEnd,
                    ValueForwardIter valuesBeginning, 
                    ValueForwardIter valuesEnd,
                    parameter_type nullValue
                    = std::numeric_limits<value_type>::max());

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

  SparseArraySigned(const SparseArraySigned& other) :
    Base(other),
    _sign(other._sign)
  {}

  ~SparseArraySigned()
  {}

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

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

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

  int
  getSign() const {
    return _sign;
  }

  size_type 
  getMemoryUsage() const {
    return Base::getMemoryUsage() + sizeof(int);
  }

  value_type
  operator()(const int i) const;

  bool
  operator==(const SparseArraySigned& x) const {
    return (Base::operator==(x) && _sign == x._sign);
  }

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

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

  void
  swap(SparseArraySigned& x) {
    Base::swap(x);
    std::swap(_sign, x._sign);
  }

  void
  negate() {
    if (empty()) {
      _sign = - _sign;
    }
    Base::negate();
  }

  void
  setSign(const int sign) {
    _sign = sign;
  }

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

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

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

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

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

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

  SparseArraySigned& 
  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_SparseArraySigned1_ipp__
#include "SparseArraySigned1.ipp"
#undef __ads_SparseArraySigned1_ipp__

---