5 files changed, 328 insertions, 23 deletions

diff --git a/src/archive.h b/src/archive.h
index 1d57724..519b2a7 100644
--- a/src/archive.h
+++ b/src/archive.h
@@ -13,7 +13,7 @@
 #include <list>
 #include "bu/hash.h"
 #include "bu/list.h"
-#include "bu/set.h"
+//#include "bu/set.h"
 #include "bu/util.h"
 
 namespace Bu
@@ -298,11 +298,12 @@ namespace Bu
                 return ar;
         }
 
-        template<typename value>
-        Archive &operator<<( Archive &ar, Set<value> &h )
+        template<typename value, int inc, typename valuealloc> class Array;
+        template<typename value, int inc, typename valuealloc>
+        Archive &operator<<( Archive &ar, Array<value, inc, valuealloc> &h )
         {
                 ar << h.getSize();
-                for( typename Set<value>::iterator i = h.begin(); i != h.end(); i++ )
+                for( typename Array<value, inc, valuealloc>::iterator i = h.begin(); i != h.end(); i++ )
                 {
                         ar << (*i);
                 }
@@ -310,17 +311,47 @@ namespace Bu
                 return ar;
         }
 
-        template<typename value>
-        Archive &operator>>( Archive &ar, Set<value> &h )
+        template<typename value, int inc, typename valuealloc>
+        Archive &operator>>(Archive &ar, Array<value, inc, valuealloc> &h )
         {
                 h.clear();
                 long nSize;
                 ar >> nSize;
-
+                
+                h.setCapacity( nSize );
                 for( long j = 0; j < nSize; j++ )
                 {
                         value v;
                         ar >> v;
+                        h.append( v );
+                }
+                return ar;
+        }
+
+        template<typename key, typename b, typename c, typename d> class Set;
+        template<typename key, typename b, typename c, typename d>
+        Archive &operator<<( Archive &ar, Set<key, b, c, d> &h )
+        {
+                ar << h.getSize();
+                for( typename Set<key, b, c, d>::iterator i = h.begin(); i != h.end(); i++ )
+                {
+                        ar << (*i);
+                }
+
+                return ar;
+        }
+
+        template<typename key, typename b, typename c, typename d>
+        Archive &operator>>( Archive &ar, Set<key, b, c, d> &h )
+        {
+                h.clear();
+                long nSize;
+                ar >> nSize;
+
+                for( long j = 0; j < nSize; j++ )
+                {
+                        key v;
+                        ar >> v;
                         h.insert( v );
                 }
 
diff --git a/src/array.cpp b/src/array.cpp
index 8cb58ab..826425c 100644
--- a/src/array.cpp
+++ b/src/array.cpp
@@ -7,3 +7,4 @@
 
 #include "bu/array.h"
 
+namespace Bu { subExceptionDef( ArrayException ) }
diff --git a/src/array.h b/src/array.h
index 093ece2..9233875 100644
--- a/src/array.h
+++ b/src/array.h
@@ -13,6 +13,7 @@
 
 namespace Bu
 {
+        subExceptionDecl( ArrayException )
         /**
          * Array type container, just like a normal array only flexible and keeps
          * track of your memory for you.
@@ -41,10 +42,14 @@ namespace Bu
                         iSize( 0 ),
                         iCapacity( 0 )
                 {
-                //      for( Link *pCur = src.pFirst; pCur; pCur = pCur->pNext )
-                //      {
-                //              append( *pCur->pValue );
-                //      }
+                }
+                
+                Array( long iSetCap ) :
+                        pData( NULL ),
+                        iSize( 0 ),
+                        iCapacity( 0 )
+                {
+                        setCapacity( iSetCap );
                 }
 
                 ~Array()
@@ -53,33 +58,244 @@ namespace Bu
                 }
 
                 /**
-                 * Clear the data from the list.
+                 * Clear the array.
                  */
                 void clear()
                 {
+                        if( pData )
+                        {
+                                for( int j = 0; j < iSize; j++ )
+                                {
+                                        va.destroy( &pData[j] );
+                                }
+                                va.deallocate( pData, iCapacity );
+                                pData = NULL;
+                        }
+                        iSize = 0;
+                        iCapacity = 0;
                 }
 
-                //operator 
+                void append( const value &rVal )
+                {
+                        if( iSize == iCapacity )
+                        {
+                                setCapacity( iCapacity + inc );
+                        }
+
+                        va.construct( &pData[iSize++], rVal );
+                }
+
+                //operator
+                value &operator[]( long iIndex )
+                {
+                        if( iIndex < 0 || iIndex >= iSize )
+                                throw ArrayException(
+                                        "Index %d out of range 0:%d", iIndex, iSize );
+
+                        return pData[iIndex];
+                }
+                
+                const value &operator[]( long iIndex ) const
+                {
+                        if( iIndex < 0 || iIndex >= iSize )
+                                throw ArrayException(
+                                        "Index %d out of range 0:%d", iIndex, iSize );
+
+                        return pData[iIndex];
+                }
 
                 /**
-                 * Get the current size of the list.
-                 *@returns (int) The current size of the list.
+                 * Get the current size of the array.
+                 *@returns The current size of the array.
                  */
-                int getSize() const
+                long getSize() const
                 {
                         return iSize;
                 }
 
-                int getCapacity() const
+                /**
+                 * Get the capacity of the array.  This number will grow as data is
+                 * added, and is mainly for the curious, it doesn't really determine
+                 * much for the end user.
+                 *@returns The current capacity of the array.
+                 */
+                long getCapacity() const
                 {
                         return iCapacity;
                 }
 
+                /**
+                 * Change the capacity of the array, very useful if you know you'll be
+                 * adding a large amount of already counted items to the array, makes
+                 * the appending much faster afterwords.
+                 *@param iNewLen The new capacity of the array.
+                 *@todo Set this up so it can reduce the size of the array as well as
+                 * make it bigger.
+                 */
+                void setCapacity( long iNewLen )
+                {
+                        if( iNewLen < iCapacity ) return;
+                        value *pNewData = va.allocate( iNewLen );
+                        if( pData )
+                        {
+                                for( int j = 0; j < iSize; j++ )
+                                {
+                                        va.construct( &pNewData[j], pData[j] );
+                                        va.destroy( &pData[j] );
+                                }
+                                va.deallocate( pData, iCapacity );
+                        }
+                        pData = pNewData;
+                        iCapacity = iNewLen;
+                }
+
+                typedef struct iterator
+                {
+                        friend class Array<value, inc, valuealloc>;
+                private:
+                        iterator( MyType &src, long iPos=0 ) :
+                                src( src ),
+                                iPos( iPos )
+                        {
+                        }
+
+                        MyType &src;
+                        long iPos;
+
+                public:
+                        iterator operator++( int )
+                        {
+                                if( iPos < 0 )
+                                        throw ArrayException(
+                                                "Cannot increment iterator past end of array.");
+                                        iPos++;
+                                if( iPos >= src.getSize() )
+                                        iPos = -1;
+                                return *this;
+                        }
+                        
+                        iterator operator++()
+                        {
+                                if( iPos >= 0 )
+                                        iPos++;
+                                if( iPos >= src.getSize() )
+                                        iPos = -1;
+                                return *this;
+                        }
+
+                        bool operator==( const iterator &oth )
+                        {
+                                return iPos == oth.iPos;
+                        }
+
+                        bool operator!=( const iterator &oth )
+                        {
+                                return iPos != oth.iPos;
+                        }
+
+                        iterator operator=( const iterator &oth )
+                        {
+                                if( &src != &oth.src )
+                                        throw ArrayException(
+                                                "Cannot mix iterators from different array objects.");
+                                iPos = oth.iPos;
+                        }
+
+                        value &operator*()
+                        {
+                                if( iPos < 0 )
+                                        throw ArrayException(
+                                                "Cannot dereference finished iterator.");
+                                return src[iPos];
+                        }
+                } iterator;
+                
+                typedef struct const_iterator
+                {
+                        friend class Array<value, inc, valuealloc>;
+                private:
+                        const_iterator( const MyType &src, long iPos=0 ) :
+                                src( src ),
+                                iPos( iPos )
+                        {
+                        }
+
+                        const MyType &src;
+                        long iPos;
+
+                public:
+                        const_iterator operator++( int )
+                        {
+                                if( iPos < 0 )
+                                        throw ArrayException(
+                                                "Cannot increment iterator past end of array.");
+                                        iPos++;
+                                if( iPos >= src.getSize() )
+                                        iPos = -1;
+                                return *this;
+                        }
+                        
+                        const_iterator operator++()
+                        {
+                                if( iPos >= 0 )
+                                        iPos++;
+                                if( iPos >= src.getSize() )
+                                        iPos = -1;
+                                return *this;
+                        }
+
+                        bool operator==( const const_iterator &oth )
+                        {
+                                return iPos == oth.iPos;
+                        }
+
+                        bool operator!=( const const_iterator &oth )
+                        {
+                                return iPos != oth.iPos;
+                        }
+
+                        const_iterator operator=( const const_iterator &oth )
+                        {
+                                if( &src != &oth.src )
+                                        throw ArrayException(
+                                                "Cannot mix iterators from different array objects.");
+                                iPos = oth.iPos;
+                        }
+
+                        const value &operator*() const
+                        {
+                                if( iPos < 0 )
+                                        throw ArrayException(
+                                                "Cannot dereference finished iterator.");
+                                return src[iPos];
+                        }
+                } const_iterator;
+
+                iterator begin()
+                {
+                        return iterator( *this );
+                }
+
+                const_iterator begin() const
+                {
+                        return const_iterator( *this );
+                }
+
+                iterator end()
+                {
+                        return iterator( *this, -1 );
+                }
+
+                const_iterator end() const
+                {
+                        return const_iterator( *this, -1 );
+                }
+
         private:
                 valuealloc va;
                 value *pData;
-                int iSize;
-                int iCapacity;
+                long iSize;
+                long iCapacity;
         };
 }
 
