fields.hpp

Go to the documentation of this file.

#pragma once

#include <algorithm>
#include <cmath>
#include <optional>
#include <string>
#include <tuple>
#include <type_traits>

namespace reactions {

  template <class... Args> struct fill : std::tuple<Args...> {
    using base_type = std::tuple<Args...>;
    constexpr fill(Args &&...args) : base_type{std::forward<Args>(args)...} {}
  };

  static constexpr auto missing = std::nullopt;
} // namespace reactions

namespace reactions::fields {

  template <class Tuple> struct underlying_types;

  template <class... Field> struct underlying_types<std::tuple<Field...>> {
    using type = std::tuple<typename Field::value_type...>;
  };

  template <class Fields>
  using underlying_types_t = typename underlying_types<Fields>::type;

  template <class> struct is_optional : std::false_type {};

  template <class T> struct is_optional<std::optional<T>> : std::true_type {};

  template <class T> constexpr auto is_optional_v = is_optional<T>::value;

  template <class Field, class Enable = void>
  struct is_optional_field : std::false_type {};

  template <class Field>
  struct is_optional_field<
      Field, std::enable_if_t<is_optional_v<typename Field::value_type>>>
      : std::true_type {};

  template <class Field>
  constexpr auto is_optional_field_v = is_optional_field<Field>::value;

  template <class T> struct remove_optional { using type = T; };

  template <class T> struct remove_optional<std::optional<T>> {
    using type = T;
  };

  template <class T>
  using remove_optional_t = typename remove_optional<T>::type;

  struct value {};
  struct error {};
  struct error_lower {};
  struct error_upper {};
  struct tag {};

  template <std::size_t Min, std::size_t Max> struct range {
    static constexpr auto min = Min, max = Max;
  };

  template <class... R> using range_collection = std::tuple<R...>;

  template <class R> struct overall_range {
    using type = range<R::min, R::max>;
  };

  template <class R0, class... R, class Rn>
  struct overall_range<range_collection<R0, R..., Rn>> {
    using type = range<R0::min, Rn::max>;
  };

  template <class R> using overall_range_t = typename overall_range<R>::type;

  template <class T, class Enable = void> struct value_and_error;

  template <class T>
  struct value_and_error<T,
                         std::enable_if_t<std::is_floating_point_v<T>, void>> {

    using value_type = T;

    value_and_error(){};

    template <class Value, class Error>
    value_and_error(Value value_, Error error_)
        : value(value_), error(error_) {}
    template <class Value, class Error>
    value_and_error(fill<Value, Error> &&f)
        : value(std::get<0>(f)), error(std::get<1>(f)) {}

    value_type value;
    value_type error;
  };

  template <class ValueType, class TagType, class Enable = void>
  struct value_and_error_with_tag;

  template <class ValueType, class TagType>
  struct value_and_error_with_tag<
      ValueType, TagType,
      std::enable_if_t<(std::is_floating_point_v<ValueType> &&
                        std::is_integral_v<TagType>),
                       void>> : value_and_error<ValueType> {

    using base_type = value_and_error<ValueType>;

    value_and_error_with_tag() : base_type{} {};

    template <class Value, class Error>
    value_and_error_with_tag(Value value_, Error error_, TagType tag_)
        : base_type{value_, error_}, tag(tag_) {}
    template <class Value, class Error>
    value_and_error_with_tag(fill<Value, Error, TagType> &&f)
        : base_type{std::get<0>(f), std::get<1>(f)}, tag(std::get<2>(f)) {}

    TagType tag;
  };

  template <class T, class Enable = void> struct value_and_errors;

  template <class T>
  struct value_and_errors<T,
                          std::enable_if_t<std::is_floating_point_v<T>, void>> {

    using value_type = T;

    value_and_errors() = default;
    template <class Value, class ErrorLower, class ErrorUpper>
    value_and_errors(Value value_, ErrorLower error_lower_,
                     ErrorUpper error_upper_)
        : value(value_), error_lower(error_lower_), error_upper(error_upper_) {}
    template <class Value, class ErrorLower, class ErrorUpper>
    value_and_errors(fill<Value, ErrorLower, ErrorUpper> &&f)
        : value(std::get<0>(f)), error_lower(std::get<1>(f)),
          error_upper(std::get<2>(f)) {}

    value_type value;
    value_type error_lower;
    value_type error_upper;
    value_type error_squared() const {
      return error_lower * error_lower + error_upper * error_upper;
    };
    value_type error() const { return std::sqrt(error_squared()); }
  };

