CooArray.h

Go to the documentation of this file.

/*
 * CooArray.h
 *
 *  Created on: 9 Jan 2019
 *      Author: Nicola Mori
 */
 
#ifndef HERD_COOARRAY_H_
#define HERD_COOARRAY_H_
 
// HerdSoftware headers
#include "herd/analysis/common/ArrayForwarder.h"
#include "herd/analysis/common/RefFrame.h"
 
namespace Herd {
template <typename ContainedClass> class CooArray : public ArrayForwarder<ContainedClass, 3> {
public:
  using BaseType = ArrayForwarder<ContainedClass, 3>;
 
  constexpr CooArray() = default;
 
  constexpr CooArray(const CooArray<ContainedClass> &c) : BaseType(c) {}
 
  // Note by VF: This one used to have a variadic template and was tricky to write. See
  // https://stackoverflow.com/questions/6893700/how-to-construct-stdarray-object-with-initializer-list
  // Note by NM: the implementation making use of variadic templates blocked the possibility to implement a copy
  // constructor
  template <typename U, typename V, typename Z>
  constexpr CooArray(U &&v1, V &&v2, Z &&v3)
      : BaseType({static_cast<ContainedClass>(v1), static_cast<ContainedClass>(v2), static_cast<ContainedClass>(v3)}) {}
 
  constexpr CooArray(const std::array<ContainedClass, 3> &values) : BaseType(values) {}
  constexpr CooArray(std::array<ContainedClass, 3> &&values) : BaseType(std::move(values)) {}
 
  constexpr CooArray<ContainedClass> &operator=(const CooArray<ContainedClass> &lhs) {
    BaseType::operator=(lhs);
    return *this;
  }
 
  constexpr ContainedClass &operator[](const RefFrame::Coo &coo) { return BaseType::operator[](static_cast<int>(coo)); }
 
  constexpr const ContainedClass &operator[](const RefFrame::Coo &coo) const {
    return BaseType::operator[](static_cast<int>(coo));
  }
 
  constexpr ContainedClass &at(const RefFrame::Coo &coo) { return BaseType::at(static_cast<int>(coo)); }
 
  constexpr const ContainedClass &at(const RefFrame::Coo &coo) const { return BaseType::at(static_cast<int>(coo)); }
};
 
} // namespace Herd
 
#endif /* HERD_COOARRAY_H_ */