command_group.h

Go to the documentation of this file.

 
#pragma once
 
#include "../algorithm.h"
#include "../assert.h"
#include "../types.h"
#include "./traits.h"
 
namespace emlabcpp::protocol
{
 
//
 
//
template < auto ID, convertible... Defs >
struct command
{
        using id_type    = decltype( ID );
        using value_type = std::tuple< tag< ID >, typename proto_traits< Defs >::value_type... >;
        using def_type   = std::tuple< tag< ID >, Defs... >;
 
        static constexpr id_type id = ID;
 
        template < typename... NewDefs >
        using with_args = command< ID, Defs..., NewDefs... >;
 
        constexpr static value_type
        make_val( typename proto_traits< Defs >::value_type const&... args )
        {
                return { tag< ID >{}, args... };
        }
};
 
//
template < std::endian Endianess, typename... Cmds >
struct command_group : converter_def_type_base
{
        using cmds_type = std::tuple< Cmds... >;
 
private:
        static constexpr std::size_t get_id_index( auto id )
        {
                return find_index< sizeof...( Cmds ) >( [id]< std::size_t i >() {
                        return std::tuple_element_t< i, cmds_type >::id == id;
                } );
        }
 
public:
        template < auto ID >
        static constexpr std::size_t id_index = get_id_index( ID );
 
        template < auto ID >
        using cmd_type = std::tuple_element_t< id_index< ID >, cmds_type >;
 
        template < auto ID >
        using cmd_value_type = typename cmd_type< ID >::value_type;
 
        template < typename... SubCmds >
        using with_commands = command_group< Endianess, Cmds..., SubCmds... >;
 
        static_assert(
            are_same_v< typename Cmds::id_type... >,
            "Each command of one group has to use same type of id" );
 
        using def_type   = endianess_wrapper< Endianess, group< typename Cmds::def_type... > >;
        using traits     = proto_traits< def_type >;
        using value_type = typename traits::value_type;
 
        static constexpr std::size_t max_size = proto_traits< def_type >::max_size;
 
        using message_type = message< max_size >;
 
        template < auto id, typename... Args >
        requires( ( id == Cmds::id ) || ... )
        constexpr static value_type make_val( Args const&... args )
        {
                std::optional< value_type > res;
 
                for_each_index< sizeof...( Cmds ) >( [&res, &args...]< std::size_t i >() {
                        using cmd = std::tuple_element_t< i, cmds_type >;
                        if constexpr ( cmd::id == id )
                                res.emplace( cmd::make_val( args... ) );
                } );
 
                EMLABCPP_ASSERT( res );
                return *res;
        }
};
 
template < std::endian Endianess >
struct command_group< Endianess >
{
        template < typename... Cmds >
        using with_commands = command_group< Endianess, Cmds... >;
};
 
}  // namespace emlabcpp::protocol