Updated the cache system. It now ensures that objects are initialized with

cache information before they are deserialized from storage.  This changed the
signature of the cache loading template function, but the new function isn't
harder to use, and provides the key information as well.

3 files changed, 58 insertions, 12 deletions

diff --git a/src/unstable/cachebase.h b/src/unstable/cachebase.h
index af2884c..bb543dd 100644
--- a/src/unstable/cachebase.h
+++ b/src/unstable/cachebase.h
@@ -328,6 +328,7 @@ namespace Bu
 
         typedef CacheEntry<keytype, obtype> Entry;
         typedef Bu::List<keytype> KeyList;
+        typedef CacheObject<keytype, obtype> ObjectType;
 
         CachePtr<keytype, obtype> insert( obtype *pObject )
         {
@@ -466,7 +467,10 @@ namespace Bu
         virtual void _create( const obtype *o )=0;
         virtual void _erase( const keytype &k )=0;
 
-        virtual obtype *_load( const keytype &k )=0;
+        virtual obtype *_load(
+            typename Bu::CacheObject<keytype, obtype>::Initializer &initObj,
+            const keytype &k
+            )=0;
         virtual void _save( const obtype *o )=0;
 
         virtual void _sync()=0;
@@ -481,7 +485,10 @@ namespace Bu
                 hChanged.insert( pObject->getKey(), true );
             mCacheEntry.unlockWrite();
             _create( pObject );
-            pObject->setCache( this, pEnt );
+            // I'm not sold on the ordering here...or the fact we're not
+            // using th initilizer
+            pObject->setCache( this );
+            pObject->setCacheEntry( pEnt );
             
             return pEnt;
         }
@@ -497,9 +504,12 @@ namespace Bu
             catch(...)
             {
                 // try to load the object from the backing store
-                obtype *pObject = _load( k );
+                typename ObjectType::Initializer initObj(
+                    this
+                    );
+                obtype *pObject = _load( initObj, k );
                 pEnt = new Entry( pObject );
-                pObject->setCache( this, pEnt );
+                pObject->setCacheEntry( pEnt );
                 Bu::ReadWriteMutex::WriteLocker wl( mCacheEntry );
                 hCacheEntry.insert( k, pEnt );
             }
@@ -536,11 +546,15 @@ namespace Bu
         ar << *pObject;
     }
 
-    template<typename obtype>
-    obtype *_cacheObjectLoad( Bu::Stream &s )
+    template<typename keytype, typename obtype>
+    obtype *_cacheObjectLoad(
+        typename Bu::CacheObject<keytype, obtype>::Initializer &initObject,
+        const keytype & /*rKey*/,
+        Bu::Stream &s
+        )
     {
         Bu::Archive ar( s, Bu::Archive::load );
-        obtype *ret = new obtype();
+        obtype *ret = initObject(new obtype());
         ar >> *ret;
         return ret;
     }
diff --git a/src/unstable/cacheobject.h b/src/unstable/cacheobject.h
index e83f706..ca70bb4 100644
--- a/src/unstable/cacheobject.h
+++ b/src/unstable/cacheobject.h
@@ -21,6 +21,7 @@ namespace Bu
     class CacheObject
     {
     friend class CacheBase<keytype, obtype>;
+    //friend class CacheObject<keytype, obtype>::Initializer;
     public:
         CacheObject() :
             pCache( NULL ),
@@ -35,6 +36,7 @@ namespace Bu
 
         typedef CacheObject<keytype, obtype> MyType;
         typedef CacheBase<keytype, obtype> CacheType;
+        typedef CacheEntry<keytype, obtype> EntryType;
 
         virtual keytype getKey() const=0;
         virtual int getPersistenceScore() const { return 0; }
@@ -94,18 +96,44 @@ namespace Bu
         {
             return pCache;
         }
+    
+    public:
+        class Initializer
+        {
+        friend class CacheBase<keytype,obtype>;
+        private:
+            Initializer( CacheBase<keytype,obtype> *pCache ) :
+                pCache( pCache )
+            {
+            }
+
+        public:
+            template<typename subtype>
+            subtype *operator()( subtype *pNewObj )
+            {
+                pNewObj->setCache( pCache );
+                return pNewObj;
+            }
+            
+        private:
+            CacheBase<keytype,obtype> *pCache;
+        };
+
 
     private:
-        typedef CacheEntry<keytype, obtype> Entry;
-        void setCache( CacheType *pCache, Entry *pEntry )
+        void setCache( CacheType *pCache )
         {
             this->pCache = pCache;
+        }
+
+        void setCacheEntry( EntryType *pEntry )
+        {
             this->pEntry = pEntry;
         }
 
     private:
         CacheType *pCache;
-        Entry *pEntry;
+        EntryType *pEntry;
         bool bChanged;
     };
 }
diff --git a/src/unstable/myriadcache.h b/src/unstable/myriadcache.h
index 9bc926f..d19395a 100644
--- a/src/unstable/myriadcache.h
+++ b/src/unstable/myriadcache.h
@@ -54,6 +54,7 @@ namespace Bu
         }
        
         using typename Bu::CacheBase<keytype,obtype>::KeyList;
+        using typename Bu::CacheBase<keytype,obtype>::ObjectType;
         
         virtual typename Bu::CacheBase<keytype,obtype>::KeyList getKeys() const
         {
@@ -92,10 +93,13 @@ namespace Bu
             bStructureChanged = true;
         }
 
-        virtual obtype *_load( const keytype &k )
+        virtual obtype *_load(
+            typename Bu::CacheObject<keytype, obtype>::Initializer &initObj,
+            const keytype &k
+            )
         {
             Bu::MyriadStream ms = mStore.openStream( hIndex.get( k ) );
-            return _cacheObjectLoad<obtype>( ms );
+            return _cacheObjectLoad<keytype, obtype>( initObj, k, ms );
         }
 
         virtual void _save( const obtype *o )