Added a basic ringbuffer, it should be nice and quick, but may be bad to use

with objects at the moment, still contemplating that one...

4 files changed, 141 insertions, 10 deletions

diff --git a/src/list.h b/src/list.h
index 6081ea5..ea67f45 100644
--- a/src/list.h
+++ b/src/list.h
@@ -69,10 +69,10 @@ namespace Bu
                         {
                                 if( pCur == NULL ) break;
                                 va.destroy( pCur->pValue );
-                                va.deallocate( pCur->pValue, sizeof( value ) );
+                                va.deallocate( pCur->pValue, 1 );
                                 Link *pTmp = pCur->pNext;
                                 la.destroy( pCur );
-                                la.deallocate( pCur, sizeof( Link ) );
+                                la.deallocate( pCur, 1 );
                                 pCur = pTmp;
                         }
                         pFirst = pLast = NULL;
@@ -81,8 +81,8 @@ namespace Bu
 
                 void append( const value &v )
                 {
-                        Link *pNew = la.allocate( sizeof( Link ) );
-                        pNew->pValue = va.allocate( sizeof( value ) );
+                        Link *pNew = la.allocate( 1 );
+                        pNew->pValue = va.allocate( 1 );
                         va.construct( pNew->pValue, v );
                         nSize++;
                         if( pFirst == NULL )
@@ -102,8 +102,8 @@ namespace Bu
 
                 void prepend( const value &v )
                 {
-                        Link *pNew = la.allocate( sizeof( Link ) );
-                        pNew->pValue = va.allocate( sizeof( value ) );
+                        Link *pNew = la.allocate( 1 );
+                        pNew->pValue = va.allocate( 1 );
                         va.construct( pNew->pValue, v );
                         nSize++;
                         if( pFirst == NULL )
@@ -316,10 +316,10 @@ namespace Bu
                         if( pPrev == NULL )
                         {
                                 va.destroy( pCur->pValue );
-                                va.deallocate( pCur->pValue, sizeof( value ) );
+                                va.deallocate( pCur->pValue, 1 );
                                 pFirst = pCur->pNext;
                                 la.destroy( pCur );
-                                la.deallocate( pCur, sizeof( Link ) );
+                                la.deallocate( pCur, 1 );
                                 if( pFirst == NULL )
                                         pLast = NULL;
                                 nSize--;
@@ -328,10 +328,10 @@ namespace Bu
                         else
                         {
                                 va.destroy( pCur->pValue );
-                                va.deallocate( pCur->pValue, sizeof( value ) );
+                                va.deallocate( pCur->pValue, 1 );
                                 Link *pTmp = pCur->pNext;
                                 la.destroy( pCur );
-                                la.deallocate( pCur, sizeof( Link ) );
+                                la.deallocate( pCur, 1 );
                                 pPrev->pNext = pTmp;
                                 if( pTmp != NULL )
                                         pTmp->pPrev = pPrev;
diff --git a/src/ringbuffer.cpp b/src/ringbuffer.cpp
new file mode 100644
index 0000000..feb9bc7
--- /dev/null
+++ b/src/ringbuffer.cpp
@@ -0,0 +1,2 @@
+#include "bu/ringbuffer.h"
+
diff --git a/src/ringbuffer.h b/src/ringbuffer.h
new file mode 100644
index 0000000..9480043
--- /dev/null
+++ b/src/ringbuffer.h
@@ -0,0 +1,100 @@
+#ifndef RING_BUFFER_H
+#define RING_BUFFER_H
+
+#include <memory>
+#include "bu/exceptionbase.h"
+
+namespace Bu
+{
+        template<typename value, typename valuealloc=std::allocator<value> >
+        class RingBuffer
+        {
+        public:
+                RingBuffer( int nCapacity ) :
+                        nCapacity( nCapacity ),
+                        nStart( -1 ),
+                        nEnd( -2 )
+                {
+                        aData = va.allocate( nCapacity );
+                        for( int j = 0; j < nCapacity; j++ )
+                        {
+                                va.construct( &aData[j], value() );
+                        }
+                }
+
+                virtual ~RingBuffer()
+                {
+                        for( int j = 0; j < nCapacity; j++ )
+                        {
+                                va.destroy( &aData[j] );
+                        }
+                        va.deallocate( aData, nCapacity );
+                }
+
+                int getCapacity()
+                {
+                        return nCapacity;
+                }
+
+                bool isFilled()
+                {
+                        return (nStart == nEnd);
+                }
+
+                bool isEmpty()
+                {
+                        return (nStart == -1);
+                }
+
+                void enqueue( const value &v )
+                {
+                        if( nStart == -1 )
+                        {
+                                nStart = 0;
+                                nEnd = 1;
+                                aData[0] = v;
+                        }
+                        else if( nStart == nEnd )
+                        {
+                                throw ExceptionBase("Hey, it's full!");
+                        }
+                        else
+                        {
+                                aData[nEnd] = v;
+                                nEnd = (nEnd+1)%nCapacity;
+                        }
+                }
+
+                value dequeue()
+                {
+                        if( nStart == -1 )
+                        {
+                                throw ExceptionBase("No data");
+                        }
+                        else
+                        {
+                                value &v = aData[nStart];
+                                nStart = (nStart+1)%nCapacity;
+                                if( nStart == nEnd )
+                                {
+                                        nStart = -1;
+                                        nEnd = -2;
+                                }
+                                return v;
+                        }
+                }
+
+                value &operator[]( int nIndex )
+                {
+                        return aData[(nIndex+nStart)%nCapacity];
+                }
+
+        private:
+                int nCapacity;
+                value *aData;
+                valuealloc va;
+                int nStart, nEnd;
+        };
+}
+
+#endif
diff --git a/src/tests/ringbuffer.cpp b/src/tests/ringbuffer.cpp
new file mode 100644
index 0000000..259ec1f
--- /dev/null
+++ b/src/tests/ringbuffer.cpp
@@ -0,0 +1,29 @@
+#include "bu/ringbuffer.h"
+#include <stdlib.h>
+
+int main()
+{
+        Bu::RingBuffer<uint32_t> ibuf( 10 );
+
+        for( int k = 0; k < 2; k++ )
+        {
+                int j = 1;
+                for(; j < 7; j++ )
+                {
+                        ibuf.enqueue( j );
+                }
+
+                for(; j < 20; j++ )
+                {
+                        ibuf.enqueue( j );
+                        printf("- %d\n", ibuf.dequeue() );
+                }
+
+                for(;;)
+                {
+                        if( ibuf.isEmpty() ) break;
+                        printf(". %d\n", ibuf.dequeue() );
+                }
+        }
+}
+