Woo! Very nearly there cache-wise, I'm about to change the name of the handler,

do a few more tests, and hopefully get something loading/saving.

7 files changed, 87 insertions, 86 deletions

diff --git a/src/cachable.cpp b/src/cachable.cpp
deleted file mode 100644
index 7fa2d23..0000000
--- a/src/cachable.cpp
+++ /dev/null
@@ -1,15 +0,0 @@
-#include "bu/cachable.h"
-
-Bu::Cachable::Cachable()
-{
-}
-
-Bu::Cachable::~Cachable()
-{
-}
-
-template<> long Bu::getCacheId<Bu::Cachable>( const Bu::Cachable *o )
-{
-        return o->getCacheId();
-}
-
diff --git a/src/cachable.h b/src/cachable.h
deleted file mode 100644
index a54c55b..0000000
--- a/src/cachable.h
+++ /dev/null
@@ -1,28 +0,0 @@
-#ifndef BU_CACHABLE_H
-#define BU_CACHABLE_H
-
-namespace Bu
-{
-        class Cachable
-        {
-        public:
-                Cachable();
-                virtual ~Cachable();
-
-                virtual long getCacheId() const =0;
-        };
-
-        template<class obtype> long getCacheId( const obtype *o );
-        template<> long getCacheId<Cachable>( const Cachable *o );
-};
-
-#define DECL_CACHABLE( name ) \
-        namespace Bu { template<> long getCacheId<name>( const name *o ); }
-
-#define DEF_CACHABLE( name ) \
-        template<> long Bu::getCacheId<name>( const name *o ) \
-        {       \
-                return getCacheId<Bu::Cachable>( (Bu::Cachable *)o );   \
-        }
-
-#endif
diff --git a/src/cache.h b/src/cache.h
index 8ab0659..f7b71ce 100644
--- a/src/cache.h
+++ b/src/cache.h
@@ -11,16 +11,15 @@
 
 namespace Bu
 {
-        template<class obtype> class Cache;
-        template<class obtype> long getCacheId( const obtype *o );
-
         template<class obtype>
         class Cache
         {
         friend class Bu::CPtr<obtype>;
-        typedef Bu::CPtr<obtype> Ptr;
+                typedef Bu::CPtr<obtype> Ptr;
+                typedef Bu::CacheHandler<obtype> Handler;
+                typedef Bu::List<Handler *> HandlerList;
         public:
-                typedef long cid;       /**< Cache ID type. Unique cache entry ID. */
+                typedef long cid_t;     /**< Cache ID type. Unique cache entry ID. */
 
         public:
                 Cache()
@@ -31,19 +30,19 @@ namespace Bu
                 virtual ~Cache()
                 {
                         TRACE();
-                        for( HandlerList::iterator i = lHandler.begin();
+/*                      for( HandlerList::iterator i = lHandler.begin();
                                  i != lHandler.end(); i++ )
                         {
                                 delete *i;
                         }
-                }
+*/              }
 
-                void appendHandler( CacheHandler *pHand )
+                void appendHandler( Handler *pHand )
                 {
                         lHandler.append( pHand );
                 }
 
-                void prependHandler( CacheHandler *pHand )
+                void prependHandler( Handler *pHand )
                 {
                         lHandler.prepend( pHand );
                 }
@@ -52,33 +51,33 @@ namespace Bu
                 {
                         TRACE();
                         CacheEntry e = {pData, 0};
-                        hEnt.insert( getCacheId( pData ), e );
+                        hEnt.insert( /*pData*/ 0 , e );
                         return Ptr( *this, pData );
                 }
 
-                Ptr get( cid cId )
+                Ptr get( cid_t cId )
                 {
                         TRACE();
                         return Ptr( *this, hEnt.get( cId ).pData );
                 }
 
-                int getRefCnt( cid cId )
+                int getRefCnt( cid_t cId )
                 {
                         TRACE();
                         return hEnt.get( cId ).iRefs;
                 }
 
         private:
-                void incRef( obtype *pData )
+                void incRef( cid_t cId )
                 {
                         TRACE();
-                        hEnt.get( getCacheId( pData ) ).iRefs++;
+                        hEnt.get( cId ).iRefs++;
                 }
 
-                void decRef( obtype *pData )
+                void decRef( cid_t cId )
                 {
                         TRACE();
-                        CacheEntry &e = hEnt.get( getCacheId( pData ) );
+                        CacheEntry &e = hEnt.get( cId );
                         e.iRefs--;
                 }
 
@@ -90,10 +89,9 @@ namespace Bu
                 } CacheEntry;
 
                 //typedef Bu::Hash<ptrdiff_t, int> RefHash;
-                typedef Bu::Hash<cid, CacheEntry> CidHash;
+                typedef Bu::Hash<cid_t, CacheEntry> CidHash;
                 //RefHash hRefs;
                 CidHash hEnt;
-                typedef Bu::List<CacheHandler *> HandlerList;
                 HandlerList lHandler;
         };
 };
