SPtr is now Bu::ified, and the List class now acts the way we think const lists

should act, you can't change anything in there.  I'm still debating changing
the const_iterator to a constIterator, or something else that's more Bu::worthy.

Heh, the namespaces are funny...ok...I'm really tired.

7 files changed, 382 insertions, 121 deletions

diff --git a/src/list.h b/src/list.h
index ec63496..4d16872 100644
--- a/src/list.h
+++ b/src/list.h
@@ -13,6 +13,15 @@ namespace Bu
                 ListLink *pNext;
                 ListLink *pPrev;
         };
+
+        /**
+         * Linked list template container.  This class is similar to the stl list
+         * class except for a few minor changes.  First, it doesn't mimic a stack or
+         * queue, use the Stack or Queue clasess for that.  Second, when const, all
+         * members are only accessable const.  Third, erasing a location does not
+         * invalidate the iterator, it simply points to the next valid location, or
+         * end() if there are no more.
+         */
         template<typename value, typename valuealloc=std::allocator<value>, typename linkalloc=std::allocator<struct ListLink<value> > >
         class List
         {
@@ -23,15 +32,59 @@ namespace Bu
         public:
                 List() :
                         pFirst( NULL ),
-                        pLast( NULL )
+                        pLast( NULL ),
+                        nSize( 0 )
+                {
+                }
+
+                List( const MyType &src ) :
+                        pFirst( NULL ),
+                        pLast( NULL ),
+                        nSize( 0 )
+                {
+                        for( Link *pCur = src.pFirst; pCur; pCur = pCur->pNext )
+                        {
+                                append( *pCur->pValue );
+                        }
+                }
+
+                ~List()
+                {
+                        clear();
+                }
+
+                MyType &operator=( const MyType &src )
                 {
+                        clear();
+                        for( Link *pCur = src.pFirst; pCur; pCur = pCur->pNext )
+                        {
+                                append( *pCur->pValue );
+                        }
+                }
+
+                void clear()
+                {
+                        Link *pCur = pFirst;
+                        for(;;)
+                        {
+                                if( pCur == NULL ) break;
+                                va.destroy( pCur->pValue );
+                                va.deallocate( pCur->pValue, sizeof( value ) );
+                                Link *pTmp = pCur->pNext;
+                                la.destroy( pCur );
+                                la.deallocate( pCur, sizeof( Link ) );
+                                pCur = pTmp;
+                        }
+                        pFirst = pLast = NULL;
+                        nSize = 0;
                 }
 
-                void append( value v )
+                void append( const value &v )
                 {
                         Link *pNew = la.allocate( sizeof( Link ) );
                         pNew->pValue = va.allocate( sizeof( value ) );
                         va.construct( pNew->pValue, v );
+                        nSize++;
                         if( pFirst == NULL )
                         {
                                 // Empty list
@@ -47,11 +100,12 @@ namespace Bu
                         }
                 }
 
-                void prepend( value v )
+                void prepend( const value &v )
                 {
                         Link *pNew = la.allocate( sizeof( Link ) );
                         pNew->pValue = va.allocate( sizeof( value ) );
                         va.construct( pNew->pValue, v );
+                        nSize++;
                         if( pFirst == NULL )
                         {
                                 // Empty list
@@ -83,22 +137,22 @@ namespace Bu
                         }
 
                 public:
-                        bool operator==( const iterator &oth )
+                        bool operator==( const iterator &oth ) const
                         {
                                 return ( pLink == oth.pLink );
                         }
 
-                        bool operator==( const Link *pOth )
+                        bool operator==( const Link *pOth ) const
                         {
                                 return ( pLink == pOth );
                         }
 
-                        bool operator!=( const iterator &oth )
+                        bool operator!=( const iterator &oth ) const
                         {
                                 return ( pLink != oth.pLink );
                         }
 
-                        bool operator!=( const Link *pOth )
+                        bool operator!=( const Link *pOth ) const
                         {
                                 return ( pLink != pOth );
                         }
@@ -110,40 +164,128 @@ namespace Bu
 
                         value *operator->()
                         {
-                                return pLink->pValue();
+                                return pLink->pValue;
                         }
 
-                        iterator operator++()
+                        iterator &operator++()
                         {
                                 if( pLink != NULL )
                                         pLink = pLink->pNext;
                                 return *this;
                         }
 
-                        iterator operator--()
+                        iterator &operator--()
                         {
                                 if( pLink != NULL )
                                         pLink = pLink->pPrev;
                                 return *this;
                         }
                         
-                        iterator operator++( int )
+                        iterator &operator++( int )
                         {
                                 if( pLink != NULL )
                                         pLink = pLink->pNext;
                                 return *this;
                         }
 
-                        iterator operator--( int )
+                        iterator &operator--( int )
                         {
                                 if( pLink != NULL )
                                         pLink = pLink->pPrev;
                                 return *this;
                         }
 
-                        iterator operator=( const iterator &oth )
+                        iterator &operator=( const iterator &oth )
                         {
                                 pLink = oth.pLink;
+                                return *this;
+                        }
+                };
+                
+                typedef struct const_iterator
+                {
+                        friend class List<value, valuealloc, linkalloc>;
+                private:
+                        Link *pLink;
+                        const_iterator() :
+                                pLink( NULL )
+                        {
+                        }
+
+                        const_iterator( Link *pLink ) :
+                                pLink( pLink )
+                        {
+                        }
+
+                public:
+                        bool operator==( const const_iterator &oth ) const
+                        {
+                                return ( pLink == oth.pLink );
+                        }
+
+                        bool operator==( const Link *pOth ) const
+                        {
+                                return ( pLink == pOth );
+                        }
+
+                        bool operator!=( const const_iterator &oth ) const
+                        {
+                                return ( pLink != oth.pLink );
+                        }
+
+                        bool operator!=( const Link *pOth ) const
+                        {
+                                return ( pLink != pOth );
+                        }
+
+                        const value &operator*()
+                        {
+                                return *(pLink->pValue);
+                        }
+
+                        const value *operator->()
+                        {
+                                return pLink->pValue;
+                        }
+
+                        const_iterator &operator++()
+                        {
+                                if( pLink != NULL )
+                                        pLink = pLink->pNext;
+                                return *this;
+                        }
+
+                        const_iterator &operator--()
+                        {
+                                if( pLink != NULL )
+                                        pLink = pLink->pPrev;
+                                return *this;
+                        }
+                        
+                        const_iterator &operator++( int )
+                        {
+                                if( pLink != NULL )
+                                        pLink = pLink->pNext;
+                                return *this;
+                        }
+
+                        const_iterator &operator--( int )
+                        {
+                                if( pLink != NULL )
+                                        pLink = pLink->pPrev;
+                                return *this;
+                        }
+
+                        const_iterator &operator=( const iterator &oth )
+                        {
+                                pLink = oth.pLink;
+                                return *this;
+                        }
+
+                        const_iterator &operator=( const const_iterator &oth )
+                        {
+                                pLink = oth.pLink;
+                                return *this;
                         }
                 };
 
@@ -152,17 +294,50 @@ namespace Bu
                         return iterator( pFirst );
                 }
 
