ring_buffer.hpp

#ifndef BLUETOE_LINK_LAYER_RING_BUFFER_HPP
#define BLUETOE_LINK_LAYER_RING_BUFFER_HPP
 
#include <cstdint>
#include <cassert>
#include <cstdlib>
 
#include <bluetoe/buffer.hpp>
#include <bluetoe/default_pdu_layout.hpp>
 
namespace bluetoe {
namespace link_layer {
 
    template < std::size_t Size, typename Buffer = read_buffer, typename Layout = default_pdu_layout >
    class pdu_ring_buffer
    {
    public:
        static constexpr std::size_t size = Size;
 
        explicit pdu_ring_buffer( std::uint8_t* buffer );
 
        void reset( std::uint8_t* buffer );
 
        Buffer alloc_front( std::uint8_t* buffer, std::size_t size ) const;
 
        void push_front( std::uint8_t* buffer, const Buffer& pdu );
 
        Buffer next_end() const;
 
        void pop_end( std::uint8_t* buffer );
 
        bool more_than_one() const;
 
    private:
        static constexpr std::size_t    ll_header_size = 2;
        static constexpr std::uint16_t  wrap_mark = 0;
 
        template < class P >
        static std::uint8_t pdu_length( const P& pdu );
 
        template < typename P >
        static std::size_t pdu_length( P* );
 
        // 1) if end_ == front_, the ring is empty
        //        end_ and front_ can point to everywhere into the buffer
        // 2) if front_ > end_, the all elements are between front_ and end_
        // 3) if end_ > front_, -> buffer splited
        //        there are elements from front_ to the end of the buffer
        //        and there are elements from the beginning of the buffer till end_
        std::uint8_t* end_;
        std::uint8_t* front_;
    };
 
    template < std::size_t Size, typename Buffer, typename Layout >
    pdu_ring_buffer< Size, Buffer, Layout >::pdu_ring_buffer( std::uint8_t* buffer )
    {
        reset( buffer );
    }
 
    template < std::size_t Size, typename Buffer, typename Layout >
    void pdu_ring_buffer< Size, Buffer, Layout >::reset( std::uint8_t* buffer )
    {
        assert( buffer );
        front_ = buffer;
        end_   = buffer;
 
        Layout::header( buffer, wrap_mark );
    }
 
    template < std::size_t Size, typename Buffer, typename Layout >
    Buffer pdu_ring_buffer< Size, Buffer, Layout >::alloc_front( std::uint8_t* buffer, std::size_t size ) const
    {
        assert( buffer );
        assert( size >= Layout::data_channel_pdu_memory_size( 0 ) );
 
        // buffer splited? There must be one byte left to not overflow the ring.
        if ( end_ > front_ && static_cast< std::ptrdiff_t >( size ) < end_ - front_ )
        {
            return Buffer{ front_, size };
        }
 
        if ( front_ >= end_ )
        {
            const std::uint8_t* end_of_buffer = buffer + Size;
 
            // allocate at the end?
            if ( static_cast< std::ptrdiff_t >( size ) <= end_of_buffer - front_ )
            {
                return Buffer{ front_, size };
            }
 
            // allocate at the begining? Again, there must be one byte left between the end front_ and the end_
            if ( static_cast< std::ptrdiff_t >( size ) < end_ - buffer )
            {
                return Buffer{ buffer, size };
            }
        }
 
        return Buffer{ 0, 0 };
    }
 
    template < std::size_t Size, typename Buffer, typename Layout >
    void pdu_ring_buffer< Size, Buffer, Layout >::push_front( std::uint8_t* buffer, const Buffer& pdu )
    {
        assert( pdu.size >= pdu_length( pdu ) );
 
        const std::uint8_t* end_of_buffer = buffer + Size;
 
        // set size to 0 to mark force the end_ pointer to wrap here
        if ( front_ != pdu.buffer && front_ + 1 < end_of_buffer )
        {
            Layout::header( front_, wrap_mark );
        }
 
        const bool was_empty = front_ == end_;
 
        front_ = pdu.buffer + pdu_length( pdu );
 
        // if the ring was empty, the end_ ptr have to wrap too now
        if ( was_empty )
            end_ = pdu.buffer;
    }
 
    template < std::size_t Size, typename Buffer, typename Layout >
    Buffer pdu_ring_buffer< Size, Buffer, Layout >::next_end() const
    {
        return front_ == end_
            ? Buffer{ 0, 0 }
            : Buffer{ end_, pdu_length( end_ ) };
    }
 
    template < std::size_t Size, typename Buffer, typename Layout >
    void pdu_ring_buffer< Size, Buffer, Layout >::pop_end( std::uint8_t* buffer )
    {
        end_ += pdu_length( end_ );
 
        const std::uint8_t* end_of_buffer = buffer + Size;
 
        // wrap the end_ pointer to the beginning, if the buffer is not empty
        if ( end_ != front_ && ( end_ + 1 >= end_of_buffer || end_[ 1 ] == wrap_mark ) )
            end_ = buffer;
    }
 
    template < std::size_t Size, typename Buffer, typename Layout >
    template < class P >
    std::uint8_t pdu_ring_buffer< Size, Buffer, Layout >::pdu_length( const P& pdu )
    {
        return pdu_length( pdu.buffer );
    }
 
    template < std::size_t Size, typename Buffer, typename Layout >
    template < typename P >
    std::size_t pdu_ring_buffer< Size, Buffer, Layout >::pdu_length( P* p )
    {
        return Layout::data_channel_pdu_memory_size( Layout::header( p ) >> 8 );
    }
 
    template < std::size_t Size, typename Buffer, typename Layout >
    bool pdu_ring_buffer< Size, Buffer, Layout >::more_than_one() const
    {
        return end_ != front_ && ( end_ + pdu_length( end_) ) != front_;
    }
 
}
}
 
#endif