diff --git a/src/cachehandler.cpp b/src/cachehandler.cpp
index efd12e7..d208e98 100644
--- a/src/cachehandler.cpp
+++ b/src/cachehandler.cpp
@@ -1,10 +1,2 @@
 #include "bu/cachehandler.h"
 
-Bu::CacheHandler::CacheHandler()
-{
-}
-
-Bu::CacheHandler::~CacheHandler()
-{
-}
-
diff --git a/src/cachehandler.h b/src/cachehandler.h
index 6ce1471..3b26970 100644
--- a/src/cachehandler.h
+++ b/src/cachehandler.h
@@ -1,15 +1,31 @@
 #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 void load()=0;
-                virtual void unload()=0;
+                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:
         };
diff --git a/src/cptr.h b/src/cptr.h
index 5aafbd3..6e54fdd 100644
--- a/src/cptr.h
+++ b/src/cptr.h
@@ -5,22 +5,29 @@ namespace Bu
 {
         template<class obtype> 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>
         class CPtr
         {
         friend class Bu::Cache<obtype>;
+        public:
+                typedef long cid_t;     /**< Cache ID type. Unique cache entry ID. */
         private:
                 CPtr( Cache<obtype> &rCache, obtype *pData ) :
                         rCache( rCache ),
                         pData( pData )
                 {
-                        rCache.incRef( pData );
+                        rCache.incRef( cId );
                 }
 
         public:
                 virtual ~CPtr()
                 {
-                        rCache.decRef( pData );
+                        rCache.decRef( cId );
                 }
 
                 obtype &operator*()
@@ -36,6 +43,7 @@ namespace Bu
         private:
                 Bu::Cache<obtype> &rCache;
                 obtype *pData;
+                cid_t cId;
         };
 };
 
diff --git a/src/tests/cache.cpp b/src/tests/cache.cpp
index f05de57..55ec5be 100644
--- a/src/tests/cache.cpp
+++ b/src/tests/cache.cpp
@@ -1,9 +1,8 @@
 #include <stdio.h>
 
 #include "bu/cache.h"
-#include "bu/cachable.h"
 
-class Bob : public Bu::Cachable
+class Bob
 {
 public:
         Bob()
@@ -36,24 +35,55 @@ public:
         int iInt;
 };
 
-DECL_CACHABLE( Bob );
-DEF_CACHABLE( Bob );
+class BobHandler : public Bu::CacheHandler<Bob>
+{
+public:
+        BobHandler() :
+                cLastId( 0 )
+        {
+        }
+
+        ~BobHandler()
+        {
+        }
+
+        virtual Bu::CPtr<Bob> load()
+        {
+        }
+
+        virtual void unload( Bu::CPtr<Bob> pObj )
+        {
+        }
+
+        virtual Bu::CPtr<Bob> create()
+        {
+        }
+
+        virtual Bu::CPtr<Bob> create( Bob &rSrc )
+        {
+        }
+
+        virtual void destroy( Bu::CPtr<Bob> pObj )
+        {
+        }
+
+private:
+        Bu::Cache<Bob>::cid_t cLastId;
+};
 
 int main()
 {
-        Bu::Cache<Bob> bobCache;
+        typedef Bu::Cache<Bob> BobCache;
+        typedef Bu::CPtr<Bob> BobPtr;
 
-        Bu::CPtr<Bob> pB1 = bobCache.insert( new Bob() );
+        BobCache bobCache;
 
+        BobPtr pB1 = bobCache.insert( new Bob() );
         (*pB1).setInt( 44 );
-        
         printf("RefCnt = %d\n", bobCache.getRefCnt( 0 ) );
 
-        Bu::CPtr<Bob> pB2 = bobCache.get( 0 );
-        
+        BobPtr pB2 = bobCache.get( 0 );
         printf("RefCnt = %d\n", bobCache.getRefCnt( 0 ) );
-
         printf("Int = %d\n", pB2->getInt() );
-
 }