1 files changed, 126 insertions, 0 deletions

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