c++_api/inc/opals/Array.hpp

#pragma once
 
#include <opals/fwd.hpp>
#include <algorithm>
#include <array>
#include <initializer_list>
 
namespace opals
{
  /// A template class holding a C - array of constant size.
  /**
  \tparam T the element type
  \tparam N the constant size, must be >= 1
 
  \author wk
  \date   03.02.2011
 
  Array may be initialized with a static initializer list:
    opals::Array<double,3> arr = { 1., 2., 3. };
    Array fulfills almost all the requirements of an STL reversible container.
    The complete implementation is exposed and hence, opals users may instantiate Array<T,N> with arbitrary template arguments.
    The class inherits most of its functionality from std::array.
  \internal
  opals::Array extends std::array.
  As extensions to std::array, assignment of a C-array is supported:
    double da[] = { 1., 2. };
    arr = da;
  In contrast to opals::Vector and opals::List,
   its data member is a plain-old-C-array
   and hence, the whole implementation can be exposed to DLL users, together with
   global template comparison operators.
  As further extensions to the interface of std::array,
  opals::Array provides operator<<, operator>>,
  and function toInternal(),
  which returns a std::array<U>, where U is the internal type
  corresponding to T (see InternalType).
  In contrast to std::array, Array may not be instantiated for N==0.
 
  Unfortunately, we cannot simply use the following template alias instead of a type on its own:
  template<class T, std::size_t N>
  using Array = std::array<T, N>;
  The reason is that boost::lexical_cast would not work any longer.
  */
  template<class T, std::size_t N>
  class Array : public std::array<T, N>
  {
  public:
    Array() = default;
    Array(std::initializer_list<T> init)
    {
      *this = init;
    }
 
    /// \name assignment with type conversion
    ///@{
    Array& operator=(const Array&) = default;
 
    template <typename T2>
    Array& operator=(const Array<T2, N>& that)
    {
      std::copy(that.begin(), that.end(), this->begin());
      return *this;
    }
 
    template <typename T2>
    Array& operator=(const T2(&that)[N])
    {
      std::copy(that, &that[N], this->begin());
      return *this;
    }
 
    template <typename T2>
    Array& operator=(const std::array<T2, N>& that)
    {
      std::copy(that.begin(), that.end(), this->begin());
      return *this;
    }
 
    template <typename T2>
    Array& operator=(std::initializer_list<T2> that)
    {
      std::copy(that.begin(), that.begin() + std::min(this->size(), that.size()), this->begin());
      return *this;
    }
  };
 
  /// \relatesalso Array
  template<class T, std::size_t N>
  bool operator== (const Array<T, N>& l, const Array<T, N>& r) {
    return static_cast<const std::array<T, N>&>(l) == static_cast<const std::array<T, N>&>(r);
  }
 
  /// \relatesalso Array
  template<class T, std::size_t N>
  bool operator< (const Array<T, N>& l, const Array<T, N>& r) {
    return static_cast<const std::array<T, N>&>(l) < static_cast<const std::array<T, N>&>(r);
  }
 
  /// \relatesalso Array
  template<class T, std::size_t N>
  bool operator!= (const Array<T, N>& l, const Array<T, N>& r) {
    return static_cast<const std::array<T, N>&>(l) != static_cast<const std::array<T, N>&>(r);
  }
 
  /// \relatesalso Array
  template<class T, std::size_t N>
  bool operator> (const Array<T, N>& l, const Array<T, N>& r) {
    return static_cast<const std::array<T, N>&>(l) > static_cast<const std::array<T, N>&>(r);
  }
 
  /// \relatesalso Array
  template<class T, std::size_t N>
  bool operator<= (const Array<T, N>& l, const Array<T, N>& r) {
    return static_cast<const std::array<T, N>&>(l) <= static_cast<const std::array<T, N>&>(r);
  }
 
  /// \relatesalso Array
  template<class T, std::size_t N>
  bool operator>= (const Array<T, N>& l, const Array<T, N>& r) {
    return static_cast<const std::array<T, N>&>(l) >= static_cast<const std::array<T, N>&>(r);
  }
 
  /// \relatesalso Array
  template<class T, std::size_t N>
  void swap(Array<T, N>& l, Array<T, N>& r) {
    swap( static_cast<std::array<T, N>&>(l), static_cast<std::array<T, N>&>(r) );
  }
}