message.h

Go to the documentation of this file.

 
#pragma once
 
#include "../concepts.h"
#include "../view.h"
 
#ifdef EMLABCPP_USE_NLOHMANN_JSON
#include <nlohmann/json.hpp>
#endif
 
namespace emlabcpp::protocol
{
 
template < std::size_t N >
class message
{
public:
        using value_type     = std::byte;
        using reference      = std::byte&;
        using pointer        = std::byte*;
        using const_pointer  = std::byte const*;
        using iterator       = std::byte*;
        using const_iterator = std::byte const*;
        using size_type      = std::size_t;
 
        static constexpr size_type capacity = N;
 
        constexpr message() = default;
 
        constexpr explicit message( size_type const n ) noexcept
          : used_( n )
        {
        }
 
        constexpr explicit message( view< const_iterator > const& v ) noexcept
          : used_( v.size() )
        {
                std::copy( v.begin(), v.end(), std::data( data_ ) );
        }
 
        template < size_type M >
        constexpr explicit message( message< M > const& other ) noexcept
          : message( view{ other } )
        {
                static_assert( M <= N );
        }
 
        template < size_type M >
        constexpr explicit message( std::array< value_type, M > const& inpt ) noexcept
          : message( view{ inpt } )
        {
                static_assert( M <= N );
        }
 
        template < std::convertible_to< uint8_t >... Ts >
        constexpr explicit message( Ts... inpt )
          : data_{ static_cast< value_type >( inpt )... }
          , used_( sizeof...( Ts ) )
        {
        }
 
        template < size_type M >
        constexpr message& operator=( message< M > const& other ) noexcept
        {
                used_ = other.size();
                std::copy( other.begin(), other.end(), std::data( data_ ) );
                return *this;
        }
 
        [[nodiscard]] constexpr const_pointer data() const noexcept
        {
                return &data_[0];
        }
 
        [[nodiscard]] constexpr pointer data() noexcept
        {
                return &data_[0];
        }
 
        [[nodiscard]] constexpr size_type size() const noexcept
        {
                return used_;
        }
 
        [[nodiscard]] constexpr value_type front() const noexcept
        {
                return data_[0];
        }
 
        [[nodiscard]] constexpr reference front() noexcept
        {
                return data_[0];
        }
 
        [[nodiscard]] constexpr value_type back() const noexcept
        {
                return data_[used_ - 1];
        }
 
        [[nodiscard]] constexpr reference back() noexcept
        {
                return data_[used_ - 1];
        }
 
        [[nodiscard]] constexpr const_iterator begin() const noexcept
        {
                return &data_[0];
        }
 
        [[nodiscard]] constexpr iterator begin() noexcept
        {
                return &data_[0];
        }
 
        [[nodiscard]] constexpr const_iterator end() const noexcept
        {
                return &data_[0] + used_;
        }
 
        [[nodiscard]] constexpr iterator end() noexcept
        {
                return &data_[0] + used_;
        }
 
        value_type operator[]( size_type const i ) const noexcept
        {
                return data_[i];
        }
 
        reference operator[]( size_type const i ) noexcept
        {
                return data_[i];
        }
 
        void resize( size_type const n ) noexcept
        {
                used_ = n;
        }
 
        friend auto operator==( message const& lh, message const& rh ) noexcept
        {
                return view_n( lh.begin(), lh.used_ ) == view_n( rh.begin(), rh.used_ );
        }
 
private:
        std::byte data_[N];
        size_type used_ = { 0 };
};
 
template < std::convertible_to< uint8_t >... Ts >
message( Ts... inpt ) -> message< sizeof...( Ts ) >;
 
template < std::size_t N >
class sizeless_message : public message< N >
{
public:
        using message< N >::message;
 
        template < std::size_t M >
        explicit sizeless_message( message< M > const& other )
          : message< N >( other )
        {
                static_assert( M <= N );
        }
};
 
template < std::convertible_to< uint8_t >... Ts >
sizeless_message( Ts... inpt ) -> sizeless_message< sizeof...( Ts ) >;
 
namespace detail
{
        template < std::size_t N >
        constexpr bool message_derived_test( message< N > const& )
        {
                return true;
        }
}  // namespace detail
 
template < typename T >
concept message_derived = requires( T val ) { detail::message_derived_test( val ); };
 
#ifdef EMLABCPP_USE_NLOHMANN_JSON
 
template < std::size_t N >
void to_json( nlohmann::json& j, message< N > const& msg )
{
        j = nlohmann::json::array();
        for ( std::byte b : msg )
                j.push_back( b );
}
 
template < std::size_t N >
void from_json( nlohmann::json const& j, message< N >& msg )
{
        if ( j.size() > N )
                throw std::exception{};  // TODO: fix this
 
        std::vector< std::byte > tmp;
        for ( std::byte const b : j )
                tmp.push_back( b );
 
        msg = message< N >{ view< std::byte const* >( tmp ) };
}
 
#endif
 
}  // namespace emlabcpp::protocol