database.hpp

Go to the documentation of this file.

#pragma once

#include <algorithm>
#include <cmath>
#include <optional>
#include <stdexcept>
#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::database {

  template <class Tuple> struct underlying_types;

  template <class... F> struct underlying_types<std::tuple<F...>> {
    using type = std::tuple<typename F::value_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 F, class Enable = void>
  struct is_optional_field : std::false_type {};

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

  template <class F>
  constexpr auto is_optional_field_v = is_optional_field<F>::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 {};

  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_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 F> 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 <class F> static constexpr get_t<F> get;

  using float_opt = std::optional<float>;
  using double_opt = std::optional<double>;
  using ve_float_opt = std::optional<value_and_errors<float>>;
  using ve_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_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 = detail::string_to_type(
        out.value, s.substr(std::tuple_element_t<0, Ranges>::min,
                            std::tuple_element_t<0, Ranges>::max));
    auto error_lower_sc = detail::string_to_type(
        out.error_lower, s.substr(std::tuple_element_t<1, Ranges>::min,
                                  std::tuple_element_t<1, Ranges>::max));
    auto error_upper_sc = detail::string_to_type(
        out.error_upper, s.substr(std::tuple_element_t<2, Ranges>::min,
                                  std::tuple_element_t<2, Ranges>::max));

    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;
  }
} // namespace reactions::database