More cache development. I'm going to have to switch from template functions to

functors.  I like template functions a little more, but functors can be at
least as fast.  It won't be much of a change.

6 files changed, 126 insertions, 4 deletions

diff --git a/src/cachable.cpp b/src/cachable.cpp
new file mode 100644
index 0000000..7fa2d23
--- /dev/null
+++ b/src/cachable.cpp
@@ -0,0 +1,15 @@
+#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
new file mode 100644
index 0000000..529da6f
--- /dev/null
+++ b/src/cachable.h
@@ -0,0 +1,19 @@
+#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 );
+};
+
+#endif
diff --git a/src/cache.h b/src/cache.h
index 24ef652..344d1c6 100644
--- a/src/cache.h
+++ b/src/cache.h
@@ -1,20 +1,69 @@
 #ifndef BU_CACHE_H
 #define BU_CACHE_H
 
+#include "bu/cptr.h"
+#include "bu/hash.h"
+
+#define BU_TRACE
+#include "bu/trace.h"
+
 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;
+        public:
+                typedef long cid;       /**< Cache ID type. Unique cache entry ID. */
+
         public:
                 Cache()
                 {
+                        TRACE();
                 }
 
                 virtual ~Cache()
                 {
+                        TRACE();
+                }
+
+                Ptr insert( obtype *pData )
+                {
+                        TRACE();
+                        CacheEntry e = {pData, 0};
+                        hEnt.insert( getCacheId( pData ), e );
+                        return Ptr( *this, pData );
                 }
 
+        private:
+                void incRef( obtype *pData )
+                {
+                        TRACE();
+                        hEnt.get( getCacheId( pData ) ).iRefs++;
+                }
+
+                void decRef( obtype *pData )
+                {
+                        TRACE();
+                        CacheEntry &e = hEnt.get( getCacheId( pData ) );
+                        e.iRefs--;
+                }
+
+        private:
+                typedef struct CacheEntry
+                {
+                        obtype *pData;
+                        int iRefs;
+                } CacheEntry;
+
+                //typedef Bu::Hash<ptrdiff_t, int> RefHash;
+                typedef Bu::Hash<cid, CacheEntry> CidHash;
+                //RefHash hRefs;
+                CidHash hEnt;
         };
 };
 
diff --git a/src/cptr.h b/src/cptr.h
index 1f8c43d..138ace8 100644
--- a/src/cptr.h
+++ b/src/cptr.h
@@ -1,23 +1,31 @@
 #ifndef BU_C_PTR_H
 #define BU_C_PTR_H
 
-#include "bu/cache.h"
-
 namespace Bu
 {
+        template<class obtype> class Cache;
+
         template<class obtype>
         class CPtr
         {
         friend class Bu::Cache<obtype>;
         private:
-                CPtr( Cache<obtype> &rCache, obtype &rData )
+                CPtr( Cache<obtype> &rCache, obtype *pData ) :
+                        rCache( rCache ),
+                        pData( pData )
                 {
+                        rCache.incRef( pData );
                 }
 
         public:
                 virtual ~CPtr()
                 {
+                        rCache.decRef( pData );
                 }
+
+        private:
+                Bu::Cache<obtype> &rCache;
+                obtype *pData;
         };
 };
 
diff --git a/src/membuf.cpp b/src/membuf.cpp
index e7c7ac8..f22a8de 100644
--- a/src/membuf.cpp
+++ b/src/membuf.cpp
@@ -52,7 +52,7 @@ size_t Bu::MemBuf::write( const void *pBuf, size_t nBytes )
         {
                 // Trickier, we must do this in two parts, overwrite, then append
                 // Frist, overwrite.
-                int iOver = sBuf.getSize() - nPos;
+                size_t iOver = sBuf.getSize() - nPos;
                 if( iOver > nBytes )
                         iOver = nBytes;
                 memcpy( sBuf.getStr()+nPos, pBuf, iOver );
diff --git a/src/tests/cache.cpp b/src/tests/cache.cpp
new file mode 100644
index 0000000..e51c31b
--- /dev/null
+++ b/src/tests/cache.cpp
@@ -0,0 +1,31 @@
+#include <stdio.h>
+
+#include "bu/cache.h"
+#include "bu/cachable.h"
+
+class Bob : public Bu::Cachable
+{
+public:
+        Bob()
+        {
+        }
+
+        virtual ~Bob()
+        {
+        }
+
+        long getCacheId() const
+        {
+                return 0;
+        }
+
+        int iInt;
+};
+
+int main()
+{
+        Bu::Cache<Bob> bobCache;
+
+//      Bu::CPtr<Bob> pB = bobCache.insert( new Bob() );
+}
+