request_handler.hpp

Go to the documentation of this file.

/*
    restinio
*/

 
#pragma once
 
#include <restinio/compiler_features.hpp>
 
#include <restinio/exception.hpp>
#include <restinio/http_headers.hpp>
#include <restinio/message_builders.hpp>
#include <restinio/chunked_input_info.hpp>
#include <restinio/impl/connection_base.hpp>
 
#include <array>
#include <functional>
#include <iosfwd>
#include <new>
 
namespace restinio
{
 
//
// extra_data_buffer_t
//
template< typename Extra_Data >
class extra_data_buffer_t
{
    void * m_buffer;
 
public:
    extra_data_buffer_t( void * buffer ) : m_buffer{ buffer } {}
 
    [[nodiscard]]
    void *
    get() const noexcept { return m_buffer; }
};
 
//
// no_extra_data_factory_t
//
struct no_extra_data_factory_t
{
    struct data_t {};
 
    void
    make_within( extra_data_buffer_t<data_t> buffer ) noexcept
    {
        new(buffer.get()) data_t{};
    }
};
 
//
// simple_extra_data_factory_t
//
template< typename Extra_Data >
struct simple_extra_data_factory_t
{
    using data_t = Extra_Data;
 
    void
    make_within( extra_data_buffer_t<data_t> buffer )
        noexcept( noexcept(new(buffer.get()) data_t{}) )
    {
        new(buffer.get()) data_t{};
    }
};
 
template< typename Extra_Data >
class generic_request_t;
 
namespace impl
{
 
template< typename Extra_Data >
connection_handle_t &
access_req_connection( generic_request_t<Extra_Data> & ) noexcept;
 
//
// generic_request_extra_data_holder_t
//
template< typename Extra_Data >
class generic_request_extra_data_holder_t
{
    alignas(Extra_Data) std::array<char, sizeof(Extra_Data)> m_data;
 
public:
    template< typename Factory >
    generic_request_extra_data_holder_t(
        Factory & factory )
    {
        factory.make_within( extra_data_buffer_t<Extra_Data>{ m_data.data() } );
    }
 
    ~generic_request_extra_data_holder_t() noexcept
    {
        get_ptr()->~Extra_Data();
    }
 
    [[nodiscard]]
    Extra_Data *
    get_ptr() noexcept
    {
        // Because the content of m_data.data() is rewritten by
        // placement new we have to use std::launder to avoid UB.
        return std::launder(
                reinterpret_cast<Extra_Data *>(m_data.data()) );
    }
 
    [[nodiscard]]
    const Extra_Data *
    get_ptr() const noexcept
    {
        // Because the content of m_data.data() is rewritten by
        // placement new we have to use std::launder to avoid UB.
        return std::launder(
                reinterpret_cast<const Extra_Data *>(m_data.data()) );
    }
};
 
} /* namespace impl */
 
//
// generic_request_t
//


template< typename Extra_Data >
class generic_request_t final
    :   public std::enable_shared_from_this< generic_request_t< Extra_Data > >
{
    template< typename UD >
    friend impl::connection_handle_t &
    impl::access_req_connection( generic_request_t<UD> & ) noexcept;
 
    public:

        template< typename Extra_Data_Factory >
        generic_request_t(
            request_id_t request_id,
            http_request_header_t header,
            std::string body,
            impl::connection_handle_t connection,
            endpoint_t remote_endpoint,
            Extra_Data_Factory & extra_data_factory )
            :   generic_request_t{
                    request_id,
                    std::move( header ),
                    std::move( body ),
                    chunked_input_info_unique_ptr_t{},
                    std::move( connection ),
                    std::move( remote_endpoint ),
                    extra_data_factory
                }
        {}


        template< typename Extra_Data_Factory >
        generic_request_t(
            request_id_t request_id,
            http_request_header_t header,
            std::string body,
            chunked_input_info_unique_ptr_t chunked_input_info,
            impl::connection_handle_t connection,
            endpoint_t remote_endpoint,
            Extra_Data_Factory & extra_data_factory )
            :   m_request_id{ request_id }
            ,   m_header{ std::move( header ) }
            ,   m_body{ std::move( body ) }
            ,   m_chunked_input_info{ std::move( chunked_input_info ) }
            ,   m_connection{ std::move( connection ) }
            ,   m_connection_id{ m_connection->connection_id() }
            ,   m_remote_endpoint{ std::move( remote_endpoint ) }
            ,   m_extra_data_holder{ extra_data_factory }
        {}

        const http_request_header_t &
        header() const noexcept
        {
            return m_header;
        }

        const std::string &
        body() const noexcept
        {
            return m_body;
        }
 
        template < typename Output = restinio_controlled_output_t >
        auto
        create_response( http_status_line_t status_line = status_ok() )
        {
            check_connection();
 
            return response_builder_t< Output >{
                status_line,
                std::move( m_connection ),
                m_request_id,
                m_header.should_keep_alive() };
        }

        auto request_id() const noexcept { return m_request_id; }

        connection_id_t connection_id() const noexcept { return m_connection_id; }

        const endpoint_t & remote_endpoint() const noexcept { return m_remote_endpoint; }


        nullable_pointer_t< const chunked_input_info_t >
        chunked_input_info() const noexcept
        {
            return m_chunked_input_info.get();
        }

        [[nodiscard]]
        Extra_Data &
        extra_data() noexcept
        {
            return *m_extra_data_holder.get_ptr();
        }

        [[nodiscard]]
        const Extra_Data &
        extra_data() const noexcept
        {
            return *m_extra_data_holder.get_ptr();
        }
 
    private:
        void
        check_connection()
        {
            if( !m_connection )
            {
                throw exception_t{ "connection already moved" };
            }
        }
 
        const request_id_t m_request_id;
        const http_request_header_t m_header;
        const std::string m_body;


        const chunked_input_info_unique_ptr_t m_chunked_input_info;
 
        impl::connection_handle_t m_connection;
        const connection_id_t m_connection_id;

        const endpoint_t m_remote_endpoint;

        impl::generic_request_extra_data_holder_t< Extra_Data > m_extra_data_holder;
};
 
template< typename Extra_Data >
std::ostream &
operator<<(
    std::ostream & o,
    const generic_request_t< Extra_Data > & req )
{
    o << "{req_id: " << req.request_id() << ", "
        "conn_id: " << req.connection_id() << ", "
        "path: " << req.header().path() << ", "
        "query: " << req.header().query() << "}";
 
    return o;
}

template< typename Extra_Data >
using generic_request_handle_t =
        std::shared_ptr< generic_request_t< Extra_Data > >;


using request_t = generic_request_t< no_extra_data_factory_t::data_t >;


using request_handle_t = std::shared_ptr< request_t >;
 
//
// default_request_handler_t
//
 
using default_request_handler_t =
        std::function< request_handling_status_t ( request_handle_t ) >;
 
namespace impl
{
 
template< typename Extra_Data >
connection_handle_t &
access_req_connection( generic_request_t<Extra_Data> & req ) noexcept
{
    return req.m_connection;
}
 
} /* namespace impl */
 
 
} /* namespace restinio */