Wow, that's a lot of changes. You can use anything as a key now, as long as it

can be hashed.  And we're about to test actually loading and saving persistant
cache items.  Fun.

10 files changed, 118 insertions, 97 deletions

diff --git a/src/cache.h b/src/cache.h
index f7b71ce..0c3994c 100644
--- a/src/cache.h
+++ b/src/cache.h
@@ -4,22 +4,30 @@
 #include "bu/cptr.h"
 #include "bu/hash.h"
 #include "bu/list.h"
-#include "bu/cachehandler.h"
+#include "bu/cachestore.h"
 
 #define BU_TRACE
 #include "bu/trace.h"
 
 namespace Bu
 {
-        template<class obtype>
+        template<class obtype, class keytype>
         class Cache
         {
-        friend class Bu::CPtr<obtype>;
-                typedef Bu::CPtr<obtype> Ptr;
-                typedef Bu::CacheHandler<obtype> Handler;
-                typedef Bu::List<Handler *> HandlerList;
+        friend class Bu::CPtr<obtype, keytype>;
         public:
-                typedef long cid_t;     /**< Cache ID type. Unique cache entry ID. */
+                typedef Bu::CPtr<obtype, keytype> Ptr;
+        private:
+                typedef Bu::CacheStore<obtype, keytype> Store;
+                typedef Bu::List<Store *> StoreList;
+                
+                typedef struct CacheEntry
+                {
+                        obtype *pData;
+                        int iRefs;
+                } CacheEntry;
+
+                typedef Bu::Hash<keytype, CacheEntry> CidHash;
 
         public:
                 Cache()
@@ -30,51 +38,51 @@ namespace Bu
                 virtual ~Cache()
                 {
                         TRACE();
-/*                      for( HandlerList::iterator i = lHandler.begin();
-                                 i != lHandler.end(); i++ )
+                        for( typename StoreList::iterator i = lStore.begin();
+                                 i != lStore.end(); i++ )
                         {
                                 delete *i;
                         }
-*/              }
+                }
 
-                void appendHandler( Handler *pHand )
+                void appendStore( Store *pHand )
                 {
-                        lHandler.append( pHand );
+                        lStore.append( pHand );
                 }
 
-                void prependHandler( Handler *pHand )
+                void prependStore( Store *pHand )
                 {
-                        lHandler.prepend( pHand );
+                        lStore.prepend( pHand );
                 }
 
                 Ptr insert( obtype *pData )
                 {
                         TRACE();
                         CacheEntry e = {pData, 0};
-                        hEnt.insert( /*pData*/ 0 , e );
+                        hEnt.insert( 0 , e );
                         return Ptr( *this, pData );
                 }
 
-                Ptr get( cid_t cId )
+                Ptr get( keytype cId )
                 {
                         TRACE();
                         return Ptr( *this, hEnt.get( cId ).pData );
                 }
 
-                int getRefCnt( cid_t cId )
+                int getRefCnt( keytype cId )
                 {
                         TRACE();
                         return hEnt.get( cId ).iRefs;
                 }
 
         private:
-                void incRef( cid_t cId )
+                void incRef( keytype cId )
                 {
                         TRACE();
                         hEnt.get( cId ).iRefs++;
                 }
 
-                void decRef( cid_t cId )
+                void decRef( keytype cId )
                 {
                         TRACE();
                         CacheEntry &e = hEnt.get( cId );
@@ -82,17 +90,8 @@ namespace Bu
                 }
 
         private:
-                typedef struct CacheEntry
-                {
-                        obtype *pData;
-                        int iRefs;
-                } CacheEntry;
-
-                //typedef Bu::Hash<ptrdiff_t, int> RefHash;
-                typedef Bu::Hash<cid_t, CacheEntry> CidHash;
-                //RefHash hRefs;
                 CidHash hEnt;
-                HandlerList lHandler;
+                StoreList lStore;
         };
 };
 
