FixedArray0.h

Go to the documentation of this file.

// -*- C++ -*-

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

#include "../defs.h"

BEGIN_NAMESPACE_ADS

template <typename T>
class FixedArray<0,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;


public:

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

  FixedArray()
  {}

  ~FixedArray() 
  {}

  FixedArray(const FixedArray& x)
  {}

  template <typename T2> 
  FixedArray(const FixedArray<0,T2>& x)
  {}

  explicit 
  FixedArray(parameter_type x)
  {}

  FixedArray(const void* vp)
  {}

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

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

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

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

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

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

  static
  size_type
  size() { 
    return 0;
  }

  static
  bool
  empty() { 
    return true;
  }

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

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

  const_iterator 
  begin() const { 
    return 0; 
  }

  const_iterator 
  end() const { 
    return 0;
  }

  const_pointer 
  data() const { 
    return 0;
  }

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

  bool
  is_sorted() const {
    return true;
  }

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

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

  iterator 
  begin() { 
    return 0; 
  }

  iterator 
  end() { 
    return 0;
  }

  pointer 
  data() { 
    return 0; 
  }

  void
  swap(FixedArray& x)
  {}

  void
  negate()
  {}

  void
  fill(parameter_type value)
  {}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  void
  abs()
  {}

  void
  acos()
  {}

  void
  asin()
  {}

  void
  atan()
  {}

  void
  ceil()
  {}

  void
  cos()
  {}

  void
  cosh()
  {}

  void
  exp()
  {}

  void
  floor()
  {}

  void
  log()
  {}

  void
  log10()
  {}

  void
  sin()
  {}

  void
  sinh()
  {}

  void
  sqrt()
  {}

  void
  tan()
  {}

  void
  tanh()
  {}

  // @}
};

END_NAMESPACE_ADS

#define __FixedArray0_ipp__
#include "FixedArray0.ipp"
#undef __FixedArray0_ipp__

---