validators.hpp

#pragma once
 
#include <cstdint>
#include <stdexcept>
#include <string>
 
#include <fmt/format.h>
 
#include <userver/chaotic/exception.hpp>
#include <userver/utils/text_light.hpp>
 
USERVER_NAMESPACE_BEGIN
 
namespace chaotic {
 
template <const auto& Value>
struct Minimum final {
    template <typename T>
    static void Validate(T value) {
        static_assert(std::is_arithmetic_v<T>);
 
        if (value < Value) throw std::runtime_error(fmt::format("Invalid value, minimum={}, given={}", Value, value));
    }
};
 
template <const auto& Value>
struct Maximum final {
    template <typename T>
    static void Validate(T value) {
        static_assert(std::is_arithmetic_v<T>);
 
        if (value > Value) throw std::runtime_error(fmt::format("Invalid value, maximum={}, given={}", Value, value));
    }
};
 
template <const auto& Value>
struct ExclusiveMinimum final {
    template <typename T>
    static void Validate(T value) {
        static_assert(std::is_arithmetic_v<T>);
 
        if (value <= Value)
            throw std::runtime_error(fmt::format("Invalid value, exclusive minimum={}, given={}", Value, value));
    }
};
 
template <const auto& Value>
struct ExclusiveMaximum final {
    template <typename T>
    static void Validate(T value) {
        static_assert(std::is_arithmetic_v<T>);
 
        if (value >= Value)
            throw std::runtime_error(fmt::format("Invalid value, exclusive maximum={}, given={}", Value, value));
    }
};
 
template <std::int64_t Value>
struct MinItems final {
    template <typename T>
    static void Validate(const T& value) {
        if (value.size() < Value) {
            throw std::runtime_error(fmt::format("Too short array, minimum length={}, given={}", Value, value.size()));
        }
    }
};
 
template <std::int64_t Value>
struct MaxItems final {
    template <typename T>
    static void Validate(const T& value) {
        if (value.size() > Value) {
            throw std::runtime_error(fmt::format("Too long array, maximum length={}, given={}", Value, value.size()));
        }
    }
};
 
template <std::int64_t Value>
struct MinLength final {
    static void Validate(std::string_view value) {
        auto length = utils::text::utf8::GetCodePointsCount(value);
        if (length < Value) {
            throw std::runtime_error(fmt::format("Too short string, minimum length={}, given={}", Value, length));
        }
    }
};
 
template <std::int64_t Value>
struct MaxLength final {
    static void Validate(std::string_view value) {
        auto length = utils::text::utf8::GetCodePointsCount(value);
        if (length > Value) {
            throw std::runtime_error(fmt::format("Too long string, maximum length={}, given={}", Value, length));
        }
    }
};
 
template <typename... Validators, typename Obj, typename Value>
void Validate(const Obj& obj, const Value& value) {
    try {
        (Validators::Validate(obj), ...);
    } catch (const std::exception& e) {
        chaotic::ThrowForValue(e.what(), value);
    }
}
 
}  // namespace chaotic
 
USERVER_NAMESPACE_END