DefaultValues.h

Go to the documentation of this file.

/*
 * DefaultValues.h
 *
 *  Created on: 21 Jul 2020
 *      Author: Valerio Formato
 */
 
#ifndef HERD_DEFAULTVALUES_H_
#define HERD_DEFAULTVALUES_H_
 
#include "herd/analysis/common/AxesArray.h"
#include "herd/analysis/common/CooArray.h"
#include "herd/analysis/common/RefFrame.h"
#include "herd/analysis/common/Vec3D.h"
 
#include <bitset>
#include <limits>
#include <string>
 
// clang-format off
#define DEFAULT_INIT(x) x{defaultValue<decltype(x)>}
#define SET_TO_DEFAULT(x) x = DefaultValue(x)
// clang-format on
 
namespace Herd {
namespace {
 
// default for numeric types
template <typename T>
constexpr typename std::enable_if_t<std::is_arithmetic<T>::value, T> defaultValue = std::numeric_limits<T>::max();
 
// std::string specialization
template <> const std::string defaultValue<std::string> = "";
 
// RefFrame::Direction specialization
template <> constexpr RefFrame::Direction defaultValue<RefFrame::Direction> = RefFrame::Direction::NONE;
 
// RefFrame::Side specialization
template <> constexpr RefFrame::Side defaultValue<RefFrame::Side> = RefFrame::Side::NONE;
 
// Vec3D specialization (default constructor is already filled with "invalid" values)
template <> constexpr Vec3D defaultValue<Vec3D> = Vec3D();
 
// needed for std::array specialization
template <class T, size_t N> constexpr std::array<T, N> make_array(const T &v) {
  std::array<T, N> ret{};
  for (auto &val : ret) {
    val = v;
  }
  return ret;
}
 
// std::array specialization
template <class T, size_t N>
constexpr std::array<T, N> defaultValue<std::array<T, N>> = make_array<T, N>(defaultValue<T>);
 
// CooArray specialization
template <typename T> constexpr CooArray<T> defaultValue<CooArray<T>> = CooArray<T>(make_array<T, 3>(defaultValue<T>));
 
// std::pair specialization
template <typename T, typename U>
constexpr std::pair<T, U> defaultValue<std::pair<T, U>> = std::make_pair(defaultValue<T>, defaultValue<U>);
 
namespace _Private { // needed for AxesArray specialization
template <typename T> constexpr AxesArray<T> getDefaultAxesArrayValue() {
  AxesArray<T> result;
  result[RefFrame::Axis::X] = defaultValue<T>;
  result[RefFrame::Axis::Y] = defaultValue<T>;
  result[RefFrame::Axis::Z] = defaultValue<T>;
  return result;
}
} // namespace _Private
 
// AxesArray specialization
template <typename T> constexpr AxesArray<T> defaultValue<AxesArray<T>> = _Private::getDefaultAxesArrayValue<T>();
 
// bitset specialization
template <int N> constexpr std::bitset<N> defaultValue<std::bitset<N>> = std::bitset<N>();
 
// generic getter
template <typename T> constexpr T DefaultValue(const T &x) {
  return defaultValue<std::remove_const_t<std::remove_reference_t<decltype(x)>>>;
}
 
} // namespace
} // namespace Herd
#endif