Alright, the caching system now passes the basic CRUD tests with arbitrary

keytypes.  It doesn't yet use the stackable CacheStore concept, but the code
is all in place to make it easy to switch to.  There also needs to be some more
accounting code in place, so that we can actually use the Schedulers, whatever
they happen to be called in the future.

A whacky side note, it turns out that we totally need to ensure an object is
loaded from the cache in order to delete it, we can't ensure that any
references to other objects that are in the cache will be loaded otherwise.

1 files changed, 50 insertions, 8 deletions

diff --git a/src/cache.h b/src/cache.h
index 0c3994c..9488044 100644
--- a/src/cache.h
+++ b/src/cache.h
@@ -38,6 +38,20 @@ namespace Bu
                 virtual ~Cache()
                 {
                         TRACE();
+                        for( typename CidHash::iterator i = hEnt.begin();
+                                 i != hEnt.end(); i++ )
+                        {
+                                if( i.getValue().iRefs > 0 )
+                                {
+                                        printf("Error?  iRefs=%d for key ", i.getValue().iRefs );
+                                        __tracer_format( i.getKey() );
+                                        printf("!\n");
+                                }
+                                lStore.first()->unload(
+                                        i.getValue().pData,
+                                        i.getKey()
+                                        );
+                        }
                         for( typename StoreList::iterator i = lStore.begin();
                                  i != lStore.end(); i++ )
                         {
@@ -47,44 +61,72 @@ namespace Bu
 
                 void appendStore( Store *pHand )
                 {
+                        TRACE();
                         lStore.append( pHand );
                 }
 
                 void prependStore( Store *pHand )
                 {
+                        TRACE();
                         lStore.prepend( pHand );
                 }
 
                 Ptr insert( obtype *pData )
                 {
-                        TRACE();
+                        TRACE( pData );
                         CacheEntry e = {pData, 0};
-                        hEnt.insert( 0 , e );
-                        return Ptr( *this, pData );
+                        keytype k = lStore.first()->create( pData );
+                        hEnt.insert( k, e );
+
+                        return Ptr( *this, pData, k );
                 }
 
                 Ptr get( keytype cId )
                 {
-                        TRACE();
-                        return Ptr( *this, hEnt.get( cId ).pData );
+                        TRACE( cId );
+                        try {
+                                return Ptr( *this, hEnt.get( cId ).pData, cId );
+                        }
+                        catch( Bu::HashException &e ) {
+                                CacheEntry e = {lStore.first()->load( cId ), 0};
+                                hEnt.insert( cId, e );
+                                return Ptr( *this, e.pData, cId );
+                        }
+                }
+
+                void erase( keytype cId )
+                {
+                        TRACE( cId );
+                        try {
+                                if( hEnt.get( cId ).iRefs > 0 )
+                                {
+                                        printf("Shouldn't delete, references still exist!\n");
+                                        return;
+                                }
+                        }
+                        catch( Bu::HashException &e ) {
+                                get( cId );
+                        }
+                        lStore.first()->destroy( hEnt.get( cId ).pData, cId );
+                        hEnt.erase( cId );
                 }
 
                 int getRefCnt( keytype cId )
                 {
-                        TRACE();
+                        TRACE( cId );
                         return hEnt.get( cId ).iRefs;
                 }
 
         private:
                 void incRef( keytype cId )
                 {
-                        TRACE();
+                        TRACE( cId );
                         hEnt.get( cId ).iRefs++;
                 }
 
                 void decRef( keytype cId )
                 {
-                        TRACE();
+                        TRACE( cId );
                         CacheEntry &e = hEnt.get( cId );
                         e.iRefs--;
                 }