xcut_config_validators.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <cstddef>
#include <functional>
#include <string>
#include <vector>
 
#include "porytiles/utilities/result/chainable_result.hpp"
#include "porytiles/xcut/config/config_scope_type.hpp"
#include "porytiles/xcut/config/config_value.hpp"
 
namespace porytiles {
 
[[nodiscard]] inline ChainableResult<ConfigValue<std::size_t>>
size_t_val_greater_than_zero(const ConfigValue<std::size_t> &val)
{
    if (val == 0) {
        std::vector<std::string> err_text{};
        std::vector<std::vector<FormatParam>> params{};
 
        err_text.emplace_back("'{}' must be greater than '{}'.");
        params.emplace_back(std::vector{FormatParam{val.canonical_name(), Style::bold}, FormatParam{"0", Style::bold}});
        err_text.emplace_back("");
        params.emplace_back();
 
        auto [format_text, format_params] = val.format_data();
        err_text.append_range(format_text);
        params.append_range(format_params);
        return FormattableError{err_text, params};
    }
    return val;
}
 
[[nodiscard]] inline ChainableResult<ConfigValue<std::size_t>>
size_t_val_two_or_four(const ConfigValue<std::size_t> &val)
{
    if (val != 2 && val != 4) {
        std::vector<std::string> err_text{};
        std::vector<std::vector<FormatParam>> params{};
 
        err_text.emplace_back("'{}' must be either '{}' or '{}'.");
        params.emplace_back(
            std::vector{
                FormatParam{val.canonical_name(), Style::bold},
                FormatParam{"2", Style::bold},
                FormatParam{"4", Style::bold}});
        err_text.emplace_back("");
        params.emplace_back();
 
        auto [format_text, format_params] = val.format_data();
        err_text.append_range(format_text);
        params.append_range(format_params);
        return FormattableError{err_text, params};
    }
    return val;
}
 
[[nodiscard]] inline ChainableResult<ConfigValue<std::size_t>>
size_t_val_eight_or_twelve(const ConfigValue<std::size_t> &val)
{
    if (val != 8 && val != 12) {
        std::vector<std::string> err_text{};
        std::vector<std::vector<FormatParam>> params{};
 
        err_text.emplace_back("'{}' must be either '{}' or '{}'.");
        params.emplace_back(
            std::vector{
                FormatParam{val.canonical_name(), Style::bold},
                FormatParam{"8", Style::bold},
                FormatParam{"12", Style::bold}});
        err_text.emplace_back("");
        params.emplace_back();
 
        auto [format_text, format_params] = val.format_data();
        err_text.append_range(format_text);
        params.append_range(format_params);
        return FormattableError{err_text, params};
    }
    return val;
}
 
namespace details {
 
template <typename T, typename ConfigInterface, typename FetchFunc, typename Comparator>
[[nodiscard]] ChainableResult<ConfigValue<T>> compare_values(
    const ConfigValue<T> &val,
    const ConfigInterface &config,
    ConfigScopeType type,
    const std::string &scope,
    const std::string &other_field_name,
    FetchFunc fetch_other,
    Comparator comp,
    std::string_view error_message)
{
    auto other_result = fetch_other(config, type, scope);
 
    // If fetching the other value failed, propagate that error
    if (!other_result.has_value()) {
        return other_result.error();
    }
 
    const auto &other_val = other_result.value();
 
    // Perform the comparison
    if (!comp(val.value(), other_val.value())) {
        std::vector<std::string> err_text{};
        std::vector<std::vector<FormatParam>> params{};
 
        err_text.emplace_back("'{}' {} '{}'.");
        params.emplace_back(
            std::vector{
                FormatParam{val.canonical_name(), Style::bold},
                FormatParam{std::string{error_message}, Style::none},
                FormatParam{other_field_name, Style::bold}});
        err_text.emplace_back("");
        params.emplace_back();
 
        auto [format_text, format_params] = val.format_data();
        err_text.append_range(format_text);
        params.append_range(format_params);
 
        err_text.emplace_back("");
        params.emplace_back();
        err_text.emplace_back("{}");
        params.emplace_back(std::vector{FormatParam{"Comparison value:", Style::italic}});
        err_text.emplace_back("");
        params.emplace_back();
 
        auto [other_format_text, other_format_params] = other_val.format_data();
        err_text.append_range(other_format_text);
        params.append_range(other_format_params);
 
        return FormattableError{err_text, params};
    }
 
    return val;
}
 
} // namespace details
 
template <typename T, typename ConfigInterface, typename FetchFunc>
[[nodiscard]] ChainableResult<ConfigValue<T>> compare_greater_than(
    const ConfigValue<T> &val,
    const ConfigInterface &config,
    ConfigScopeType type,
    const std::string &scope,
    const std::string &other_field_name,
    FetchFunc fetch_other)
{
    return details::compare_values(
        val, config, type, scope, other_field_name, fetch_other, std::greater<>{}, "must be greater than");
}
 
template <typename T, typename ConfigInterface, typename FetchFunc>
[[nodiscard]] ChainableResult<ConfigValue<T>> compare_less_than(
    const ConfigValue<T> &val,
    const ConfigInterface &config,
    ConfigScopeType type,
    const std::string &scope,
    const std::string &other_field_name,
    FetchFunc fetch_other)
{
    return details::compare_values(
        val, config, type, scope, other_field_name, fetch_other, std::less<>{}, "must be less than");
}
 
template <typename T, typename ConfigInterface, typename FetchFunc>
[[nodiscard]] ChainableResult<ConfigValue<T>> compare_greater_equal(
    const ConfigValue<T> &val,
    const ConfigInterface &config,
    ConfigScopeType type,
    const std::string &scope,
    const std::string &other_field_name,
    FetchFunc fetch_other)
{
    return details::compare_values(
        val,
        config,
        type,
        scope,
        other_field_name,
        fetch_other,
        std::greater_equal<>{},
        "must be greater than or equal to");
}
 
template <typename T, typename ConfigInterface, typename FetchFunc>
[[nodiscard]] ChainableResult<ConfigValue<T>> compare_less_equal(
    const ConfigValue<T> &val,
    const ConfigInterface &config,
    ConfigScopeType type,
    const std::string &scope,
    const std::string &other_field_name,
    FetchFunc fetch_other)
{
    return details::compare_values(
        val, config, type, scope, other_field_name, fetch_other, std::less_equal<>{}, "must be less than or equal to");
}
 
template <typename T, typename ConfigInterface, typename FetchFunc>
[[nodiscard]] ChainableResult<ConfigValue<T>> compare_equal(
    const ConfigValue<T> &val,
    const ConfigInterface &config,
    const std::string &scope_param,
    const std::string &other_field_name,
    FetchFunc fetch_other)
{
    return details::compare_values(
        val, config, scope_param, other_field_name, fetch_other, std::equal_to<>{}, "must be equal to");
}
 
template <typename T, typename ConfigInterface, typename FetchFunc>
[[nodiscard]] ChainableResult<ConfigValue<T>> compare_not_equal(
    const ConfigValue<T> &val,
    const ConfigInterface &config,
    const std::string &scope_param,
    const std::string &other_field_name,
    FetchFunc fetch_other)
{
    return details::compare_values(
        val, config, scope_param, other_field_name, fetch_other, std::not_equal_to<>{}, "must not be equal to");
}
 
} // namespace porytiles