ringbuff.c File Reference

Ring buffer implementation An IO buffer that attempts to minimize moving buffered data around. More...

#include "ctl/ctldef.h"
#include "ctl/debug.h"
#include "ctl/ctlnew.h"
#include "ctl/ringbuff.h"

Include dependency graph for ringbuff.c:

Go to the source code of this file.

Functions
void	RingBuff_Init (RingBuff *self, void *buff, size_t size)
	Initialize a ring buffer with a buffer.
bool	RingBuff_Space (RingBuff *self, uint8 **buff, size_t count)
bool	RingBuff_Peek (RingBuff *self, const uint8 **buff, size_t count)
	Peek at read position.
bool	RingBuff_Consume (RingBuff *self, size_t count)
	Consume bytes we peeked at.
bool	RingBuff_Add (RingBuff *self, uint8 **buff, size_t count)
	Add data to the ring buffer.
bool	RingBuff_Pop (RingBuff *self, const uint8 **buff, size_t count)
	Read data from current read position.
bool	RingBuff_CopyTo (RingBuff *self, const void *buff, size_t count)
	Write data to the buffer.
bool	RingBuff_CopyFrom (RingBuff *self, void *buff, size_t count)
	Read data from the buffer, wrapping it transparently.
bool	RingBuff_AddSerial (RingBuff *self, ctl_serial *serial, size_t reserve)
	Reserve space for serial data in an atomic manner.
bool	RingBuff_PeekSerial (RingBuff *self, ctl_serial *serial)
	Peek at serial packet data on queue.
bool	RingBuff_PopSerial (RingBuff *self, ctl_serial *serial)
	Pop a packet of serial data off the stack.

---

Detailed Description

Ring buffer implementation An IO buffer that attempts to minimize moving buffered data around.

Ring buffer Re-uses the same buffer without moving data around much.

Author:

David Mace

Definition in file ringbuff.c.

---

Function Documentation

bool RingBuff_Add	(	RingBuff *	self,
		uint8 **	buff,
		size_t	count
	)

Add data to the ring buffer.

Parameters:

	self	Pointer to instance of ring buffer
	count	Number of bytes to reserve

Returns:

true on success, false on failure

Definition at line 105 of file ringbuff.c.

References RingBuff_Space().

Referenced by RingBuff_AddSerial().

{
    if( RingBuff_Space( self, buff, count ) )
    {   // Consume free space
        self->tail += count;
        return true;
    }
    return false;
}

Here is the call graph for this function:

bool RingBuff_AddSerial	(	RingBuff *	self,
		ctl_serial *	serial,
		size_t	reserve
	)

Reserve space for serial data in an atomic manner.

Parameters:

	self	Pointer to instance of ring buffer
	serial	Pointer to serial data to be filled in by this
	reserve	Amount of space to reserve in serial data

Returns:

true if there is enough space, false if not Guarantees if enough data is available, the serial packet will be in one piece

Definition at line 182 of file ringbuff.c.

References ctl_serial_init, RingBuff_Add(), and uint16_serial_write().

Referenced by Socket_Alloc_Serial().

{
    uint8* space;
    uint16 size = 2 + reserve;
    if( RingBuff_Add( self, &space, size ) )
    {
        ctl_serial_init( serial, space, space + size );
        uint16_serial_write(&size, serial );
        return true;
    }
    return false;
}

Here is the call graph for this function:

bool RingBuff_Consume	(	RingBuff *	self,
		size_t	count
	)

Consume bytes we peeked at.

Parameters:

	self	Pointer to instance of ring buffer
	count	Number of bytes to get

Returns:

true on success, false on failure

Definition at line 83 of file ringbuff.c.

References assert, and assertobjptr.

{
    assertobjptr(self);
    assert( self->tail >= self->head );
    if( self->head + count > self->tail )
    {
        return false;
    }
    self->head += count;
    if( self->head == self->tail )
    {   // Reset if we use up the data
        RingBuff_Reset(self);
    }
    return true;
}

bool RingBuff_CopyFrom	(	RingBuff *	self,
		void *	buff,
		size_t	count
	)

Read data from the buffer, wrapping it transparently.

Parameters:

	self	Pointer to instance of ring buffer
	buff	Buffer to copy to, or NULL just to consume bytes
	count	Number of bytes to get

Returns:

true on success, false on failure (not enough data)

Definition at line 162 of file ringbuff.c.

References RingBuff_Peek().

{
    const uint8* data;
    if( RingBuff_Peek( self, &data, count ) )
    {   // Consume data
        memcpy(buff,data,count);
        self->head += count;
        return true;
    }
    return false;
}

Here is the call graph for this function:

bool RingBuff_CopyTo	(	RingBuff *	self,
		const void *	buff,
		size_t	count
	)

Write data to the buffer.

Parameters:

	self	Pointer to instance of ring buffer
	buff	Buffer to copy from
	count	Number of bytes to set

Returns:

true on success, false on failure (not enough room)

Definition at line 143 of file ringbuff.c.

References RingBuff_Space().

Referenced by Socket_Write(), and Socket_Write_Serial().

