type_traits.hpp

#pragma once
 
#include <concepts> 
#include <variant>
 
#include "../../core/type_traits.hpp"
 
namespace malloy::server::concepts
{
    namespace detail
    {
        template<typename T>
        concept route_handler_retr =
            malloy::concepts::is_container_of<T, malloy::http::response, std::variant> ||
            malloy::concepts::is<T, malloy::http::response>;
 
        template<typename Func, typename... Args>
        concept route_handler_helper =
            std::invocable<Func, Args...> &&
            requires(Func f, Args... args) {
                { std::invoke(f, args...) } -> route_handler_retr;
        };
    }
 
    template<typename F, typename Req>
    concept route_handler =
        detail::route_handler_helper<F, const Req&> ||
        detail::route_handler_helper<F, const Req&, const std::vector<std::string>>;
 
    template<typename Func>
    concept websocket_handler = std::invocable <Func, const malloy::http::request_header<>&, const std::shared_ptr<websocket::connection>&>;
 
    template<typename H>
    concept request_filter =
        std::move_constructible<H> &&
        requires(const H& f, const typename H::request_type::header_type& h, typename H::request_type::body_type::value_type& v)
    {
        { f.setup_body(h, v) };
    };
 
    template<typename P>
    concept request_validator = requires(P p, const boost::beast::http::request_header<>& h) {
        { std::invoke(p, h) } -> malloy::concepts::is_container_of<malloy::http::response, std::optional>;
    };
 
} // namespace malloy::server::concepts