-                const Link *end()
+                const const_iterator begin() const
+                {
+                        return const_iterator( pFirst );
+                }
+
+                const Link *end() const
                 {
                         return NULL;
                 }
 
-                int getSize()
+                void erase( iterator &i )
+                {
+                        Link *pCur = i.pLink;
+                        Link *pPrev = pCur->pPrev;
+                        if( pPrev == NULL )
+                        {
+                                va.destroy( pCur->pValue );
+                                va.deallocate( pCur->pValue, sizeof( value ) );
+                                pFirst = pCur->pNext;
+                                la.destroy( pCur );
+                                la.deallocate( pCur, sizeof( Link ) );
+                                if( pFirst == NULL )
+                                        pLast = NULL;
+                                nSize--;
+                                i.pLink = pFirst;
+                        }
+                        else
+                        {
+                                va.destroy( pCur->pValue );
+                                va.deallocate( pCur->pValue, sizeof( value ) );
+                                Link *pTmp = pCur->pNext;
+                                la.destroy( pCur );
+                                la.deallocate( pCur, sizeof( Link ) );
+                                pPrev->pNext = pTmp;
+                                if( pTmp != NULL )
+                                        pTmp->pPrev = pPrev;
+                                nSize--;
+                                i.pLink = pTmp;
+                        }
+                }
+
+                int getSize() const
                 {
-                        int j = 0;
-                        for( Link *pCur = pFirst; pCur; pCur = pCur->pNext )
-                                j++;
-                        return j;
+                        return nSize;
                 }
                 
         private:
