buffer.hpp

#ifndef BLUETOE_LINK_LAYER_BUFFER_HPP
#define BLUETOE_LINK_LAYER_BUFFER_HPP
 
#include <cstdlib>
#include <cstdint>
#include <cassert>
#include <initializer_list>
#include <algorithm>
 
namespace bluetoe {
namespace link_layer {
 
    struct read_buffer
    {
        std::uint8_t*   buffer;
 
        std::size_t     size;
 
        bool empty() const
        {
            return buffer == nullptr && size == 0;
        }
 
        void fill( std::initializer_list< std::uint8_t > data )
        {
            assert( data.size() <= size );
            std::copy( data.begin(), data.end(), buffer );
        }
    };
 
    template < class Layout >
    void fill( const read_buffer& buffer, std::initializer_list< std::uint8_t > data )
    {
        if ( data.size() >= 1 )
        {
            std::uint16_t header = *data.begin();
 
            if ( data.size() >= 2 )
                header |= *std::next( data.begin() ) << 8;
 
            Layout::header( buffer, header );
 
            if ( data.size() >= 3 )
            {
                std::uint8_t* body = Layout::body( buffer ).first;
                std::copy( std::next( data.begin(), 2 ), std::end( data ), body );
            }
        }
    }
 
    struct write_buffer
    {
        const std::uint8_t* buffer;
 
        std::size_t         size;
 
        bool empty() const
        {
            return buffer == nullptr && size == 0;
        }
 
        explicit write_buffer( const read_buffer& rhs )
            : buffer( rhs.buffer )
            , size( rhs.size )
        {}
 
        write_buffer()
            : buffer( nullptr )
            , size( 0 )
        {
        }
 
        write_buffer( const std::uint8_t* b, std::size_t s )
            : buffer( b )
            , size( s )
        {
        }
    };
}
}
 
#endif