The new cache system has been broken out into it's individual headers, and is

now ready for actual use.

1 files changed, 514 insertions, 0 deletions

diff --git a/src/unstable/cachebase.h b/src/unstable/cachebase.h
new file mode 100644
index 0000000..807adf0
--- /dev/null
+++ b/src/unstable/cachebase.h
@@ -0,0 +1,514 @@
+/*
+ * Copyright (C) 2007-2013 Xagasoft, All rights reserved.
+ *
+ * This file is part of the libbu++ library and is released under the
+ * terms of the license contained in the file LICENSE.
+ */
+
+#ifndef BU_CACHE_BASE_H
+#define BU_CACHE_BASE_H
+
+#include "bu/string.h"
+#include "bu/archive.h"
+#include "bu/hash.h"
+#include "bu/readwritemutex.h"
+#include "bu/mutexlocker.h"
+#include "bu/cacheobject.h"
+
+namespace Bu
+{
+    template<typename keytype, typename obtype> class CacheBase;
+    template<typename keytype, typename obtype> class CacheEntry;
+        
+    template<typename keytype, typename obtype>
+    class CacheEntry
+    {
+    friend class CacheBase<keytype, obtype>;
+    private:
+        CacheEntry( obtype *pObject ) :
+            iRefCount( 0 ),
+            pObject( pObject )
+        {
+        }
+
+    public:
+        int getRefCount() const
+        {
+            mEntry.lock();
+            int ret = iRefCount;
+            mEntry.unlock();
+            return ret;
+        }
+
+        obtype *getPtr() const
+        {
+            return pObject;
+        }
+
+        void lock() const
+        {
+            mObject.lock();
+        }
+
+        void unlock() const
+        {
+            mObject.unlock();
+        }
+
+        Bu::Mutex &getMutex()
+        {
+            return mObject;
+        }
+
+        void incRef()
+        {
+            mEntry.lock();
+            iRefCount++;
+            mEntry.unlock();
+        }
+
+        bool decRef()
+        {
+            mEntry.lock();
+            iRefCount--;
+            bool bRet = iRefCount > 0;
+            mEntry.unlock();
+            return bRet;
+        }
+
+    private:
+        mutable Bu::Mutex mEntry;
+        mutable Bu::Mutex mObject;
+        int iRefCount;
+        obtype *pObject;
+    };
+
+    template<typename keytype, typename basetype>
+    class CachePtrInterface
+    {
+    protected:
+        CachePtrInterface()
+        {
+        }
+
+        virtual ~CachePtrInterface()
+        {
+        }
+        
+        template<typename obtype>
+        void checkRef( CacheBase<keytype, basetype> *pCache,
+                const keytype &kId,
+                CacheEntry<keytype, basetype> * &rpEnt,
+                obtype * &rpData )
+        {
+            if( pCache == NULL )
+                throw Bu::ExceptionBase("Invalid pointer");
+
+            if( !rpData )
+            {
+                rpEnt = pCache->getRef( kId );
+                rpEnt->incRef();
+                rpData = dynamic_cast<obtype *>(rpEnt->getPtr());
+                if( rpData == NULL )
+                {
+                    rpEnt->decRef();
+                    rpEnt = NULL;
+                    throw std::bad_cast();
+                }
+            }
+        }
+
+        template<typename obtype>
+        void releaseRef( CacheBase<keytype, basetype> *pCache,
+                CacheEntry<keytype, basetype> * &rpEnt,
+                obtype * &rpData )
+        {
+            if( pCache == NULL )
+                return;
+
+            if( rpData == NULL )
+                return;
+
+            rpData = NULL;
+            rpEnt->decRef();
+            pCache->releaseRef( rpEnt );
+            rpEnt = NULL;
+        }
+    };
+
+    template<typename keytype, typename obtype, typename basetype=obtype>
+    class CachePtr : protected CachePtrInterface<keytype, basetype>
+    {
+    friend class CacheBase<keytype, basetype>;
+    private:
+        typedef CachePtr<keytype, obtype, basetype> MyType;
+
+        CachePtr( CacheBase<keytype, basetype> *pCache,
+                CacheEntry<keytype, basetype> *pEnt,
+                const keytype &kId ) :
+            pCache( pCache ),
+            kId( kId ),
+            pEnt( pEnt ),
+            pData( NULL )
+        {
+            pEnt->incRef();
+            pData = dynamic_cast<obtype *>( pEnt->getPtr() );
+            if( pData == NULL )
+            {
+                pEnt->decRef();
+                throw std::bad_cast();
+            }
+        }
+
+        CachePtr( CacheBase<keytype, basetype> *pCache, const keytype &kId ) :
+            pCache( pCache ),
+            kId( kId ),
+            pEnt( NULL ),
+            pData( NULL )
+        {
+        }
+
+    public:
+        CachePtr() :
+            pCache( NULL ),
+            pEnt( NULL ),
+            pData( NULL )
+        {
+        }
+
+        CachePtr( const MyType &rhs ) :
+            pCache( rhs.pCache ),
+            kId( rhs.kId ),
+            pEnt( rhs.pEnt ),
+            pData( rhs.pData )
+        {
+            pEnt->incRef();
+        }
+
+        virtual ~CachePtr()
+        {
+            unbind();
+        }
+
+        const keytype &getKey() const
+        {
+            return kId;
+        }
+
+        obtype &operator*()
+        {
+            bind();
+            return pData;
+        }
+        
+        const obtype &operator*() const
+        {
+            bind();
+            return pData;
+        }
+
+        obtype *operator->()
+        {
+            bind();
+            return pData;
+        }
+        
+        const obtype *operator->() const
+        {
+            bind();
+            return pData;
+        }
+
+        MyType operator=( const MyType &rhs )
+        {
+            unbind();
+            pCache = rhs.pCache;
+            kId = rhs.kId;
+            pEnt = rhs.pEnt;
+            pData = rhs.pData;
+            pEnt->incRef();
+
+            return *this;
+        }
+        
+        template<typename castto>
+        CachePtr<keytype, castto, basetype> cast()
+        {
+            return pCache->cast<obtype, castto>( *this );
+        }
+        
+        bool operator==( const MyType &rhs ) const
+        {
+            return pCache == rhs.pCache &&
+                kId == rhs.kId;
+        }
+        
+        bool operator!=( const MyType &rhs ) const
+        {
+            return pCache != rhs.pCache ||
+                kId != rhs.kId;
+        }
+        
+        void bind()
+        {
+            CachePtrInterface<keytype, basetype>::checkRef( pCache, kId, pEnt, pData );
+        }
+
+        void unbind()
+        {
+            CachePtrInterface<keytype, basetype>::releaseRef( pCache, pEnt, pData );
+        }
+
+        void lock()
+        {
+            bind();
+            if( pEnt )
+                pEnt->lock();
+        }
+
+        void unlock()
+        {
+            bind();
+            if( pEnt )
+                pEnt->unlock();
+        }
+
+        class Locker
+        {
+        public:
+            Locker( MyType &rPtr ) :
+                rPtr( rPtr ),
+                bLocked( true )
+            {
+                rPtr.lock();
+            }
+
+            ~Locker()
+            {
+                unlock();
+            }
+
+            void unlock()
+            {
+                if( !bLocked )
+                    return;
+                rPtr.unlock();
+                bLocked = false;
+            }
+
+        private:
+            MyType &rPtr;
+            bool bLocked;
+        };
+
+    private:
+        CacheBase<keytype, basetype> *pCache;
+        mutable keytype kId;
+        mutable CacheEntry<keytype, basetype> *pEnt;
+        mutable obtype *pData;
+    };
+
+    template<typename keytype, typename obtype>
+    class CacheBase
+    {
+    friend class CachePtrInterface<keytype, obtype>;
+    friend class CacheObject<keytype, obtype>;
+    public:
+        CacheBase()
+        {
+        }
+
+        virtual ~CacheBase()
+        {
+            Bu::ReadWriteMutex::WriteLocker wl( mCacheEntry );
+            syncChanges();
+        }
+
+        typedef CacheEntry<keytype, obtype> Entry;
+        typedef Bu::List<keytype> KeyList;
+
+        CachePtr<keytype, obtype> insert( obtype *pObject )
+        {
+            Entry *pEnt = addEntry( pObject );
+
+            return CachePtr<keytype, obtype>(
+                this, pEnt, pObject->getKey()
+                );
+        }
+
+        template<typename supertype>
+        CachePtr<keytype, supertype, obtype> insert( supertype *pObject )
+        {
+            obtype *pCast = dynamic_cast<obtype *>( pObject );
+            if( pCast == NULL )
+                throw std::bad_cast();
+
+            Entry *pEnt = addEntry( pCast );
+
+            return CachePtr<keytype, supertype, obtype>(
+                this, pEnt, pObject->getKey()
+                );
+        }
+
+        CachePtr<keytype, obtype> get( const keytype &key )
+        {
+            Entry *pEnt = getEntry( key );
+            return CachePtr<keytype, obtype>( this, pEnt, key );
+        }
+
+        template<typename supertype>
+        CachePtr<keytype, supertype, obtype> get( const keytype &key )
+        {
+            Entry *pEnt = getEntry( key );
+            return CachePtr<keytype, supertype, obtype>( this, pEnt, key );
+        }
+
+        CachePtr<keytype, obtype> getLazy( const keytype &key )
+        {
+            return CachePtr<keytype, obtype>( this, key );
+        }
+
+        template<typename supertype>
+        CachePtr<keytype, supertype, obtype> getLazy( const keytype &key )
+        {
+            return CachePtr<keytype, supertype, obtype>( this, key );
+        }
+
+        template<typename supertype, typename castto>
+        CachePtr<keytype, castto, obtype> cast( CachePtr<keytype, supertype, obtype> &ptr )
+        {
+            if( ptr.pEnt )
+                return CachePtr<keytype, castto, obtype>( this, ptr.pEnt, ptr.kId );
+            else
+                return CachePtr<keytype, castto, obtype>( this, ptr.kId );
+        }
+
+        void erase( const keytype &key )
+        {
+            Bu::ReadWriteMutex::WriteLocker wl( mCacheEntry );
+            if( hCacheEntry.has( key ) )
+            {
+                Entry *pEnt = hCacheEntry.get( key );
+                pEnt->mEntry.lock();
+                if( pEnt->iRefCount > 0 )
+                {
+                    int iCount = pEnt->iRefCount;
+                    pEnt->mEntry.unlock();
+                    throw Bu::ExceptionBase( Bu::String("Cache entry %1 cannot be erased, there are %2 active references.").arg( key ).arg( iCount ).end().getStr() );
+                }
+                delete pEnt->pObject;
+                delete pEnt;
+                hCacheEntry.erase( key );
+            }
+            _erase( key );
+        }
+
+        virtual KeyList getKeys() const=0;
+        virtual int getSize() const=0;
+
+        void sync()
+        {
+            Bu::ReadWriteMutex::WriteLocker wl( mCacheEntry );
+            _sync();
+            syncChanges();
+        }
+
+    protected:
+        Entry *getRef( const keytype &k )
+        {
+            Entry *pEnt = getEntry( k );
+            return pEnt;
+        }
+
+        void releaseRef( Entry * )//pEnt )
+        {
+        }
+
+        void objectChanged( const keytype &k )
+        {
+            Bu::ReadWriteMutex::WriteLocker wl( mCacheEntry );
+            hChanged.insert( k, true );
+        }
+
+    protected:
+        virtual void _create( const obtype *o )=0;
+        virtual void _erase( const keytype &k )=0;
+
+        virtual obtype *_load( const keytype &k )=0;
+        virtual void _save( const obtype *o )=0;
+
+        virtual void _sync()=0;
+
+    private:
+        Entry *addEntry( obtype *pObject )
+        {
+            Entry *pEnt = new Entry( pObject );
+            mCacheEntry.lockWrite();
+            hCacheEntry.insert( pObject->getKey(), pEnt );
+            mCacheEntry.unlockWrite();
+            _create( pObject );
+            pObject->setCache( this, pEnt );
+            
+            return pEnt;
+        }
+
+        Entry *getEntry( const keytype &k )
+        {
+            Entry *pEnt = NULL;
+            try
+            {
+                Bu::ReadWriteMutex::ReadLocker rl( mCacheEntry );
+                pEnt = hCacheEntry.get( k );
+            }
+            catch(...)
+            {
+                // try to load the object from the backing store
+                obtype *pObject = _load( k );
+                pEnt = new Entry( pObject );
+                pObject->setCache( this, pEnt );
+                Bu::ReadWriteMutex::WriteLocker wl( mCacheEntry );
+                hCacheEntry.insert( k, pEnt );
+            }
+            return pEnt;
+        }
+
+        void syncChanges()
+        {
+            if( !hChanged.isEmpty() )
+            {
+                for( typename CacheKeySet::iterator i = hChanged.begin(); i; i++ )
+                {
+                    Entry *pEnt = hCacheEntry.get( i.getKey() );
+                    Bu::MutexLocker ml( pEnt->getMutex() );
+                    _save( pEnt->getPtr() );
+                }
+                hChanged.clear();
+            }
+        }
+
+    private:
+        typedef Bu::Hash<keytype, Entry *> CacheEntryHash;
+        typedef Bu::Hash<keytype, bool> CacheKeySet;
+        CacheEntryHash hCacheEntry;
+        CacheKeySet hChanged;
+        Bu::ReadWriteMutex mCacheEntry;
+    };
+
+    template<typename obtype>
+    void _cacheObjectSave( Bu::Stream &s, obtype *pObject )
+    {
+        Bu::Archive ar( s, Bu::Archive::save );
+        ar << *pObject;
+    }
+
+    template<typename obtype>
+    obtype *_cacheObjectLoad( Bu::Stream &s )
+    {
+        Bu::Archive ar( s, Bu::Archive::load );
+        obtype *ret = new obtype();
+        ar >> *ret;
+        return ret;
+    }
+}
+
+#endif