type_traits.hpp

#pragma once
 
#include "../core/http/response.hpp"
#include "../core/http/type_traits.hpp"
#include "../core/type_traits.hpp"
 
#include <concepts>
#include <variant>
 
namespace malloy::client::concepts
{
 
    namespace detail
    {
 
        template<typename F>
        struct response_filter_body_helper
        {
            template<malloy::http::concepts::body T>
            void operator()(T&&)
            {
                F f2;
                typename F::header_type h2;
                typename std::decay_t<T>::value_type r;
                f2.setup_body(h2, r);
            }
        };

        template<typename Callback>
        struct http_cb_helper
        {
            Callback cb;
 
            template<typename V>
            void operator()(V&&)
            {
                using body_t = std::decay_t<V>;
                malloy::http::response<body_t> res;
 
                cb(std::move(res));
            }
        
        };
    
    }   // namespace detail
 
    template<typename F>
    concept response_filter = std::move_constructible<F> && requires(const F& f, const typename F::header_type& h)
    {
        {
            f.body_for(h)
        } -> malloy::concepts::is_variant_of_bodies;
 
        {
            std::visit(detail::response_filter_body_helper<F>{}, f.body_for(h))
        };
    };
 
    template<typename F, typename Filter>
    concept http_callback = response_filter<Filter>&& std::move_constructible<F>&& requires(F cb, const Filter& f, const typename Filter::header_type& h)
    {
        std::visit(detail::http_cb_helper<F>{std::move(cb)}, f.body_for(h));
    };
 
}