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, 28 insertions, 2 deletions

diff --git a/src/sharedcore.h b/src/sharedcore.h
index 5a44df9..ac36606 100644
--- a/src/sharedcore.h
+++ b/src/sharedcore.h
@@ -15,10 +15,10 @@
 
 namespace Bu
 {
-        template<typename Core>
+        template<typename Shell, typename Core>
         class SharedCore
         {
-                typedef class SharedCore<Core> _SharedType;
+                typedef class SharedCore<Shell, Core> _SharedType;
         public:
                 SharedCore() :
                         core( NULL ),
@@ -54,6 +54,18 @@ namespace Bu
                         return *iRefCount;
                 }
 
+                Shell clone() const
+                {
+                        Shell s( dynamic_cast<const Shell &>(*this) );
+                        s._hardCopy();
+                        return s;
+                }
+
+                bool isCoreShared( const Shell &rOther ) const
+                {
+                        return rOther.core == core;
+                }
+
         protected:
                 Core *core;
                 void _hardCopy()
@@ -68,6 +80,20 @@ namespace Bu
                         iRefCount = new int( 1 );
                 }
 
+                /**
+                 * Reset core acts like a hard copy, except instead of providing a
+                 * standalone copy of the shared core, it provides a brand new core.
+                 *
+                 * Very useful in functions used to reset the state of an object.
+                 */
+                void _resetCore()
+                {
+                        if( core )
+                                _deref();
+                        core = _allocateCore();
+                        iRefCount = new int( 1 );
+                }
+
                 virtual Core *_allocateCore()
                 {
                         return new Core();