validator.h

Go to the documentation of this file.

#pragma once
 
#include <concepts>
#include <cstddef>
#include <functional>
#include <string>
#include <type_traits>
#include <vector>
 
namespace cppfig {
 
struct ValidationResult {
    bool is_valid = true;
    std::string error_message;
 
    static auto Ok() -> ValidationResult { return { .is_valid = true, .error_message = "" }; }
 
    static auto Error(std::string message) -> ValidationResult { return { .is_valid = false, .error_message = std::move(message) }; }
 
    explicit operator bool() const { return is_valid; }
};
 
template <typename V, typename T>
concept ValidatorFor = requires(const V& validator, const T& value) {
    { validator(value) } -> std::same_as<ValidationResult>;
};
 
template <typename T>
class Validator {
public:
    using validator_fn = std::function<ValidationResult(const T&)>;
 
    Validator()
        : fn_([](const T&) { return ValidationResult::Ok(); })
    {
    }
 
    explicit Validator(validator_fn fn)
        : fn_(std::move(fn))
    {
    }
 
    auto operator()(const T& value) const -> ValidationResult { return fn_(value); }
 
    [[nodiscard]] auto And(Validator<T> other) const -> Validator<T>
    {
        auto this_fn = fn_;
        auto other_fn = other.fn_;
        return Validator<T>([this_fn, other_fn](const T& value) -> ValidationResult {
            auto result = this_fn(value);
            if (!result) {
                return result;
            }
            return other_fn(value);
        });
    }
 
    [[nodiscard]] auto Or(Validator<T> other) const -> Validator<T>
    {
        auto this_fn = fn_;
        auto other_fn = other.fn_;
        return Validator<T>([this_fn, other_fn](const T& value) -> ValidationResult {
            auto result = this_fn(value);
            if (result) {
                return result;
            }
            return other_fn(value);
        });
    }
 
private:
    validator_fn fn_;
};
 
template <typename T>
    requires std::is_arithmetic_v<T>
auto Min(T min_value) -> Validator<T>
{
    return Validator<T>([min_value](const T& value) -> ValidationResult {
        if (value < min_value) {
            return ValidationResult::Error("Value " + std::to_string(value) + " is less than minimum " + std::to_string(min_value));
        }
        return ValidationResult::Ok();
    });
}
 
template <typename T>
    requires std::is_arithmetic_v<T>
auto Max(T max_value) -> Validator<T>
{
    return Validator<T>([max_value](const T& value) -> ValidationResult {
        if (value > max_value) {
            return ValidationResult::Error("Value " + std::to_string(value) + " exceeds maximum " + std::to_string(max_value));
        }
        return ValidationResult::Ok();
    });
}
 
template <typename T>
    requires std::is_arithmetic_v<T>
auto Range(T min_value, T max_value) -> Validator<T>
{
    return Min(min_value).And(Max(max_value));
}
 
template <typename T>
    requires std::is_arithmetic_v<T>
auto Positive() -> Validator<T>
{
    return Validator<T>([](const T& value) -> ValidationResult {
        if (value <= T { 0 }) {
            return ValidationResult::Error("Value must be positive");
        }
        return ValidationResult::Ok();
    });
}
 
template <typename T>
    requires std::is_arithmetic_v<T>
auto NonNegative() -> Validator<T>
{
    return Validator<T>([](const T& value) -> ValidationResult {
        if (value < T { 0 }) {
            return ValidationResult::Error("Value must be non-negative");
        }
        return ValidationResult::Ok();
    });
}
 
inline auto NotEmpty() -> Validator<std::string>
{
    return Validator<std::string>([](const std::string& value) -> ValidationResult {
        if (value.empty()) {
            return ValidationResult::Error("Value must not be empty");
        }
        return ValidationResult::Ok();
    });
}
 
inline auto MaxLength(std::size_t max_len) -> Validator<std::string>
{
    return Validator<std::string>([max_len](const std::string& value) -> ValidationResult {
        if (value.size() > max_len) {
            return ValidationResult::Error("String length " + std::to_string(value.size()) + " exceeds maximum " + std::to_string(max_len));
        }
        return ValidationResult::Ok();
    });
}
 
inline auto MinLength(std::size_t min_len) -> Validator<std::string>
{
    return Validator<std::string>([min_len](const std::string& value) -> ValidationResult {
        if (value.size() < min_len) {
            return ValidationResult::Error("String length " + std::to_string(value.size()) + " is less than minimum " + std::to_string(min_len));
        }
        return ValidationResult::Ok();
    });
}
 
template <typename T>
auto OneOf(std::vector<T> allowed_values) -> Validator<T>
{
    return Validator<T>([allowed = std::move(allowed_values)](const T& value) -> ValidationResult {
        for (const auto& allowed_value : allowed) {
            if (value == allowed_value) {
                return ValidationResult::Ok();
            }
        }
        return ValidationResult::Error("Value is not in the list of allowed values");
    });
}
 
template <typename T, typename Pred>
    requires std::predicate<Pred, const T&>
auto Predicate(Pred pred, std::string error_message) -> Validator<T>
{
    return Validator<T>([p = std::move(pred), msg = std::move(error_message)](const T& value) -> ValidationResult {
        if (!p(value)) {
            return ValidationResult::Error(msg);
        }
        return ValidationResult::Ok();
    });
}
 
template <typename T>
auto AlwaysValid() -> Validator<T>
{
    return Validator<T>();
}
 
}  // namespace cppfig