diff --git a/src/set.h b/src/set.h
index 7dfa191..42f9eb8 100644
--- a/src/set.h
+++ b/src/set.h
@@ -16,8 +16,6 @@
 #include <utility>
 #include "bu/exceptionbase.h"
 #include "bu/list.h"
-///#include "archival.h"
-///#include "archive.h"
 
 #define bitsToBytes( n ) (n/32+(n%32>0 ? 1 : 0))
 
@@ -355,7 +353,7 @@ namespace Bu
                         {
                                 if( &hsh != &oth.hsh )
                                         throw SetException(
-                                                "Cannot mix iterators from different hash objects.");
+                                                "Cannot mix iterators from different set objects.");
                                 nPos = oth.nPos;
                                 bFinished = oth.bFinished;
                         }
@@ -371,7 +369,7 @@ namespace Bu
                 } iterator;
                 
                 /**
-                 * Iteration structure for iterating through the hash (const).
+                 * Iteration structure for iterating through the set (const).
                  */
                 typedef struct const_iterator
                 {
diff --git a/src/unit/array.cpp b/src/unit/array.cpp
new file mode 100644
index 0000000..db29882
--- /dev/null
+++ b/src/unit/array.cpp
@@ -0,0 +1,59 @@
+/*
+ * Copyright (C) 2007-2008 Xagasoft, All rights reserved.
+ *
+ * This file is part of the libbu++ library and is released under the
+ * terms of the license contained in the file LICENSE.
+ */
+
+#include "bu/unitsuite.h"
+#include "bu/array.h"
+
+class Unit : public Bu::UnitSuite
+{
+public:
+        Unit()
+        {
+                setName("Array");
+                addTest( Unit::general );
+                addTest( Unit::iterate );
+        }
+
+        virtual ~Unit()
+        {
+        }
+
+        void general()
+        {
+                Bu::Array<int> ai;
+
+                ai.append( 5 );
+                ai.append( 10 );
+                unitTest( ai.getSize() == 2 );
+                unitTest( ai.getCapacity() == 10 );
+                unitTest( ai[0] == 5 );
+                unitTest( ai[1] == 10 );
+        }
+
+        void iterate()
+        {
+                Bu::Array<int> ai;
+                for( int j = 0; j < 10; j++ )
+                        ai.append( j );
+
+                int j = 0;
+                for( Bu::Array<int>::iterator i = ai.begin(); i != ai.end(); i++ )
+                        unitTest( (*i) == j++ );
+                
+                const Bu::Array<int> &ci = ai;
+                j = 0;
+                for( Bu::Array<int>::const_iterator i = ci.begin(); i != ci.end(); i++ )
+                        unitTest( (*i) == j++ );
+        }
+        
+};
+
+int main( int argc, char *argv[] )
+{
+        return Unit().run( argc, argv );
+}
+