fixed_size.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <restinio/async_chain/common.hpp>
 
#include <array>
 
namespace restinio::async_chain
{

template<
    std::size_t Size,
    typename Extra_Data_Factory = no_extra_data_factory_t >
class fixed_size_chain_t
{
    using unique_controller_t = unique_async_handling_controller_t< Extra_Data_Factory >;

    using scheduler_holder_t = generic_async_request_scheduler_t< Extra_Data_Factory >;

    using schedulers_array_t = std::array< scheduler_holder_t, Size >;

    using actual_request_handle_t =
            typename async_handling_controller_t< Extra_Data_Factory >::actual_request_handle_t;

    using actual_on_next_result_t =
            typename async_handling_controller_t< Extra_Data_Factory >::actual_on_next_result_t;

    class actual_controller_t final
        : public async_handling_controller_t< Extra_Data_Factory >
    {
        const actual_request_handle_t m_request;
        schedulers_array_t m_schedulers;

        std::size_t m_current{};
 
    public:
        explicit actual_controller_t(
            actual_request_handle_t request,
            const schedulers_array_t & schedulers )
            :   m_request{ request }
            ,   m_schedulers{ schedulers }
        {}
 
        [[nodiscard]]
        const actual_request_handle_t &
        request_handle() const noexcept override { return m_request; }
 
    private:
        [[nodiscard]]
        actual_on_next_result_t
        on_next() override
        {
            const auto index_to_use = m_current;
            ++m_current;
 
            if( index_to_use >= m_schedulers.size() )
            {
                return { no_more_schedulers_t{} };
            }
            else
            {
                return { m_schedulers[ index_to_use ] };
            }
        }
    };


    schedulers_array_t m_schedulers;

    template<
        typename Head,
        typename... Tail >
    void
    store_to( std::size_t index, Head && head, Tail && ...tail )
    {
        m_schedulers[ index ] =
            [scheduler = std::move(head)]
            ( unique_controller_t controller ) -> schedule_result_t
            {
                return scheduler( std::move(controller) );
            };
 
        if constexpr( 0u != sizeof...(tail) )
            store_to( index + 1u, std::forward<Tail>(tail)... );
    }
 
public:
    fixed_size_chain_t() = delete;

    template< typename... Schedulers >
    fixed_size_chain_t( Schedulers && ...schedulers )
    {
        static_assert( Size == sizeof...(schedulers),
                "Wrong number of parameters for the constructor of "
                "fixed_size_chain_t<Size>. Exact `Size` parameters expected" );
 
        store_to( 0u, std::forward<Schedulers>(schedulers)... );
    }

    [[nodiscard]]
    request_handling_status_t
    operator()( const actual_request_handle_t & req ) const
    {
        unique_controller_t controller =
                std::make_unique< actual_controller_t >(
                        req,
                        m_schedulers );
        next( std::move(controller) );
 
        return request_accepted();
    }
};
 
} /* namespace restinio::async_chain */