RingBuffer is now SharedCore. I think that's all the container classes, there

may be a few other things that should change too, we'll see.

Played with doxygen docs on List, we can actually use @cond to remove things
from the docs, either permenently or conditionally, and so I could trick it into
making all of the sharedcore classes inherit from the same SharedCore in the
docs instead of different ones.  Or, just not inherit from SharedCore at all.

What to do...? :-P

I also got rid of ListHash, it wasn't working out yet anyway.

1 files changed, 163 insertions, 44 deletions

diff --git a/src/ringbuffer.h b/src/ringbuffer.h
index e984d18..04add42 100644
--- a/src/ringbuffer.h
+++ b/src/ringbuffer.h
@@ -10,97 +10,216 @@
 
 #include <memory>
 #include "bu/exceptionbase.h"
+#include "bu/queue.h"
+#include "bu/sharedcore.h"
 
 namespace Bu
 {
-        /**
-         *@ingroup Containers
-         */
-        template<typename value, typename valuealloc=std::allocator<value> >
-        class RingBuffer
+        template<typename value, typename valuealloc> class RingBuffer;
+
+        template<typename value, typename valuealloc>
+        class RingBufferCore
         {
-        public:
-                RingBuffer( int nCapacity ) :
-                        nCapacity( nCapacity ),
-                        nStart( -1 ),
-                        nEnd( -2 )
+        friend class RingBuffer<value, valuealloc>;
+        friend class SharedCore<RingBuffer<value, valuealloc>,
+                   RingBufferCore<value, valuealloc> >;
+        private:
+                RingBufferCore() :
+                        iCapacity( 0 ),
+                        iStart( -1 ),
+                        iEnd( -2 ),
+                        aData( NULL )
                 {
-                        aData = va.allocate( nCapacity );
                 }
 
-                virtual ~RingBuffer()
+                virtual ~RingBufferCore()
                 {
-                        for( int j = nStart; j < nEnd; j=(j+1%nCapacity) )
-                        {
-                                va.destroy( &aData[j] );
-                        }
-                        va.deallocate( aData, nCapacity );
+                        clear();
                 }
 
-                int getCapacity()
+                void init( int iNewCapacity )
                 {
-                        return nCapacity;
-                }
+                        if( iCapacity > 0 )
+                                return;
 
-                bool isFilled()
-                {
-                        return (nStart == nEnd);
+                        iCapacity = iNewCapacity;
+                        iStart = -1;
+                        iEnd = -2;
+                        aData = va.allocate( iCapacity );
                 }
 
-                bool isEmpty()
+                void clear()
                 {
-                        return (nStart == -1);
+                        for( int j = iStart; j < iEnd; j=(j+1%iCapacity) )
+                        {
+                                va.destroy( &aData[j] );
+                        }
+                        va.deallocate( aData, iCapacity );
+                        aData = NULL;
+                        iCapacity = 0;
                 }
-
+                
                 void enqueue( const value &v )
                 {
-                        if( nStart == -1 )
+                        if( iStart == -1 )
                         {
-                                nStart = 0;
-                                nEnd = 1;
+                                iStart = 0;
+                                iEnd = 1;
                                 va.construct( &aData[0], v );
                         }
-                        else if( nStart == nEnd )
+                        else if( iStart == iEnd )
                         {
                                 throw ExceptionBase("Hey, it's full!");
                         }
                         else
                         {
-                                va.construct( &aData[nEnd], v );
-                                nEnd = (nEnd+1)%nCapacity;
+                                va.construct( &aData[iEnd], v );
+                                iEnd = (iEnd+1)%iCapacity;
                         }
                 }
 
                 value dequeue()
                 {
-                        if( nStart == -1 )
+                        if( iStart == -1 )
                         {
                                 throw ExceptionBase("No data");
                         }
                         else
                         {
-                                value &v = aData[nStart];
-                                va.destroy( &aData[nStart] );
-                                nStart = (nStart+1)%nCapacity;
-                                if( nStart == nEnd )
+                                value &v = aData[iStart];
+                                va.destroy( &aData[iStart] );
+                                iStart = (iStart+1)%iCapacity;
+                                if( iStart == iEnd )
                                 {
-                                        nStart = -1;
-                                        nEnd = -2;
+                                        iStart = -1;
+                                        iEnd = -2;
                                 }
                                 return v;
                         }
                 }
 
-                value &operator[]( int nIndex )
+                value &get( int iIndex )
                 {
-                        return aData[(nIndex+nStart)%nCapacity];
+                        return aData[(iIndex+iStart)%iCapacity];
                 }
 
-        private:
-                int nCapacity;
+                int getSize()
+                {
+                        if( iStart < 0 )
+                                return 0;
+                        if( iEnd == iStart )
+                                return iCapacity;
+                        if( iEnd < iStart )
+                                return iEnd-iStart;
+                        return iCapacity-(iEnd-iStart);
+                }
+
+                int iCapacity;
+                int iStart, iEnd;
                 value *aData;
                 valuealloc va;
-                int nStart, nEnd;
+        };
+
+        /**
+         *@ingroup Containers
+         */
+        template<typename value, typename valuealloc=std::allocator<value> >
+        class RingBuffer : public Queue<value>, public SharedCore<
+                                           RingBuffer<value, valuealloc>,
+                                           RingBufferCore<value, valuealloc>
+                                           >
+        {
+        private:
+                typedef RingBuffer<value, valuealloc> MyType;
+                typedef RingBufferCore<value, valuealloc> Core;
+
+        protected:
+                using SharedCore<MyType, Core>::core;
+                using SharedCore<MyType, Core>::_hardCopy;
+                using SharedCore<MyType, Core>::_allocateCore;
+
+        public:
+                RingBuffer( int iCapacity )
+                {
+                        core->init( iCapacity );
+                }
+
+                RingBuffer( const RingBuffer &rSrc ) :
+                        SharedCore<MyType, Core>( rSrc )
+                {
+                }
+
+                virtual ~RingBuffer()
+                {
+                }
+
+                int getCapacity() const
+                {
+                        return core->iCapacity;
+                }
+
+                bool isFilled() const
+                {
+                        return (core->iStart == core->iEnd);
+                }
+
+                bool isEmpty() const
+                {
+                        return (core->iStart == -1);
+                }
+
+                virtual void enqueue( const value &v )
+                {
+                        _hardCopy();
+
+                        core->enqueue( v );
+                }
+
+                virtual value dequeue()
+                {
+                        _hardCopy();
+
+                        return core->dequeue();
+                }
+
+                virtual int getSize() const
+                {
+                        return core->getSize();
+                }
+
+                virtual value &peek()
+                {
+                        _hardCopy();
+
+                        return core->get( 0 );
+                }
+
+                virtual const value &peek() const
+                {
+                        return core->get( 0 );
+                }
+
+                value &operator[]( int iIndex )
+                {
+                        _hardCopy();
+
+                        return core->get( iIndex );
+                }
+
+        protected:
+                virtual Core *_copyCore( Core *src )
+                {
+                        Core *pRet = _allocateCore();
+
+                        pRet->init( src->iCapacity );
+                        int iSize = src->getSize();
+                        for( int j = 0; j < iSize; j++ )
+                        {
+                                pRet->enqueue( src->get( j ) );
+                        }
+
+                        return pRet;
+                }
         };
 }