SharedCore has more features now, which is cool, including a test to see if

another object of the parent type has the same core, and another to clone the
parent object.  That one is pretty cool, it means you can now get a real copy
when you want to, great for multi-threaded stuff.

Also, two more classes are now SharedCore: Hash and Heap!

1 files changed, 19 insertions, 8 deletions

diff --git a/src/array.h b/src/array.h
index eeee677..fc4fb12 100644
--- a/src/array.h
+++ b/src/array.h
@@ -18,9 +18,17 @@ namespace Bu
         subExceptionDecl( ArrayException )
 
         template<typename value, int inc, typename valuealloc>
+        class Array;
+
+        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 ),
@@ -110,16 +118,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 +142,7 @@ namespace Bu
                 }
 
                 Array( const MyType &src ) :
-                        SharedCore< Core >( src )
+                        SharedCore<MyType, Core >( src )
                 {
                 }
                 
@@ -168,8 +180,7 @@ namespace Bu
                  */
                 void clear()
                 {
-                        _hardCopy();
-                        core->clear();
+                        _resetCore();
                 }
 
                 MyType &append( const value &rVal )