  template <class T> constexpr auto const &access_value(T const &c) {
    return c;
  }

  template <class T>
  constexpr auto const &access_value(std::optional<T> const &opt) {
    return opt.value();
  }

  template <class Field> struct get_t;

  template <> struct get_t<value> {
    template <class T> constexpr auto const &operator()(T const &t) const {
      return access_value(t).value;
    }
  };

  template <> struct get_t<error> {
    template <class T> constexpr auto const &operator()(T const &t) const {
      return access_value(t).error;
    }
  };

  template <> struct get_t<error_lower> {
    template <class T> constexpr auto const &operator()(T const &t) const {
      return access_value(t).error_lower;
    }
  };

  template <> struct get_t<error_upper> {
    template <class T> constexpr auto const &operator()(T const &t) const {
      return access_value(t).error_upper;
    }
  };

  template <> struct get_t<tag> {
    template <class T> constexpr auto const &operator()(T const &t) const {
      return access_value(t).tag;
    }
  };

  template <class T, class Subfield, class... S> struct type_of {
    using type = typename type_of<Subfield, S...>::type;
  };

  template <class T, class Subfield> struct type_of<T, Subfield> {
    using type =
        std::enable_if_t<std::is_default_constructible_v<T>,
                         std::decay_t<decltype(get_t<Subfield>{}(T{}))>>;
  };

  template <class T, class... Subfield>
  using type_of_t = typename type_of<T, Subfield...>::type;

  template <class T>
  value_and_error<T> operator*(value_and_error<T> const &vae, T f) {
    return {f * vae.value, f * vae.error};
  }

  template <class T>
  value_and_error<T> operator*(T f, value_and_error<T> const &vae) {
    return vae * f;
  }

  template <class V, class T>
  value_and_error_with_tag<V, T>
  operator*(value_and_error_with_tag<V, T> const &vae, V f) {
    return {f * vae.value, f * vae.error, vae.tag};
  }

  template <class V, class T>
  value_and_error_with_tag<V, T>
  operator*(V f, value_and_error_with_tag<V, T> const &vae) {
    return vae * f;
  }

  template <class T>
  value_and_errors<T> operator*(value_and_errors<T> const &vae, T f) {
    return {f * vae.value, f * vae.error_lower, f * vae.error_upper};
  }

  template <class T>
  value_and_errors<T> operator*(T f, value_and_errors<T> const &vae) {
    return vae * f;
  }

  template <class Field> static constexpr get_t<Field> get;

  using float_opt = std::optional<float>;
  using double_opt = std::optional<double>;
  using ve_float_opt = std::optional<value_and_error<float>>;
  using ve_double_opt = std::optional<value_and_error<double>>;
  template <class TagType>
  using vet_float_opt = std::optional<value_and_error_with_tag<float, TagType>>;
  template <class TagType>
  using vet_double_opt =
      std::optional<value_and_error_with_tag<double, TagType>>;
  using ves_float_opt = std::optional<value_and_errors<float>>;
  using ves_double_opt = std::optional<value_and_errors<double>>;

  enum conversion_status : int {
    success, 
    empty,   
    failed   
  };

  namespace detail {

    conversion_status string_to_type(int &out, std::string const &s) {

      if (s.empty())
        return empty;

      try {
        out = std::stoi(s);
      } catch (std::invalid_argument &e) {
        return failed;
      }

      return success;
    }

    conversion_status string_to_type(float &out, std::string const &s) {

      if (s.empty())
        return empty;

      try {
        out = std::stof(s);
      } catch (std::invalid_argument &e) {
        return failed;
      }

      return success;
    }

    conversion_status string_to_type(double &out, std::string const &s) {

      if (s.empty())
        return empty;

      try {
        out = std::stod(s);
      } catch (std::invalid_argument &e) {
        return failed;
      }

      return success;
    }