diff --git a/src/cachehandler.cpp b/src/cachehandler.cpp
deleted file mode 100644
index d208e98..0000000
--- a/src/cachehandler.cpp
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "bu/cachehandler.h"
-
diff --git a/src/cachehandler.h b/src/cachehandler.h
deleted file mode 100644
index 3b26970..0000000
--- a/src/cachehandler.h
+++ /dev/null
@@ -1,34 +0,0 @@
-#ifndef BU_CACHE_HANDLER_H
-#define BU_CACHE_HANDLER_H
-
-#include "bu/cptr.h"
-
-namespace Bu
-{
-        /**
-         * Handles I/O for data in the cache.  This also assigns ID's to the newly
-         * created objects that are requested through this system.
-         */
-        template<class T>
-        class CacheHandler
-        {
-        public:
-                CacheHandler()
-                {
-                }
-
-                virtual ~CacheHandler()
-                {
-                }
-
-                virtual Bu::CPtr<T> load()=0;
-                virtual void unload( Bu::CPtr<T> pObj )=0;
-                virtual Bu::CPtr<T> create()=0;
-                virtual Bu::CPtr<T> create( T &rSrc )=0;
-                virtual void destroy( Bu::CPtr<T> pObj )=0;
-
-        private:
-        };
-};
-
-#endif
diff --git a/src/cachestore.cpp b/src/cachestore.cpp
new file mode 100644
index 0000000..7f26f17
--- /dev/null
+++ b/src/cachestore.cpp
@@ -0,0 +1,2 @@
+#include "bu/cachestore.h"
+
diff --git a/src/cachestore.h b/src/cachestore.h
new file mode 100644
index 0000000..3211b6a
--- /dev/null
+++ b/src/cachestore.h
@@ -0,0 +1,35 @@
+#ifndef BU_CACHE_STORE_H
+#define BU_CACHE_STORE_H
+
+#include "bu/cptr.h"
+
+namespace Bu
+{
+        /**
+         * Handles I/O for data in the cache.  This also assigns ID's to the newly
+         * created objects that are requested through this system.
+         */
+        template<class obtype, class keytype>
+        class CacheStore
+        {
+        public:
+                CacheStore()
+                {
+                }
+
+                virtual ~CacheStore()
+                {
+                }
+
+                typedef Bu::CPtr<obtype, keytype> Ptr;
+
+                virtual obtype *load( const keytype &key )=0;
+                virtual void unload( obtype *pObj )=0;
+                virtual keytype create( obtype *pSrc )=0;
+                virtual void destroy( obtype *pObj, const keytype &key )=0;
+
+        private:
+        };
+};
+
+#endif
diff --git a/src/cachehandlernids.cpp b/src/cachestorenids.cpp
index e69de29..e69de29 100644
--- a/src/cachehandlernids.cpp
+++ b/src/cachestorenids.cpp
diff --git a/src/cachehandlernids.h b/src/cachestorenids.h
index e69de29..e69de29 100644
--- a/src/cachehandlernids.h
+++ b/src/cachestorenids.h
diff --git a/src/cptr.cpp b/src/cptr.cpp
index e69de29..65d668b 100644
--- a/src/cptr.cpp
+++ b/src/cptr.cpp
@@ -0,0 +1 @@
+#include "bu/cptr.h"
diff --git a/src/cptr.h b/src/cptr.h
index 6e54fdd..8f35a03 100644
--- a/src/cptr.h
+++ b/src/cptr.h
@@ -3,31 +3,29 @@
 
 namespace Bu
 {
-        template<class obtype> class Cache;
+        template<class obtype, class keytype> class Cache;
 
         /**
          * Cache Pointer - Provides access to data that is held within the cache.
          * This provides safe, refcounting access to data stored in the cache, with
          * support for lazy loading.
          */
-        template<class obtype>
+        template<class obtype, class keytype>
         class CPtr
         {
-        friend class Bu::Cache<obtype>;
-        public:
-                typedef long cid_t;     /**< Cache ID type. Unique cache entry ID. */
+        friend class Bu::Cache<obtype, keytype>;
         private:
-                CPtr( Cache<obtype> &rCache, obtype *pData ) :
+                CPtr( Cache<obtype, keytype> &rCache, obtype *pData ) :
                         rCache( rCache ),
                         pData( pData )
                 {
-                        rCache.incRef( cId );
+                        rCache.incRef( kId );
                 }
 
         public:
                 virtual ~CPtr()
                 {
-                        rCache.decRef( cId );
+                        rCache.decRef( kId );
                 }
 
                 obtype &operator*()
@@ -41,9 +39,9 @@ namespace Bu
                 }
 
         private:
-                Bu::Cache<obtype> &rCache;
+                Bu::Cache<obtype, keytype> &rCache;
                 obtype *pData;
-                cid_t cId;
+                keytype kId;
         };
 };
 
