FixedArray1.h

Go to the documentation of this file.

// -*- C++ -*-

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

#include "../defs.h"

BEGIN_NAMESPACE_ADS

template<typename T>
class FixedArray<1,T> {
  //
  // Private types.
  //

private:

  typedef ArrayTypes<T> Types;

  //
  // Public types.
  //

public:

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

  typedef typename Types::value_type value_type;
  typedef typename Types::parameter_type parameter_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:

  value_type _data;

public:

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

  FixedArray() :
    _data()
  {}

  ~FixedArray() 
  {}

  FixedArray(const FixedArray& other) :
    _data(other._data)
  {}

  template<typename T2> 
  FixedArray(const FixedArray<1,T2>& x) :
    _data(static_cast<value_type>(x[0]))
  {}

  explicit 
  FixedArray(parameter_type x) :
    _data(x)
  {}

  FixedArray(const void* vp) :
    _data(*static_cast<const_pointer>(vp))
  {}

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

  FixedArray& 
  operator=(const FixedArray& x) {
    if (&x != this) {
      _data = x._data;
    }
    return *this;
  }

  FixedArray& 
  operator=(parameter_type x) {
    _data = x;
    return *this;
  }

  template<typename T2> 
  FixedArray& 
  operator=(const FixedArray<1,T2>& x) {
    _data = x[0];
    return *this;
  }

  template<typename T2, bool A>
  FixedArray& 
  operator=(const Array<1, T2, A>& x) {
#ifdef DEBUG_FixedArray
    assert(size() == x.size());
#endif
    _data[0] = x[0];
    return *this;
  }

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

  static
  size_type
  size() { 
    return 1;
  }

  static
  bool
  empty() { 
    return false;
  }

  static
  size_type
  max_size() { 
    return std::numeric_limits<int>::max() / sizeof(value_type); 
  }

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

  const_iterator 
  begin() const { 
    return &_data; 
  }

  const_iterator 
  end() const { 
    return &_data + 1; 
  }

  const_pointer 
  data() const { 
    return &_data; 
  }

#ifdef DEBUG_FixedArray
  parameter_type
  operator()(const int i) const {
    assert(i == 0);
    return _data;
  }
#else
  parameter_type
  operator()(const int) const {
    return _data;
  }
#endif

#ifdef DEBUG_FixedArray
  parameter_type
  operator[](const int i) const {
    assert(i == 0);
    return _data;
  }
#else
  parameter_type
  operator[](const int) const {
    return _data;
  }
#endif

  template<typename EqualityComparable>
  const_iterator
  find(const EqualityComparable& x) const {
    if (_data == x) {
      return begin();
    }
    return end();
  }

  template<typename EqualityComparable>
  int
  find_index(const EqualityComparable& x) const {
    if (_data == x) {
      return 0;
    }
    return 1;
  }

  template<typename EqualityComparable>
  bool
  has(const EqualityComparable& x) const {
    return _data == x;
  }

  bool
  is_sorted() const {
    return true;
  }

  template<class StrictWeakOrdering>
  bool
  is_sorted(StrictWeakOrdering comp) const {
    return true;
  }

  int
  min_index() const {
    return 0;
  }

  template<class StrictWeakOrdering>
  int
  min_index(StrictWeakOrdering comp) const {
    return 0;
  }

  int
  max_index() const {
    return 0;
  }

  template<class StrictWeakOrdering>
  int
  max_index(StrictWeakOrdering comp) const {
    return 0;
  }

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

  iterator 
  begin() { 
    return &_data; 
  }

  iterator 
  end() { 
    return &_data + 1;
  }

  pointer 
  data() { 
    return &_data; 
  }

  reference
  operator()(const int i) { 
#ifdef DEBUG_FixedArray
    assert(i == 0);
#endif
    return _data;
  }

#ifdef DEBUG_FixedArray
  reference
  operator[](const int i) {
    assert(i == 0);
    return _data;
  }
#else
  reference
  operator[](const int) {
    return _data;
  }
#endif

  void
  swap(FixedArray& x) {
    std::swap(_data, x._data);
  }

  template<typename EqualityComparable>
  iterator
  find(const EqualityComparable& x) {
    if (_data == x) {
      return begin();
    }
    return end();
  }

  void
  negate() {
    _data = - _data;
  }

  void
  fill(parameter_type value) {
    _data = value;
  }

  template<typename InputIterator>
  void
  copy(InputIterator start, InputIterator finish) {
    _data = *start;
#ifdef DEBUG_FixedArray
    assert(++start == finish);
#endif
  }
    
  void
  sort()
  {}

  template<class StrictWeakOrdering>
  void
  sort(StrictWeakOrdering comp)
  {}

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

  FixedArray& 
  operator+=(parameter_type x) {
    _data += x;
    return *this;
  }

  FixedArray& 
  operator-=(parameter_type x) {
    _data -= x;
    return *this;
  }

  FixedArray& 
  operator*=(parameter_type x) {
    _data *= x;
    return *this;
  }

  FixedArray& 
  operator/=(parameter_type x) {
#ifdef DEBUG_FixedArray
    assert(x != 0);
#endif
    _data /= x;
    return *this;
  }

  FixedArray& 
  operator%=(parameter_type x) {
#ifdef DEBUG_FixedArray
    assert(x != 0);
#endif
    _data %= x;
    return *this;
  }

  FixedArray& 
  operator<<=(const int offset) {
    _data <<= offset;
    return *this;
  }

  FixedArray& 
  operator>>=(const int offset) {
    _data >>= offset;
    return *this;
  }

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

  template<typename T2>
  FixedArray& 
  operator+=(const FixedArray<1,T2>& x) {
    _data += x[0];
    return *this;
  }

  template<typename T2>
  FixedArray& 
  operator-=(const FixedArray<1,T2>& x) {
    _data -= x[0];
    return *this;
  }

  template<typename T2>
  FixedArray& 
  operator*=(const FixedArray<1,T2>& x) {
    _data *= x[0];
    return *this;
  }

  template<typename T2>
  FixedArray& 
  operator/=(const FixedArray<1,T2>& x) {
#ifdef DEBUG_FixedArray
    assert(x[0] != 0);
#endif
    _data /= x[0];
    return *this;
  }

  template<typename T2>
  FixedArray& 
  operator%=(const FixedArray<1,T2>& x) {
#ifdef DEBUG_FixedArray
    assert(x[0] != 0);
#endif
    _data %= x[0];
    return *this;
  }

  // @}
};


END_NAMESPACE_ADS


#define __FixedArray1_ipp__
#include "FixedArray1.ipp"
#undef __FixedArray1_ipp__

---