{
    uint8* space;
    if( RingBuff_Space( self, &space, count ) )
    {   // Consume free space
        memcpy(space,buff,count);
        self->tail += count;
        return true;
    }
    return false;
}

Here is the call graph for this function:

void RingBuff_Init	(	RingBuff *	self,
		void *	buff,
		size_t	size
	)

Initialize a ring buffer with a buffer.

Parameters:

	self	Pointer to instance of ring buffer
	buff	Buffer into which we'll be stuffing things
	size	Size of that buffer

Definition at line 20 of file ringbuff.c.

References assertobjptr, and assertptr.

Referenced by Socket_Customize().

{
    assertobjptr(self);
    assertptr(buff,size);
    self->buff = (const uint8*)buff;
    self->end = self->buff + size;
    self->head = self->tail = (uint8*)self->buff;
}

bool RingBuff_Peek	(	RingBuff *	self,
		const uint8 **	buff,
		size_t	count
	)

Peek at read position.

Parameters:

	self	Pointer to instance of ring buffer
	buff	Pointer to variable to receive pointer to data
	count	Number of bytes to get

Returns:

true on success, false on failure (not enough data to return count)

Definition at line 65 of file ringbuff.c.

References assert, and assertobjptr.

Referenced by RingBuff_CopyFrom(), RingBuff_PeekSerial(), RingBuff_Pop(), and RingBuff_PopSerial().

{
    assertobjptr(self);
    assert( self->tail >= self->head );
    if( self->head + count > self->tail )
    {   /* Not enough data left */
        return false;
    }
    *buff = self->head;
    return true;
}

bool RingBuff_PeekSerial	(	RingBuff *	self,
		ctl_serial *	serial
	)

Peek at serial packet data on queue.

Parameters:

	self	Pointer to instance of ring buffer
	serial	Pointer to serial data to be filled in by this

Returns:

true if there is a whole packet to pop Guarantees if enough data is available, the serial packet will be in one piece

Definition at line 202 of file ringbuff.c.

References ctl_serial_init, RingBuff_Peek(), and uint16_serial_read().

{
    const uint8* data;
    if( RingBuff_Peek( self, &data, 2 ) )
    {
        ctl_serial_init( serial, (uint8*)data, data+2 );
        uint16 size;
        uint16_serial_read(&size, serial );
        ctl_serial_init( serial, data, data + size );
        return true;
    }
    return false;
}

Here is the call graph for this function:

bool RingBuff_Pop	(	RingBuff *	self,
		const uint8 **	buff,
		size_t	count
	)

Read data from current read position.

Parameters:

	self	Pointer to instance of ring buffer
	count	Number of bytes to get

Returns:

true on success, false on failure

Definition at line 121 of file ringbuff.c.

References RingBuff_Peek().

Referenced by RingBuff_PopSerial(), and Socket_Raw_Consume().

{
    if( RingBuff_Peek( self, buff, count ) )
    {   // Consume data
        self->head += count;
        if( self->head == self->tail )
        {   // Reset if we use up the data
            RingBuff_Reset(self);
        }
        return true;
    }
    /* Not enough data left */
    return false;
}

Here is the call graph for this function:

bool RingBuff_PopSerial	(	RingBuff *	self,
		ctl_serial *	serial
	)

Pop a packet of serial data off the stack.

Parameters:

	self	Pointer to instance of ring buffer
	serial	Pointer to serial data to be filled in by this

Returns:

true if there is a whole packet to pop Guarantees serial packet will be in one piece

Definition at line 223 of file ringbuff.c.

References ctl_serial_init, ctl_serial::curr, RingBuff_Peek(), RingBuff_Pop(), and uint16_serial_read().

{
    const uint8* data;
    if( RingBuff_Peek( self, &data, 2 ) )
    {
        uint16 size;
        ctl_serial_init( serial, data, data+2 );
        uint16_serial_read(&size, serial );
        /* Pop the packet off, once it's available */
        if( RingBuff_Pop( self, &data, size ) )
        {
            ctl_serial_init( serial, data, data + size );
            /* Parse past length; it can be had by rewinding, but in most cases app won't want it. */
            serial->curr += 2;
            return true;
        }
    }
    return false;
}

Here is the call graph for this function:

bool RingBuff_Space	(	RingBuff *	self,
		uint8 **	buff,
		size_t	count
	)

Get a pointer to free space in ring buffer writeable in one write

Parameters:

	self	Pointer to instance of ring buffer
	buff	Pointer to variable to receive pointer to data
	count	Size of data demanded

Returns:

True on success, false on failure

Definition at line 36 of file ringbuff.c.

References assert, and assertobjconst.

Referenced by RingBuff_Add(), and RingBuff_CopyTo().

{
    assertobjconst(self);
    assert( self->head <= self->tail );
    if( self->tail + count <= self->end )
    {
        *buff = (uint8*)self->tail;
        return true;
    }
    else if( self->head > self->buff && (count <= RingBuff_Free(self) ) )
    {
        size_t used = self->tail - self->head;
        memmove( (uint8*)self->buff, self->head, used );
        self->head = (uint8*)self->buff;
        self->tail = (uint8*)self->buff + used;
        *buff = (uint8*)self->tail;
        return true;
    }
    *buff = NULL;
    return false;
}