diff --git a/src/tests/cache.cpp b/src/tests/cache.cpp
index 55ec5be..1cc008a 100644
--- a/src/tests/cache.cpp
+++ b/src/tests/cache.cpp
@@ -1,4 +1,7 @@
 #include <stdio.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <errno.h>
 
 #include "bu/cache.h"
 
@@ -35,55 +38,74 @@ public:
         int iInt;
 };
 
-class BobHandler : public Bu::CacheHandler<Bob>
+class BobStore : public Bu::CacheStore<Bob, long>
 {
 public:
-        BobHandler() :
+        BobStore() :
                 cLastId( 0 )
         {
+                TRACE();
         }
 
-        ~BobHandler()
-        {
-        }
-
-        virtual Bu::CPtr<Bob> load()
+        ~BobStore()
         {
+                TRACE();
         }
 
-        virtual void unload( Bu::CPtr<Bob> pObj )
+        virtual Bob *load( const long &key )
         {
+                TRACE();
+                return NULL;
         }
 
-        virtual Bu::CPtr<Bob> create()
+        virtual void unload( Bob *pObj )
         {
+                TRACE();
+                delete pObj;
         }
 
-        virtual Bu::CPtr<Bob> create( Bob &rSrc )
+        virtual long create( Bob *rSrc )
         {
+                TRACE();
+                return ++cLastId;
         }
 
-        virtual void destroy( Bu::CPtr<Bob> pObj )
+        virtual void destroy( Bob *pObj, const long &key )
         {
+                TRACE();
+                delete pObj;
         }
 
 private:
-        Bu::Cache<Bob>::cid_t cLastId;
+        long cLastId;
 };
 
-int main()
+int main( int argc, char *argv[] )
 {
-        typedef Bu::Cache<Bob> BobCache;
-        typedef Bu::CPtr<Bob> BobPtr;
+        TRACE();
+        if( argc < 3 )
+        {
+                printf("Try: %s [icufd] [<id/value>]\n\n", argv[0] );
+                return 0;
+        }
+
+        switch( argv[1][0] )
+        {
+                case 'i':
+                        mkdir("bobcache", 0755 );
+                        printf("Initialized cache:  %s\n", strerror( errno ) );
+                        return 0;
+
+                case 'c':
+                        typedef Bu::Cache<Bob, long> BobCache;
+                        typedef BobCache::Ptr BobPtr;
 
-        BobCache bobCache;
+                        BobCache cBob;
 
-        BobPtr pB1 = bobCache.insert( new Bob() );
-        (*pB1).setInt( 44 );
-        printf("RefCnt = %d\n", bobCache.getRefCnt( 0 ) );
+                        cBob.appendStore( new BobStore() );
+
+                        return 0;
+        }
 
-        BobPtr pB2 = bobCache.get( 0 );
-        printf("RefCnt = %d\n", bobCache.getRefCnt( 0 ) );
-        printf("Int = %d\n", pB2->getInt() );
 }