Merged in the core branch. This is a major update that fixes many things, and

changes many others, including source files that were deleted and renamed.

Before doing this update, I reccomend a full clean, or even a fresh checkout.

Things to note, most outstanding about this update:
 - Bu::Socket was changed to Bu::TcpSocket and the default mode is blocking.
 - All templatized container classes are SharedCore now, which is good, but
   SharedCore is inherently non-reentrant safe.  However, all SharedCore classes
   have a "clone" function that return a non-shared copy of the object, safe for
   passing into a reentrant safe function accessing shared memory.

1 files changed, 21 insertions, 8 deletions

diff --git a/src/array.h b/src/array.h
index eeee677..f225c97 100644
--- a/src/array.h
+++ b/src/array.h
@@ -18,9 +18,18 @@ namespace Bu
         subExceptionDecl( ArrayException )
 
         template<typename value, int inc, typename valuealloc>
+        class Array;
+
+        /** @cond DEVEL */
+        template<typename value, int inc, typename valuealloc>
         class ArrayCore
         {
-        public:
+        friend class Array<value, inc, valuealloc>;
+        friend class SharedCore<
+                Array<value, inc, valuealloc>,
+                ArrayCore<value, inc, valuealloc>
+                >;
+        private:                
                 ArrayCore() :
                         pData( NULL ),
                         iSize( 0 ),
@@ -99,6 +108,7 @@ namespace Bu
                 long iSize;
                 long iCapacity;
         };
+        /** @endcond */
 
         /**
          * Array type container, just like a normal array only flexible and keeps
@@ -110,16 +120,20 @@ namespace Bu
          *@ingroup Containers
          */
         template<typename value, int inc=10, typename valuealloc=std::allocator<value> >
-        class Array : public SharedCore<ArrayCore<value, inc, valuealloc> >
+        class Array : public SharedCore<
+                                  Array<value, inc, valuealloc>,
+                                  ArrayCore<value, inc, valuealloc>
+                                  >
         {
         private:
                 typedef class Array<value, inc, valuealloc> MyType;
                 typedef class ArrayCore<value, inc, valuealloc> Core;
 
         protected:
-                using SharedCore< Core >::core;
-                using SharedCore< Core >::_hardCopy;
-                using SharedCore< Core >::_allocateCore;
+                using SharedCore<MyType, Core>::core;
+                using SharedCore<MyType, Core>::_hardCopy;
+                using SharedCore<MyType, Core>::_resetCore;
+                using SharedCore<MyType, Core>::_allocateCore;
 
         public:
                 struct const_iterator;
@@ -130,7 +144,7 @@ namespace Bu
                 }
 
                 Array( const MyType &src ) :
-                        SharedCore< Core >( src )
+                        SharedCore<MyType, Core >( src )
                 {
                 }
                 
@@ -168,8 +182,7 @@ namespace Bu
                  */
                 void clear()
                 {
-                        _hardCopy();
-                        core->clear();
+                        _resetCore();
                 }
 
                 MyType &append( const value &rVal )