@@ -170,6 +345,7 @@ namespace Bu
                 Link *pLast;
                 linkalloc la;
                 valuealloc va;
+                int nSize;
         };
 }
 
diff --git a/src/old/sptr.cpp b/src/old/sptr.cpp
deleted file mode 100644
index 7f5e894..0000000
--- a/src/old/sptr.cpp
+++ /dev/null
@@ -1 +0,0 @@
-#include "sptr.h"
diff --git a/src/old/sptr.h b/src/old/sptr.h
deleted file mode 100644
index deae94d..0000000
--- a/src/old/sptr.h
+++ /dev/null
@@ -1,99 +0,0 @@
-#ifndef SPTR_H
-#define SPTR_H
-
-#include <stdint.h>
-#include <stdio.h>
-
-template<typename T>
-class SPtr
-{
-public:
-        SPtr() :
-                pRefCnt( NULL ),
-                pData( NULL )
-        {
-        }
-
-        ~SPtr()
-        {
-                decCount();
-        }
-
-        SPtr( const SPtr<T> &src ) :
-                pRefCnt( src.pRefCnt ),
-                pData( src.pData )
-        {
-                if( pRefCnt )
-                        (*pRefCnt) += 1;
-        }
-
-        SPtr( T *pSrc ) :
-                pRefCnt( NULL ),
-                pData( pSrc )
-        {
-                pRefCnt = new int32_t;
-                (*pRefCnt) = 1;
-        }
-
-        int32_t count()
-        {
-                return *pRefCnt;
-        }
-
-        T *operator->() const
-        {
-                return pData;
-        }
-
-        T *operator*() const
-        {
-                return pData;
-        }
-
-        SPtr<T> operator=( const SPtr<T> &src )
-        {
-                decCount();
-                pRefCnt = src.pRefCnt;
-                pData = src.pData;
-                (*pRefCnt) += 1;
-
-                return *this;
-        }
-
-        bool operator==( const SPtr<T> &src )
-        {
-                return pData == src.pData;
-        }
-
-        operator bool()
-        {
-                return pRefCnt != NULL;
-        }
-
-        bool isSet()
-        {
-                return pRefCnt != NULL;
-        }
-
-private:
-        void decCount()
-        {
-                if( pRefCnt )
-                {
-                        (*pRefCnt) -= 1;
-                        //printf("Decrementing ref-count to %d\n", *pRefCnt );
-                        if( (*pRefCnt) == 0 )
-                        {
-                                delete pRefCnt;
-                                delete pData;
-                                pRefCnt = NULL;
-                                pData = NULL;
-                        }
-                }
-        }
-
-        int32_t *pRefCnt;
-        T *pData;
-};
-
-#endif
diff --git a/src/serversocket.h b/src/serversocket.h
index 9a26e2d..f146d91 100644
--- a/src/serversocket.h
+++ b/src/serversocket.h
@@ -2,13 +2,19 @@
 #define SERVER_SOCKET_H
 
 #include <stdint.h>
