min_max_value.hpp

// Copyright (C) 2022 by Camden Mannett.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE or copy at https://www.boost.org/LICENSE_1_0.txt)
 
#pragma once
 
#include "arg_router/exception.hpp"
#include "arg_router/parsing/parsing.hpp"
#include "arg_router/policy/policy.hpp"
 
#include <limits>
 
namespace arg_router::policy
{
template <typename ValueType, typename LessThanCompare = std::less<ValueType>>
class min_max_value_t
{
public:
    using value_type = ValueType;
    using less_than_compare = LessThanCompare;
 
    constexpr min_max_value_t(std::optional<value_type> min,
                              std::optional<value_type> max,
                              less_than_compare compare = less_than_compare{}) noexcept :
        min_(std::move(min)),
        max_(std::move(max)),  //
        comp_{std::move(compare)}
    {
    }
 
    [[nodiscard]] constexpr const less_than_compare& comp() const noexcept { return comp_; }
 
    template <typename InputValueType, typename... Parents>
    void validation_phase(const InputValueType& value,
                          [[maybe_unused]] const Parents&... parents) const
    {
        static_assert(sizeof...(Parents) >= 1, "Min/max value requires at least 1 parent");
 
        using node_type = boost::mp11::mp_first<std::tuple<Parents...>>;
 
        if (min_ && comp_(value, *min_)) {
            throw multi_lang_exception{error_code::minimum_value_not_reached,
                                       parsing::node_token_type<node_type>()};
        }
        if (max_ && comp_(*max_, value)) {
            throw multi_lang_exception{error_code::maximum_value_exceeded,
                                       parsing::node_token_type<node_type>()};
        }
    }
 
private:
    std::optional<value_type> min_;
    std::optional<value_type> max_;
    less_than_compare comp_;
};
 
template <typename MinType, typename MaxType>
class min_max_value_ct
{
    static_assert(!(std::is_void_v<MinType> && std::is_void_v<MaxType>),
                  "MinType and MaxType cannot both be void");
 
public:
    explicit min_max_value_ct() noexcept
    {
        if constexpr (!std::is_void_v<MinType>) {
            static_assert(traits::has_value_type_v<MinType>, "MinType must have a value_type");
            static_assert(std::is_integral_v<typename MinType::value_type> ||
                              std::is_enum_v<typename MinType::value_type>,
                          "MinType value_type must be integrals or enums");
        }
        if constexpr (!std::is_void_v<MaxType>) {
            static_assert(traits::has_value_type_v<MaxType>, "MaxType must have a value_type");
            static_assert(std::is_integral_v<typename MaxType::value_type> ||
                              std::is_enum_v<typename MaxType::value_type>,
                          "MaxType value_type must be integrals or enums");
        }
 
        if constexpr (!std::is_void_v<MinType> && !std::is_void_v<MaxType>) {
            static_assert(
                std::is_same_v<typename MinType::value_type, typename MaxType::value_type>,
                "MinType and MaxType must have the same value_type");
            static_assert(MinType::value <= MaxType::value,
                          "MinType must be less than or equal to MaxType");
        }
    }
 
    template <typename T = MinType>
    [[nodiscard]] constexpr static auto minimum_value(
        // NOLINTNEXTLINE(*-named-parameter)
        std::enable_if_t<!std::is_void_v<T>>* = nullptr) noexcept
    {
        return MinType::value;
    }
 
    template <typename T = MaxType>
    [[nodiscard]] constexpr static auto maximum_value(
        // NOLINTNEXTLINE(*-named-parameter)
        std::enable_if_t<!std::is_void_v<T>>* = nullptr) noexcept
    {
        return MaxType::value;
    }
 
    template <typename InputValueType, typename... Parents>
    void validation_phase(const InputValueType& value,
                          [[maybe_unused]] const Parents&... parents) const
    {
        static_assert(sizeof...(Parents) >= 1, "Min/max value requires at least 1 parent");
 
        using node_type = boost::mp11::mp_first<std::tuple<Parents...>>;
 
        if constexpr (!std::is_void_v<MinType>) {
            if (value < minimum_value()) {
                throw multi_lang_exception{error_code::minimum_value_not_reached,
                                           parsing::node_token_type<node_type>()};
            }
        }
        if constexpr (!std::is_void_v<MaxType>) {
            if (value > maximum_value()) {
                throw multi_lang_exception{error_code::maximum_value_exceeded,
                                           parsing::node_token_type<node_type>()};
            }
        }
    }
};
 
template <typename ValueType, typename LessThanCompare = std::less<ValueType>>
[[nodiscard]] constexpr auto min_max_value(ValueType&& min,
                                           ValueType&& max,
                                           LessThanCompare&& compare = LessThanCompare{}) noexcept
{
    return min_max_value_t<ValueType, LessThanCompare>{std::forward<ValueType>(min),
                                                       std::forward<ValueType>(max),
                                                       std::forward<LessThanCompare>(compare)};
}
 
template <typename ValueType, typename LessThanCompare = std::less<ValueType>>
[[nodiscard]] constexpr auto min_value(ValueType&& min,
                                       LessThanCompare&& compare = LessThanCompare{}) noexcept
{
    return min_max_value_t<ValueType, LessThanCompare>{std::forward<ValueType>(min),
                                                       {},
                                                       std::forward<LessThanCompare>(compare)};
}
 
template <typename ValueType, typename LessThanCompare = std::less<ValueType>>
[[nodiscard]] constexpr auto max_value(ValueType&& max,
                                       LessThanCompare&& compare = LessThanCompare{}) noexcept
{
    return min_max_value_t<ValueType, LessThanCompare>{{},
                                                       std::forward<ValueType>(max),
                                                       std::forward<LessThanCompare>(compare)};
}
 
template <auto Min, auto Max>
[[nodiscard]] constexpr auto min_max_value() noexcept
{
    return min_max_value_ct<traits::integral_constant<Min>, traits::integral_constant<Max>>{};
}
 
template <auto Min>
[[nodiscard]] constexpr auto min_value() noexcept
{
    return min_max_value_ct<traits::integral_constant<Min>, void>{};
}
 
template <auto Max>
[[nodiscard]] constexpr auto max_value() noexcept
{
    return min_max_value_ct<void, traits::integral_constant<Max>>{};
}
 
template <typename ValueType, typename LessThanCompare>
struct is_policy<min_max_value_t<ValueType, LessThanCompare>> : std::true_type {
};
 
template <typename ValueType>
struct is_policy<min_max_value_t<ValueType>> : std::true_type {
};
 
template <typename MinType, typename MaxType>
struct is_policy<min_max_value_ct<MinType, MaxType>> : std::true_type {
};
}  // namespace arg_router::policy