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 "common/AxesArray.h"
#include "common/CooArray.h"
#include "common/RefFrame.h"
#include "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 <> const Vec3D defaultValue<Vec3D> = Vec3D();

// CooArray specialization
template <typename T>
const CooArray<T> defaultValue<CooArray<T>> = CooArray<T>(defaultValue<T>, defaultValue<T>, defaultValue<T>);

// needed for std::array specialization
template <class T, size_t N> std::array<T, N> make_array(const T &v) {
  std::array<T, N> ret;
  ret.fill(v);
  return ret;
}

// 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>);

// std::array specialization
template <class T, size_t N> const std::array<T, N> defaultValue<std::array<T, N>> = make_array<T, N>(defaultValue<T>);

namespace _Private { // needed for AxesArray specialization
template <typename T> 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> const AxesArray<T> defaultValue<AxesArray<T>> = _Private::getDefaultAxesArrayValue<T>();

// bitset specialization
template <int N> const 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