FixedArray3.h

Go to the documentation of this file.

// -*- C++ -*-

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

#include "../defs.h"

BEGIN_NAMESPACE_ADS

template<typename T>
class FixedArray<3,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[3];

public:

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

  // Default constructor.  Leave the data uninitialized.
  FixedArray()
  {}

  ~FixedArray() 
  {}

  FixedArray(const FixedArray& x) {
    _data[0] = x._data[0];
    _data[1] = x._data[1];
    _data[2] = x._data[2];
  }

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

  explicit 
  FixedArray(parameter_type x) {
    _data[0] = x;
    _data[1] = x;
    _data[2] = x;
  }

  FixedArray(const void* vp) {
    const_pointer p = static_cast<const_pointer>(vp);
    _data[0] = *p++;
    _data[1] = *p++;
    _data[2] = *p;
  }

  explicit 
  FixedArray(parameter_type x0, parameter_type x1, parameter_type x2) {
    _data[0] = x0;
    _data[1] = x1;
    _data[2] = x2;
  }

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

  FixedArray& 
  operator=(const FixedArray& other) {
    if (&other != this) {
      _data[0] = other._data[0];
      _data[1] = other._data[1];
      _data[2] = other._data[2];
    }
    return *this;
  }

  FixedArray& 
  operator=(parameter_type x) {
    _data[0] = x;
    _data[1] = x;
    _data[2] = x;
    return *this;
  }

  template<typename T2> 
  FixedArray& 
  operator=(const FixedArray<3,T2>& x) {
    _data[0] = x[0];
    _data[1] = x[1];
    _data[2] = x[2];
    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];
    _data[1] = x[1];
    _data[2] = x[2];
    return *this;
  }

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

  static
  size_type
  size() { 
    return 3;
  }

  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 + 3;
  }

  const_pointer 
  data() const { 
    return _data;
  }

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

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

  template<typename EqualityComparable>
  const_iterator
  find(const EqualityComparable& x) const {
    if (_data[0] == x) {
      return begin();
    }
    if (_data[1] == x) {
      return begin() + 1;
    }
    if (_data[2] == x) {
      return begin() + 2;
    }
    return end();
  }

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

  template<typename EqualityComparable>
  bool
  has(const EqualityComparable& x) const {
    return (_data[0] == x || _data[1] == x || _data[2] == x);
  }

  bool
  is_sorted() const {
    if (_data[1] < _data[0] || _data[2] < _data[1]) {
      return false;
    }
    return true;
  }

  template<class StrictWeakOrdering>
  bool
  is_sorted(StrictWeakOrdering comp) const {
    if (comp(_data[1], _data[0]) || comp(_data[2], _data[1])) {
      return false;
    }
    return true;
  }

  int
  min_index() const {
    if (_data[0] < _data[1]) {
      if (_data[0] < _data[2]) {
        return 0;
      }
      return 2;
    }
    if (_data[1] < _data[2]) {
      return 1;
    }
    return 2;
  }

  template<class StrictWeakOrdering>
  int
  min_index(StrictWeakOrdering comp) const {
    if (comp(_data[0], _data[1])) {
      if (comp(_data[0], _data[2])) {
        return 0;
      }
      return 2;
    }
    if (comp(_data[1], _data[2])) {
      return 1;
    }
    return 2;
  }

  int
  max_index() const {
    if (_data[0] > _data[1]) {
      if (_data[0] > _data[2]) {
        return 0;
      }
      return 2;
    }
    if (_data[1] > _data[2]) {
      return 1;
    }
    return 2;
  }

  template<class StrictWeakOrdering>
  int
  max_index(StrictWeakOrdering comp) const {
    if (comp(_data[0], _data[1])) {
      if (comp(_data[0], _data[2])) {
        return 0;
      }
      return 2;
    }
    if (comp(_data[1], _data[2])) {
      return 1;
    }
    return 2;
  }

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

  iterator 
  begin() { 
    return _data;
  }

  iterator 
  end() { 
    return _data + 3;
  }

  pointer 
  data() { 
    return _data;
  }

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

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

  void
  swap(FixedArray& x) {
    std::swap(_data[0], x._data[0]);
    std::swap(_data[1], x._data[1]);
    std::swap(_data[2], x._data[2]);
  }

  template<typename EqualityComparable>
  iterator
  find(const EqualityComparable& x) {
    if (_data[0] == x) {
      return begin();
    }
    if (_data[1] == x) {
      return begin() + 1;
    }
    if (_data[2] == x) {
      return begin() + 2;
    }
    return end();
  }

  void
  negate() {
    _data[0] = - _data[0];
    _data[1] = - _data[1];
    _data[2] = - _data[2];
  }

  void
  fill(parameter_type value) {
    _data[0] = value;
    _data[1] = value;
    _data[2] = value;
  }

  template<typename InputIterator>
  void
  copy(InputIterator start, InputIterator finish) {
    _data[0] = *start;
    ++start;
    _data[1] = *start;
    ++start;
    _data[2] = *start;
#ifdef DEBUG_FixedArray
    assert(++start == finish);
#endif
  }
    
  void
  sort() {
    if (_data[1] < _data[0]) {
      std::swap(_data[0], _data[1]);
    }
    if (_data[2] < _data[1]) {
      std::swap(_data[1], _data[2]);
    }
    if (_data[1] < _data[0]) {
      std::swap(_data[0], _data[1]);
    }
  }

  template<class StrictWeakOrdering>
  void
  sort(StrictWeakOrdering comp) {
    if (comp(_data[1], _data[0])) {
      std::swap(_data[0], _data[1]);
    }
    if (comp(_data[2], _data[1])) {
      std::swap(_data[1], _data[2]);
    }
    if (comp(_data[1], _data[0])) {
      std::swap(_data[0], _data[1]);
    }
  }

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

  FixedArray& 
  operator+=(parameter_type x) {
    _data[0] += x;
    _data[1] += x;
    _data[2] += x;
    return *this;
  }

  FixedArray& 
  operator-=(parameter_type x) {
    _data[0] -= x;
    _data[1] -= x;
    _data[2] -= x;
    return *this;
  }

  FixedArray& 
  operator*=(parameter_type x) {
    _data[0] *= x;
    _data[1] *= x;
    _data[2] *= x;
    return *this;
  }

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

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

  FixedArray& 
  operator<<=(const int offset) {
    _data[0] <<= offset;
    _data[1] <<= offset;
    _data[2] <<= offset;
    return *this;
  }

  FixedArray& 
  operator>>=(const int offset) {
    _data[0] >>= offset;
    _data[1] >>= offset;
    _data[2] >>= offset;
    return *this;
  }

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

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

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

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

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

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

  // @}
};


END_NAMESPACE_ADS

#define __FixedArray3_ipp__
#include "FixedArray3.ipp"
#undef __FixedArray3_ipp__

---