-#include "fstring.h"
-#include "socket.h"
+#include "bu/fstring.h"
 
 namespace Bu
 {
         /**
+         * A single tcp/ip server socket.  When created the server socket will bind
+         * to the specified interface and port, and immediately begin listening for
+         * connections.  When connections come in they are pooled by the networking
+         * drivers in the kernel until they are accepted, this means that failure
+         * to keep space in the connection pool will result in connection refusals.
          *
+         * Although the accept function returns an integral file descriptor, it is
+         * designed to be used with the Socket class.
          */
         class ServerSocket
         {
diff --git a/src/sptr.cpp b/src/sptr.cpp
new file mode 100644
index 0000000..8ea7f8f
--- /dev/null
+++ b/src/sptr.cpp
@@ -0,0 +1 @@
+#include "bu/sptr.h"
diff --git a/src/sptr.h b/src/sptr.h
new file mode 100644
index 0000000..faa8524
--- /dev/null
+++ b/src/sptr.h
@@ -0,0 +1,147 @@
+#ifndef SPTR_H
+#define SPTR_H
+
+#include <stdint.h>
+#include <stdio.h>
+
+namespace Bu
+{
+        template<typename T> class SPtr;
+        template< typename Tb, typename Ta > SPtr<Tb> SPtrCast( SPtr<Ta> src );
+
+        template<typename T>
+        class SPtr
+        {
+                template<typename Tb, typename Ta>
+                friend SPtr<Tb> SPtrCast( SPtr<Ta> pt );
+        public:
+                SPtr() :
+                        pRefCnt( NULL ),
+                        pData( NULL )
+                {
+                }
+
+                ~SPtr()
+                {
+                        decCount();
+                }
+
+                SPtr( const SPtr<T> &src ) :
+                        pRefCnt( src.pRefCnt ),
+                        pData( src.pData )
+                {
+                        if( pRefCnt )
+                                (*pRefCnt) += 1;
+                }
+
+                SPtr( T *pSrc ) :
+                        pRefCnt( NULL ),
+                        pData( pSrc )
+                {
+                        if( pData )
+                        {
+                                pRefCnt = new int32_t;
+                                (*pRefCnt) = 1;
+                        }
+                }
+
+                int32_t count() const
+                {
+                        return *pRefCnt;
+                }
+
+                const T *operator->() const
+                {
+                        return pData;
+                }
+
+                const T &operator*() const
+                {
+                        return *pData;
+                }
+                
+                T *operator->()
+                {
+                        return pData;
+                }
+
+                T &operator*()
+                {
+                        return *pData;
+                }
+
+                SPtr<T> operator=( const SPtr<T> &src )
+                {
+                        decCount();
+                        pRefCnt = src.pRefCnt;
+                        pData = src.pData;
+                        if( pRefCnt )
+                                (*pRefCnt) += 1;
+
+                        return *this;
+                }
+
+                const SPtr<T> operator=( const SPtr<T> &src ) const
+                {
+                        decCount();
+                        pRefCnt = src.pRefCnt;
+                        pData = src.pData;
+                        if( pRefCnt )
+                                (*pRefCnt) += 1;
+
+                        return *this;
+                }
+
+                bool operator==( const SPtr<T> &src ) const
+                {
+                        return pData == src.pData;
+                }
+
+                bool operator==( const T *src ) const
+                {
+                        return pData == src;
+                }
+
+                operator bool() const
+                {
+                        return pRefCnt != NULL;
+                }
+
+                bool isSet() const
+                {
+                        return pRefCnt != NULL;
+                }
+
+        private:
+                void decCount() const
+                {
+                        if( pRefCnt )
+                        {
+                                (*pRefCnt) -= 1;
+                                //printf("Decrementing ref-count to %d\n", *pRefCnt );
+                                if( (*pRefCnt) == 0 )
+                                {
+                                        delete pRefCnt;
+                                        delete pData;
+                                        pRefCnt = NULL;
+                                        pData = NULL;
+                                }
+                        }
+                }
+
+                mutable int32_t *pRefCnt;
+                mutable T *pData;
+        };
+
+        template< typename Tb, typename Ta > SPtr<Tb> SPtrCast( SPtr<Ta> src )
+        {
+                SPtr<Tb> ret;
+                ret.pRefCnt = src.pRefCnt;
+                ret.pData = dynamic_cast<Tb *>(src.pData);
+                if( ret.pRefCnt )
+                        (*(ret.pRefCnt)) += 1;
+                return ret;
+        }
+}
+
+#endif
diff --git a/src/tests/list.cpp b/src/tests/list.cpp
index 34ab656..12807a5 100644
--- a/src/tests/list.cpp
+++ b/src/tests/list.cpp
@@ -1,4 +1,10 @@
 #include "bu/list.h"
+#include <list>
+
+typedef struct Bob
+{
+        int nID;
+} Bob;
 
 int main()
 {
@@ -16,7 +22,32 @@ int main()
         {
                 printf("%d ", *i );
         }
+        printf("\n");
+        for( Bu::List<int>::iterator i = l.begin(); i != l.end(); i++ )
+        {
+                l.erase( i );
+                if( i != l.end() )
+                        printf("%d ", *i );
+        }
+
+        printf("\n\n");
 
+        Bu::List<Bob> lb;
+        for( int j = 0; j < 10; j++ )
+        {
+                Bob b;
+                b.nID = j;
+                lb.append( b );
+        }
+
+        const Bu::List<Bob> rb = lb;
+
+        for( Bu::List<Bob>::const_iterator i = rb.begin(); i != rb.end(); i++ )
+        {
+                //i->nID += 2;
+                //(*i).nID = 4;
+                printf("%d ", i->nID );
+        }
         printf("\n\n");
 }