Concepts.hpp

#pragma once
 
#include "rpc/Errors.hpp"
#include "rpc/common/Checkers.hpp"
#include "rpc/common/Types.hpp"
 
#include <boost/json/value.hpp>
#include <boost/json/value_from.hpp>
#include <boost/json/value_to.hpp>
 
#include <cstdint>
#include <optional>
#include <string>
 
namespace rpc {
 
struct RpcSpec;

template <typename T>
concept SomeRequirement = requires(T a, boost::json::value lval) {
    { a.verify(lval, std::string{}) } -> std::same_as<MaybeError>;
};

template <typename T>
concept SomeModifier = requires(T a, boost::json::value lval) {
    { a.modify(lval, std::string{}) } -> std::same_as<MaybeError>;
};

template <typename T>
concept SomeCheck = requires(T a, boost::json::value lval) {
    { a.check(lval, std::string{}) } -> std::same_as<std::optional<check::Warning>>;
};

template <typename T>
concept SomeProcessor = (SomeRequirement<T> or SomeModifier<T>);

template <typename T>
concept SomeContextProcessWithInput =
    requires(T a, typename T::Input const& in, typename T::Output out, Context const& ctx) {
        { a.process(in, ctx) } -> std::same_as<HandlerReturnType<decltype(out)>>;
    };

template <typename T>
concept SomeContextProcessWithoutInput = requires(T a, typename T::Output out, Context const& ctx) {
    { a.process(ctx) } -> std::same_as<HandlerReturnType<decltype(out)>>;
};

template <typename T>
concept SomeHandlerWithInput = requires(T a, uint32_t version) {
    { a.spec(version) } -> std::same_as<RpcSpec const&>;
} and SomeContextProcessWithInput<T> and boost::json::has_value_to<typename T::Input>::value;

template <typename T>
concept SomeHandlerWithoutInput = SomeContextProcessWithoutInput<T>;

template <typename T>
concept SomeHandler = (SomeHandlerWithInput<T> or SomeHandlerWithoutInput<T>) and
    boost::json::has_value_from<typename T::Output>::value;
 
}  // namespace rpc