draconisplusplus/include/rfl/comparisons.hpp

#ifndef RFL_COMPARISONS_HPP_
#define RFL_COMPARISONS_HPP_

#include <type_traits>

#include "Result.hpp"
#include "parsing/schema/ValidationType.hpp"

namespace rfl {

template <auto _threshold>
struct EqualTo {
  template <class T>
  static Result<T> validate(T _value) noexcept {
    constexpr auto threshold = static_cast<T>(_threshold);
    if (_value != threshold) {
      return Error("Value expected to be equal to " +
                   std::to_string(threshold) + ", but got " +
                   std::to_string(_value) + ".");
    }
    return _value;
  }

  template <class T>
  static parsing::schema::ValidationType to_schema() {
    using ValidationType = parsing::schema::ValidationType;
    const auto value =
        std::is_floating_point_v<T>
            ? std::variant<double, int>(static_cast<double>(_threshold))
            : std::variant<double, int>(static_cast<int>(_threshold));
    return ValidationType{ValidationType::EqualTo{.value_ = value}};
  }
};

template <auto _threshold>
struct Minimum {
  template <class T>
  static Result<T> validate(T _value) noexcept {
    constexpr auto threshold = static_cast<T>(_threshold);
    if (_value < threshold) {
      return Error("Value expected to be greater than or equal to " +
                   std::to_string(threshold) + ", but got " +
                   std::to_string(_value) + ".");
    }
    return _value;
  }

  template <class T>
  static parsing::schema::ValidationType to_schema() {
    using ValidationType = parsing::schema::ValidationType;
    const auto value =
        std::is_floating_point_v<T>
            ? std::variant<double, int>(static_cast<double>(_threshold))
            : std::variant<double, int>(static_cast<int>(_threshold));
    return ValidationType{ValidationType::Minimum{.value_ = value}};
  }
};

template <auto _threshold>
struct ExclusiveMinimum {
  template <class T>
  static Result<T> validate(T _value) noexcept {
    constexpr auto threshold = static_cast<T>(_threshold);
    if (_value <= threshold) {
      return Error("Value expected to be greater than " +
                   std::to_string(threshold) + ", but got " +
                   std::to_string(_value) + ".");
    }
    return _value;
  }

  template <class T>
  static parsing::schema::ValidationType to_schema() {
    using ValidationType = parsing::schema::ValidationType;
    const auto value =
        std::is_floating_point_v<T>
            ? std::variant<double, int>(static_cast<double>(_threshold))
            : std::variant<double, int>(static_cast<int>(_threshold));
    return ValidationType{ValidationType::ExclusiveMinimum{.value_ = value}};
  }
};

template <auto _threshold>
struct Maximum {
  template <class T>
  static Result<T> validate(T _value) noexcept {
    constexpr auto threshold = static_cast<T>(_threshold);
    if (_value > threshold) {
      return Error("Value expected to be less than or equal to " +
                   std::to_string(threshold) + ", but got " +
                   std::to_string(_value) + ".");
    }
    return _value;
  }

  template <class T>
  static parsing::schema::ValidationType to_schema() {
    using ValidationType = parsing::schema::ValidationType;
    const auto value =
        std::is_floating_point_v<T>
            ? std::variant<double, int>(static_cast<double>(_threshold))
            : std::variant<double, int>(static_cast<int>(_threshold));
    return ValidationType{ValidationType::Maximum{.value_ = value}};
  }
};

template <auto _threshold>
struct ExclusiveMaximum {
  template <class T>
  static Result<T> validate(T _value) noexcept {
    constexpr auto threshold = static_cast<T>(_threshold);
    if (_value >= threshold) {
      return Error("Value expected to be less than " +
                   std::to_string(threshold) + ", but got " +
                   std::to_string(_value) + ".");
    }
    return _value;
  }

  template <class T>
  static parsing::schema::ValidationType to_schema() {
    using ValidationType = parsing::schema::ValidationType;
    const auto value =
        std::is_floating_point_v<T>
            ? std::variant<double, int>(static_cast<double>(_threshold))
            : std::variant<double, int>(static_cast<int>(_threshold));
    return ValidationType{ValidationType::ExclusiveMaximum{.value_ = value}};
  }
};

template <auto _threshold>
struct NotEqualTo {
  template <class T>
  static Result<T> validate(T _value) noexcept {
    constexpr auto threshold = static_cast<T>(_threshold);
    if (_value == threshold) {
      return Error("Value expected to not be equal to " +
                   std::to_string(threshold) + ", but got " +
                   std::to_string(_value) + ".");
    }
    return _value;
  }

  template <class T>
  static parsing::schema::ValidationType to_schema() {
    using ValidationType = parsing::schema::ValidationType;
    const auto value =
        std::is_floating_point_v<T>
            ? std::variant<double, int>(static_cast<double>(_threshold))
            : std::variant<double, int>(static_cast<int>(_threshold));
    return ValidationType{ValidationType::NotEqualTo{.value_ = value}};
  }
};

}  // namespace rfl

#endif