Ok, the cache-id officiation is being delegated to the CacheHandlers, this is

just fine, since they can do it any way they want.  The Congo CacheHandlers
will all have to be specialized versions of the generic ones, but they'll use
all the general functionality, just make up IDs differently.  It'll rock.

1 files changed, 31 insertions, 0 deletions

diff --git a/src/cache.h b/src/cache.h
index 344d1c6..8ab0659 100644
--- a/src/cache.h
+++ b/src/cache.h
@@ -3,6 +3,8 @@
 
 #include "bu/cptr.h"
 #include "bu/hash.h"
+#include "bu/list.h"
+#include "bu/cachehandler.h"
 
 #define BU_TRACE
 #include "bu/trace.h"
@@ -29,6 +31,21 @@ namespace Bu
                 virtual ~Cache()
                 {
                         TRACE();
+                        for( HandlerList::iterator i = lHandler.begin();
+                                 i != lHandler.end(); i++ )
+                        {
+                                delete *i;
+                        }
+                }
+
+                void appendHandler( CacheHandler *pHand )
+                {
+                        lHandler.append( pHand );
+                }
+
+                void prependHandler( CacheHandler *pHand )
+                {
+                        lHandler.prepend( pHand );
                 }
 
                 Ptr insert( obtype *pData )
@@ -39,6 +56,18 @@ namespace Bu
                         return Ptr( *this, pData );
                 }
 
+                Ptr get( cid cId )
+                {
+                        TRACE();
+                        return Ptr( *this, hEnt.get( cId ).pData );
+                }
+
+                int getRefCnt( cid cId )
+                {
+                        TRACE();
+                        return hEnt.get( cId ).iRefs;
+                }
+
         private:
                 void incRef( obtype *pData )
                 {
@@ -64,6 +93,8 @@ namespace Bu
                 typedef Bu::Hash<cid, CacheEntry> CidHash;
                 //RefHash hRefs;
                 CidHash hEnt;
+                typedef Bu::List<CacheHandler *> HandlerList;
+                HandlerList lHandler;
         };
 };