    conversion_status string_to_type(bool &out, std::string const &s) {

      if (s.empty())
        return empty;

      try {
        out = std::stoi(s);
      } catch (std::invalid_argument &e) {
        return failed;
      }

      return success;
    }

    conversion_status string_to_type(std::string &out, std::string const &s) {

      out = s;

      if (out.size() == 0)
        return empty;
      else
        return success;
    }
  } // namespace detail

  template <class Range, class T>
  conversion_status read_field(T &out, std::string const &s) {
    // std::from_chars is not correctly implemented in GCC, and
    // we can not work with std::string_view objects
    auto b = s.find_first_not_of(' ', Range::min);

    if (b >= Range::max)
      return empty;

    auto e = s.find_last_not_of(' ', Range::max) + 1;

    return detail::string_to_type(out, s.substr(b, e - b));
  }

  template <class Ranges, class T>
  conversion_status read_field(value_and_error<T> &out, std::string const &s) {
    // std::from_chars is not correctly implemented in GCC, and
    // we can not work with std::string_view objects
    static_assert(std::tuple_size_v<Ranges> == 3);

    auto b = s.find_first_not_of(' ', std::tuple_element_t<0, Ranges>::min);

    if (b >= std::tuple_element_t<1, Ranges>::max)
      return empty;

    auto value_sc = read_field<std::tuple_element_t<0, Ranges>>(out.value, s);
    auto error_sc = read_field<std::tuple_element_t<1, Ranges>>(out.error, s);

    if (value_sc == empty || error_sc == empty)
      return failed; // either all are defined or none
    else if (value_sc == failed || error_sc == failed)
      return failed;
    else
      return success;
  }

  template <class Ranges, class ValueType, class TagType>
  conversion_status
  read_field(value_and_error_with_tag<ValueType, TagType> &out,
             std::string const &s) {
    // std::from_chars is not correctly implemented in GCC, and
    // we can not work with std::string_view objects
    static_assert(std::tuple_size_v<Ranges> == 3);

    auto b = s.find_first_not_of(' ', std::tuple_element_t<0, Ranges>::min);

    if (b >= std::tuple_element_t<2, Ranges>::max)
      return empty;

    auto value_sc = read_field<std::tuple_element_t<0, Ranges>>(out.value, s);
    auto error_sc = read_field<std::tuple_element_t<1, Ranges>>(out.error, s);
    auto tag_sc = read_field<std::tuple_element_t<2, Ranges>>(out.tag, s);

    if (value_sc == empty || error_sc == empty || tag_sc == empty)
      return failed; // either all are defined or none
    else if (value_sc == failed || error_sc == failed || tag_sc == failed)
      return failed;
    else
      return success;
  }

  template <class Ranges, class T>
  conversion_status read_field(value_and_errors<T> &out, std::string const &s) {
    // std::from_chars is not correctly implemented in GCC, and
    // we can not work with std::string_view objects
    static_assert(std::tuple_size_v<Ranges> == 3);

    auto b = s.find_first_not_of(' ', std::tuple_element_t<0, Ranges>::min);

    if (b >= std::tuple_element_t<2, Ranges>::max)
      return empty;

    auto value_sc = read_field<std::tuple_element_t<0, Ranges>>(out.value, s);
    auto error_lower_sc =
        read_field<std::tuple_element_t<1, Ranges>>(out.error_lower, s);
    auto error_upper_sc =
        read_field<std::tuple_element_t<2, Ranges>>(out.error_upper, s);

    if (value_sc == empty || error_lower_sc == empty || error_upper_sc == empty)
      return failed; // either all are defined or none
    else if (value_sc == failed || error_lower_sc == failed ||
             error_upper_sc == failed)
      return failed;
    else
      return success;
  }

  template <class Field, class... Subfield> struct field_member_type {
    using type =
        type_of_t<remove_optional_t<typename Field::value_type>, Subfield...>;
  };

  template <class Field> struct field_member_type<Field> {
    using type = remove_optional_t<typename Field::value_type>;
  };

  template <class Field, class... Subfield>
  using field_member_type_t =
      typename field_member_type<Field, Subfield...>::type;

  template <class T> std::string to_string(T const &v) {
    return std::to_string(v);
  }

  template <> std::string to_string(std::string const &v) { return v; }
} // namespace reactions::fields