config_validators.hpp

Go to the documentation of this file.

#pragma once
 
#include <cstddef>
#include <functional>
#include <string>
#include <vector>
 
#include "fmt/format.h"
 
#include "porytiles2/xcut/config/config_value.hpp"
#include "porytiles2/xcut/result/chainable_result.hpp"
 
namespace porytiles2 {
 
/*
 * Regular (single-value) validators
 */
 
[[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.name(), Style::bold}, FormatParam{"0", Style::bold}});
        err_text.emplace_back("");
        params.emplace_back();
 
        auto [format_text, format_params] = val.format_data();
        std::ranges::copy(format_text, std::back_inserter(err_text));
        std::ranges::copy(format_params, std::back_inserter(params));
        return FormattableError{err_text, params};
    }
    return val;
}
 
/*
 * Cross-field validators
 * These validators can access other config values for validation
 */
 
namespace details {
 
template <typename T, typename ConfigInterface, typename FetchFunc, typename Comparator>
[[nodiscard]] ChainableResult<ConfigValue<T>> compare_values(
    const ConfigValue<T> &val,
    const ConfigInterface &config,
    const std::string &scope_param,
    const std::string &other_field_name,
    FetchFunc fetch_other,
    Comparator comp,
    std::string_view error_message)
{
    auto other_result = fetch_other(config, scope_param);
 
    // 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.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();
        std::ranges::copy(format_text, std::back_inserter(err_text));
        std::ranges::copy(format_params, std::back_inserter(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();
        std::ranges::copy(other_format_text, std::back_inserter(err_text));
        std::ranges::copy(other_format_params, std::back_inserter(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,
    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::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,
    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::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,
    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::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,
    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::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 porytiles2