Concepts.hpp

#pragma once
 
#include "rpc/Errors.hpp"
#include "rpc/common/SpecBackend.hpp"
#include "rpc/common/Types.hpp"
 
#include <boost/json/value.hpp>
#include <boost/json/value_from.hpp>
#include <boost/json/value_to.hpp>
#include <rpcspec/Errors.hpp>
 
#include <concepts>
#include <cstdint>
#include <expected>
#include <optional>
#include <string>
 
namespace rpc {

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

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

template <typename T>
concept SomeHandlerWithTypedInput = requires(uint32_t version, boost::json::value jv) {
    typename T::Input;
    { T::parseInput(jv, version) } -> std::same_as<std::expected<typename T::Input, Status>>;
    { T::spec(version) } -> std::same_as<SpecView>;
} and SomeContextProcessWithInput<T>;

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

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