6 files changed, 727 insertions, 4 deletions

diff --git a/src/experimental/cache.cpp b/src/unstable/cachebase.cpp
index 840682a..69b378e 100644
--- a/src/experimental/cache.cpp
+++ b/src/unstable/cachebase.cpp
@@ -5,4 +5,4 @@
  * terms of the license contained in the file LICENSE.
  */
 
-#include "bu/cache.h"
+#include "bu/cachebase.h"
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
diff --git a/src/experimental/cachestore.cpp b/src/unstable/cacheobject.cpp
index 2082a50..eedb645 100644
--- a/src/experimental/cachestore.cpp
+++ b/src/unstable/cacheobject.cpp
@@ -5,5 +5,4 @@
  * terms of the license contained in the file LICENSE.
  */
 
-#include "bu/cachestore.h"
-
+#include "bu/cacheobject.h"
diff --git a/src/unstable/cacheobject.h b/src/unstable/cacheobject.h
new file mode 100644
index 0000000..0088685
--- /dev/null
+++ b/src/unstable/cacheobject.h
@@ -0,0 +1,84 @@
+/*
+ * 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_OBJECT_H
+#define BU_CACHE_OBJECT_H
+
+#ifndef NULL
+#define NULL 0
+#endif
+
+namespace Bu
+{
+    template<typename keytype, typename obtype> class CacheBase;
+    template<typename keytype, typename obtype> class CacheEntry;
+
+    template<typename keytype, typename obtype>
+    class CacheObject
+    {
+    friend class CacheBase<keytype, obtype>;
+    public:
+        CacheObject() :
+            pCache( NULL ),
+            bChanged( false )
+        {
+        }
+
+        virtual ~CacheObject()
+        {
+        }
+
+        typedef CacheBase<keytype, obtype> CacheType;
+
+        virtual keytype getKey() const=0;
+        virtual int getPersistenceScore() const { return 0; }
+
+        void lock()
+        {
+            pEntry->lock();
+        }
+
+        void unlock()
+        {
+            pEntry->unlock();
+        }
+
+        int getRefCount() const
+        {
+            return pEntry->getRefCount();
+        }
+
+        bool hasChanged() const
+        {
+            return bChanged;
+        }
+
+    protected:
+        void changed( bool bChanged=true )
+        {
+            if( this->bChanged == false && bChanged == true )
+                pCache->objectChanged( getKey() );
+
+            this->bChanged = bChanged;
+        }
+
+    private:
+        typedef CacheEntry<keytype, obtype> Entry;
+        void setCache( CacheType *pCache, Entry *pEntry )
+        {
+            this->pCache = pCache;
+            this->pEntry = pEntry;
+        }
+
+    private:
+        CacheType *pCache;
+        Entry *pEntry;
+        bool bChanged;
+    };
+}
+
+#endif
diff --git a/src/experimental/cachecalc.cpp b/src/unstable/myriadcache.cpp
index 7e2940c..0a997f8 100644
--- a/src/experimental/cachecalc.cpp
+++ b/src/unstable/myriadcache.cpp
@@ -5,4 +5,4 @@
  * terms of the license contained in the file LICENSE.
  */
 
-#include "bu/cachecalc.h"
+#include "bu/myriadcache.h"
diff --git a/src/unstable/myriadcache.h b/src/unstable/myriadcache.h
new file mode 100644
index 0000000..f8c0e00
--- /dev/null
+++ b/src/unstable/myriadcache.h
@@ -0,0 +1,126 @@
+/*
+ * 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_MYRIAD_CACHE_H
+#define BU_MYRIAD_CACHE_H
+
+#include "bu/cachebase.h"
+#include "bu/myriad.h"
+#include "bu/myriadstream.h"
+#include "bu/file.h"
+#include "bu/streamstack.h"
+
+namespace Bu
+{
+    template<typename keytype, typename obtype>
+    class MyriadCache : public Bu::CacheBase<keytype, obtype>
+    {
+    public:
+        MyriadCache( Bu::Stream &sStore, int iBlockSize=512, int iPreallocate=8 ) :
+            sStore( sStore ),
+            mStore( sStore, iBlockSize, iPreallocate ),
+            bStructureChanged( false )
+        {
+            try
+            {
+                Bu::ReadWriteMutex::ReadLocker l( rwStore );
+                Bu::MyriadStream ms = mStore.openStream( 1 );
+                Bu::Archive ar( ms, Bu::Archive::load );
+                uint8_t uVer;
+                ar >> uVer;
+                switch( uVer )
+                {
+                    case 0:
+                        ar >> hIndex;
+                        break;
+                }
+            }
+            catch(...)
+            {
+                if( mStore.createStreamWithId( 1 ) != 1 )
+                    throw Bu::ExceptionBase("Error creating index stream.");
+
+                _sync();
+            }
+        }
+
+        virtual ~MyriadCache()
+        {
+            _sync();
+        }
+       
+        using typename Bu::CacheBase<keytype,obtype>::KeyList;
+        
+        virtual KeyList getKeys() const
+        {
+            Bu::ReadWriteMutex::ReadLocker rl( rwStore );
+            return hIndex.getKeys();
+        }
+        
+        virtual int getSize() const
+        {
+            Bu::ReadWriteMutex::ReadLocker rl( rwStore );
+            return hIndex.getSize();
+        }
+
+    protected:
+        virtual void _create( const obtype *o )
+        {
+            Bu::ReadWriteMutex::WriteLocker wl( rwStore );
+            hIndex.insert( o->getKey(), mStore.createStream() );
+            _save( o );
+
+            bStructureChanged = true;
+        }
+
+        virtual void _erase( const keytype &k )
+        {
+            Bu::ReadWriteMutex::WriteLocker wl( rwStore );
+            mStore.deleteStream( hIndex.get( k ) );
+            hIndex.erase( k );
+
+            bStructureChanged = true;
+        }
+
+        virtual obtype *_load( const keytype &k )
+        {
+            Bu::MyriadStream ms = mStore.openStream( hIndex.get( k ) );
+            return _cacheObjectLoad<obtype>( ms );
+        }
+
+        virtual void _save( const obtype *o )
+        {
+            Bu::MyriadStream ms = mStore.openStream( hIndex.get( o->getKey() ) );
+            _cacheObjectSave( ms, o );
+            ms.setSize( ms.tell() );
+        }
+
+        virtual void _sync()
+        {
+            Bu::ReadWriteMutex::ReadLocker wl( rwStore );
+            if( !bStructureChanged )
+                return;
+
+            Bu::MyriadStream ms = mStore.openStream( 1 );
+            Bu::Archive ar( ms, Bu::Archive::save );
+            ar << (uint8_t)0 << hIndex;
+            ar.close();
+            ms.setSize( ms.tell() );
+
+            bStructureChanged = false;
+        }
+
+    private:
+        Bu::Stream &sStore;
+        Bu::Myriad mStore;
+        Bu::Hash<keytype, int> hIndex;
+        mutable Bu::ReadWriteMutex rwStore;
+        bool bStructureChanged;
+    };
+}
+
+#endif