RingBuffer.cpp

Go to the documentation of this file.

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// Project: uLib - User mode library.
// Module: RingBuffer -- A simple circular FIFO data buffer.
// Author: Copyright (c) Love Nystrom
// License: NNOSL (BSD descendant, see NNOSL.txt in the base directory).
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

#include <uLib\RingBuffer.h>
#include <uLib\MemFunc.h>
#include <uLib\Debug.h>
#include <memory.h>

#define RINGBUF_BURST_XFER  1

RingBuffer::RingBuffer( PBYTE Array, UINT Size )
{
    UserData = NULL;
    Attach( Array, Size );
    _dyna = false;
}

RingBuffer::RingBuffer( UINT Size )
{
    UserData = NULL;
    PBYTE buf = (PBYTE) mem_Alloc( Size );
    _dyna = (buf != NULL);
    if (!_dyna) Size = 0;
    Attach( buf, Size );
}

RingBuffer::~RingBuffer()
{
    if (_dyna) mem_Free( _buffer );
}

void RingBuffer::Attach( PBYTE Array, UINT Size )
{
    _buffer = Array;
    _size = Size;
    _head = _tail = 0; // _head == _tail means the buffer is *empty OR full*!
    _full = false;
}

bool RingBuffer::Get( BYTE* Data )
{
    bool ok = !Empty();
    if ( ok )
    {
        *Data = *(_buffer + _tail);
        if (++_tail >= _size) _tail = 0;
        _full = false;
    }
    return ok;
}

bool RingBuffer::Put( BYTE Data )
{
    bool ok = !_full;
    if ( ok )
    {
        *(_buffer + _head) = Data;
        if (++_head >= _size) _head = 0;
        if (_head == _tail) _full = true;
    }
    return ok;
}

#if !RINGBUF_BURST_XFER // One by one slug transfer...

bool RingBuffer::PutBlock( BYTE* Data, UINT Count )
{
    bool ok = (Unused() >= Count);
    if (ok) {
        while( Count-- ) Put( *Data++ );
    }
    return ok;
}

bool RingBuffer::GetBlock( BYTE* Data, UINT Count )
{
    bool ok = (Used() >= Count); // Enough stored ?
    if ( ok )
    {
        while( Count-- ) Get( Data++ );
    }
    return ok;
}

#else // Burst transfer - Beta

bool RingBuffer::PutBlock( BYTE* Data, UINT Count )
{
    bool ok = (Unused() >= Count);
    if ( ok )
    {
        if (_head + Count <= _size) // One burst
        {
            memcpy( _buffer + _head, Data, Count );
           _head += Count;
        }
        else // Split insertion in two bursts
        {
            UINT nfirst = _size - _head;
            UINT nsecond = Count - nfirst;
            if ( nfirst )  memcpy( _buffer + _head, Data, nfirst );
            if ( nsecond ) memcpy( _buffer, Data + nfirst, nsecond );
           _head = nsecond;
        }
        IF_DEBUG( if (_head > _size) __debugbreak() );
        if (_head == _size) _head = 0;
        int diff = _head - _tail; // Check if buffer is full..
        if (diff < 0) diff += _size; // unwrap..
        if (!diff || (diff == (int)_size)) _full = true;
    }
    return ok;
}

bool RingBuffer::GetBlock( BYTE* Data, UINT Count )
{
    bool ok = (Used() >= Count); // Enough stored ?
    if ( ok )
    {
        if (_tail + Count <= _size) // One burst
        {
            memcpy( Data, _buffer + _tail, Count );
           _tail += Count;
        }
        else // Split withdrawal in two bursts
        {
            UINT nfirst = _size - _tail;
            UINT nsecond = Count - nfirst;
            if ( nfirst )  memcpy( Data, _buffer + _tail, nfirst );
            if ( nsecond ) memcpy( Data + nfirst, _buffer, nsecond );
           _tail = nsecond;
        }
        IF_DEBUG( if (_tail > _size) __debugbreak() );
        if (_tail == _size) _tail = 0;
        _full = false;
    }
    return ok;
}

#endif // RINGBUF_BURST_XFER

bool RingBuffer::GetStr( ASTR Buf, UINT BufSize )
{
    UINT strLen = 0;
    UINT start = _tail;
    UINT offs = _tail;
    while( *(_buffer + offs) != 0 )
    {
        strLen++;
        if (++offs >= _size) offs = 0;
        if (offs == start) return false; // No NUL terminator found.
    }
    strLen++; // Include NUL terminator
    bool ok = (BufSize >= strLen);
    if (ok) GetBlock( (PBYTE)Buf, strLen );
    else
    {
        ok = GetBlock( (PBYTE)Buf, BufSize-1 );
        Buf[ BufSize-1 ] = 0; // NUL terminate clipped string.
        TRACE( DP_WARNING, _F("Clipping: strLen=%lu, BufSize=%lu\n"), strLen, BufSize );
        Discard( strLen-BufSize );
    }
    return ok;
}

bool RingBuffer::PutStr( ACSTR Str, UINT StrLen )
{
    bool counted = (StrLen != 0);
    if (!counted) StrLen = (UINT) strlen( Str );
    bool ok = (Unused() > StrLen);
    if (ok)
    {
        UINT length = counted ? StrLen : StrLen+1;
        PutBlock( (PBYTE)Str, length );
        if (counted && (Str[ length-1 ] != 0)) Put( 0 ); // Add NUL terminator
    }
    return ok;
}

void RingBuffer::Clear()
{
    _full = false;
    _head = _tail = 0;
}

void RingBuffer::Discard( UINT Count )
{
    if ( Count )
    {
        UINT avail = Used(); // Stored amount
        if (Count >= avail) Clear();
        else
        {
            _tail += Count;
            _tail %= _size;
            _full = false;
        }
    }
}

UINT RingBuffer::Used()
{
    if ( _full ) return _size;
    INT count = _head - _tail;
    if (count < 0) count += _size;
    return count;
}

UINT RingBuffer::Unused()
{
    return _size - Used();
}

bool RingBuffer::Empty()
{
    return ((_tail == _head) && !_full);
}

BYTE& RingBuffer::operator[]( UINT Index )
{
    if (Empty() || Index >= Used()) // If Index out of bounds..
    {
      #if 0
        RaiseException( EXCEPTION_ARRAY_BOUNDS_EXCEEDED, 0, 0, NULL ); // Generic
      #else
        ULONG_PTR info[ 2 ] = { (ULONG_PTR) this, Index }; // Just because we can.. ;)
        RaiseException( EXCEPTION_RINGBUFFER_INVALID_INDEX, 0, 2, info ); // Specific
      #endif
    }
    Index += _tail;
    Index %= _size;
    return _buffer[ Index ];
}

// EOF