packet.h

Go to the documentation of this file.

 
#pragma once
 
#include "./sequencer.h"
#include "./serializer.h"
#include "./tuple.h"
 
namespace emlabcpp::protocol
{
 
template < typename T >
concept packet_def = requires( T t ) {
        { T::endianess } -> std::convertible_to< std::endian >;
        is_std_array_v< std::decay_t< decltype( T::prefix ) > >;
        requires convertible< typename T::size_type >;
        requires convertible< typename T::checksum_type >;
};
 
template < typename Def, typename Payload >
using packet_base = tuple<
    Def::endianess,
    std::decay_t< decltype( Def::prefix ) >,
    sized_buffer< typename Def::size_type, Payload >,
    typename Def::checksum_type >;
 
template < packet_def Def, typename Payload >
struct packet : packet_base< Def, Payload >
{
        using payload_type = Payload;
        using base         = packet_base< Def, Payload >;
 
        static constexpr auto prefix    = Def::prefix;
        static constexpr auto endianess = Def::endianess;
 
        using prefix_type                        = std::decay_t< decltype( prefix ) >;
        using prefix_traits                      = proto_traits< prefix_type >;
        static constexpr std::size_t prefix_size = prefix_traits::max_size;
 
        using size_type                        = typename Def::size_type;
        using size_traits                      = proto_traits< size_type >;
        static constexpr std::size_t size_size = size_traits::max_size;
 
        using payload_traits = proto_traits< Payload >;
        using value_type     = typename payload_traits::value_type;
 
        using checksum_type   = typename Def::checksum_type;
        using checksum_traits = proto_traits< checksum_type >;
 
        static_assert( fixedly_sized< size_type > );
 
        struct sequencer_def
        {
                using message_type    = typename base::message_type;
                using serializer_type = serializer< size_type, endianess >;
 
                static constexpr auto        prefix     = Def::prefix;
                static constexpr std::size_t fixed_size = prefix_size + size_size;
 
                static constexpr std::size_t get_size( auto const& buffer )
                {
                        std::array< std::byte, size_size > tmp;
 
                        auto iter = std::begin( buffer );
                        std::advance( iter, prefix_size );
                        std::copy_n( iter, size_size, tmp.begin() );
                        return serializer_type::deserialize( tmp ) + fixed_size +
                               checksum_traits::max_size;
                }
        };
 
        using sequencer_type = sequencer< sequencer_def >;
 
        static constexpr checksum_type get_checksum( view< std::byte const* > const mview )
        {
                return Def::get_checksum( mview );
        }
};
 
}  // namespace emlabcpp::protocol