Deferred erase now works on cache entries. You can erase a cache entry while

it still has active references, and it will be safely cleaned up when the last
reference is released.

6 files changed, 392 insertions, 12 deletions

diff --git a/src/stable/array.h b/src/stable/array.h
index a598865..a662705 100644
--- a/src/stable/array.h
+++ b/src/stable/array.h
@@ -297,6 +297,30 @@ namespace Bu
             return core->iSize;
         }
 
+        void setSize( long iNewLen, const value &initTo=value() )
+        {
+            if( core->iSize == iNewLen )
+                return;
+
+            _hardCopy();
+            if( iNewLen > core->iCapacity )
+            {
+                core->setCapacity( iNewLen );
+                for( int j = core->iSize; j < iNewLen; j++ )
+                {
+                    core->va.construct(
+                        &core->pData[j],
+                        initTo
+                        );
+                }
+                core->iSize = iNewLen;
+            }
+            else
+            {
+                core->iSize = iNewLen;
+            }
+        }
+
         /**
          * Get the capacity of the array.  This number will grow as data is
          * added, and is mainly for the curious, it doesn't really determine
diff --git a/src/stable/file.cpp b/src/stable/file.cpp
index b551d24..35933f1 100644
--- a/src/stable/file.cpp
+++ b/src/stable/file.cpp
@@ -240,7 +240,7 @@ void Bu::File::setSize( Bu::size iSize )
 
 Bu::size Bu::File::getSize() const
 {
-    struct stat st;
+    struct ::stat st;
     fstat( fd, &st );
     return st.st_size;
 }
@@ -250,7 +250,7 @@ Bu::size Bu::File::getBlockSize() const
 #ifdef WIN32
     return 4096;
 #else
-    struct stat st;
+    struct ::stat st;
     fstat( fd, &st );
     return st.st_blksize;
 #endif
@@ -261,6 +261,11 @@ Bu::String Bu::File::getLocation() const
     return "to be implemented";
 }
 
+void Bu::File::stat( struct ::stat *pStat )
+{
+    fstat( fd, pStat );
+}
+
 #ifndef WIN32
 void Bu::File::chmod( mode_t t )
 {
diff --git a/src/stable/file.h b/src/stable/file.h
index ad60e80..e3497d3 100644
--- a/src/stable/file.h
+++ b/src/stable/file.h
@@ -15,6 +15,8 @@
 #include "bu/string.h"
 #include "bu/exceptionbase.h"
 
+struct stat;
+
 namespace Bu
 {
     subExceptionDecl( FileException );
@@ -76,6 +78,8 @@ namespace Bu
         virtual size getBlockSize() const;
         virtual Bu::String getLocation() const;
 
+        void stat( struct ::stat *pStat );
+
         /**
          * Create a temp file and return its handle.  The file is opened 
          * Read/Write.
diff --git a/src/tests/cachedel.cpp b/src/tests/cachedel.cpp
new file mode 100644
index 0000000..817757c
--- /dev/null
+++ b/src/tests/cachedel.cpp
@@ -0,0 +1,288 @@
+#include "bu/myriadcache.h"
+#include "bu/uuid.h"
+#include "bu/string.h"
+#include "bu/sio.h"
+#include "bu/membuf.h"
+
+class Something : public Bu::CacheObject<Bu::Uuid, Something>
+{
+friend Bu::ArchiveBase &operator>>( Bu::ArchiveBase &ar, Something &s );
+friend Bu::ArchiveBase &operator<<( Bu::ArchiveBase &ar, const Something &s );
+public:
+    Something()
+    {
+    }
+    
+    Something( const Bu::String &sName ) :
+        uId( Bu::Uuid::generate() ),
+        sName( sName )
+    {
+    }
+
+    virtual ~Something()
+    {
+    }
+
+    virtual Bu::Uuid getKey() const
+    {
+        return uId;
+    }
+
+    Bu::String getName() const
+    {
+        return sName;
+    }
+
+    void setName( const Bu::String &sNewName )
+    {
+        sName = sNewName;
+        changed();
+    }
+
+    virtual Bu::String toString() const=0;
+
+private:
+    Bu::Uuid uId;
+    Bu::String sName;
+};
+
+class SubSomethingA : public Something
+{
+friend Bu::ArchiveBase &operator>>( Bu::ArchiveBase &ar, SubSomethingA &s );
+friend Bu::ArchiveBase &operator<<( Bu::ArchiveBase &ar, const SubSomethingA &s );
+public:
+    SubSomethingA()
+    {
+    }
+
+    SubSomethingA( const Bu::String &sName, int iNumber ) :
+        Something( sName ),
+        iNumber( iNumber )
+    {
+    }
+    
+    virtual Bu::String toString() const
+    {
+        return Bu::String("[typeA] %1 (%2)").arg( getName() ).arg( iNumber );
+    }
+
+private:
+    int iNumber;
+};
+
+class SubSomethingB : public Something
+{
+friend Bu::ArchiveBase &operator>>( Bu::ArchiveBase &ar, SubSomethingB &s );
+friend Bu::ArchiveBase &operator<<( Bu::ArchiveBase &ar, const SubSomethingB &s );
+public:
+    SubSomethingB()
+    {
+    }
+
+    SubSomethingB( const Bu::String &sName, const Bu::String &sString ) :
+        Something( sName ),
+        sString( sString )
+    {
+    }
+    
+    virtual Bu::String toString() const
+    {
+        return Bu::String("[typeB] %1 (%2)").arg( getName() ).arg( sString );
+    }
+
+private:
+    Bu::String sString;
+};
+
+Bu::ArchiveBase &operator>>( Bu::ArchiveBase &ar, Something &s )
+{
+    return ar >> s.uId >> s.sName;
+}
+
+Bu::ArchiveBase &operator<<( Bu::ArchiveBase &ar, const Something &s )
+{
+    return ar << s.uId << s.sName;
+}
+
+Bu::ArchiveBase &operator>>( Bu::ArchiveBase &ar, SubSomethingA &s )
+{
+    return ar >> (Something &)s >> s.iNumber;
+}
+
+Bu::ArchiveBase &operator<<( Bu::ArchiveBase &ar, const SubSomethingA &s )
+{
+    return ar << (Something &)s << s.iNumber;
+}
+
+Bu::ArchiveBase &operator>>( Bu::ArchiveBase &ar, SubSomethingB &s )
+{
+    return ar >> (Something &)s >> s.sString;
+}
+
+Bu::ArchiveBase &operator<<( Bu::ArchiveBase &ar, const SubSomethingB &s )
+{
+    return ar << (Something &)s << s.sString;
+}
+    
+namespace Bu
+{
+    template<>
+    void _cacheObjectSave<const Something>( Bu::Stream &s, const Something *pObject )
+    {
+        Bu::Archive ar( s, Bu::Archive::save );
+        if( typeid(*pObject) == typeid(SubSomethingA) )
+        {
+            ar << (uint8_t)1 << (SubSomethingA &)*pObject;
+        }
+        else if( typeid(*pObject) == typeid(SubSomethingB) )
+        {
+            ar << (uint8_t)2 << (SubSomethingB &)*pObject;
+        }
+        else
+        {
+            Bu::println("Not a recognized type!");
+            throw Bu::ExceptionBase("Not recognized type!");
+        }
+    }
+
+    template<>
+    Something *_cacheObjectLoad<Bu::Uuid, Something>( Bu::CacheObject<Bu::Uuid, Something>::Initializer &initObj, const Bu::Uuid &rKey, Bu::Stream &s )
+    {
+        Bu::Archive ar( s, Bu::Archive::load );
+        uint8_t uType;
+        ar >> uType;
+        switch( uType )
+        {
+            case 1:
+                {
+                    SubSomethingA *ret = initObj(new SubSomethingA());
+                    ar >> *ret;
+                    return ret;
+                }
+                break;
+
+            case 2:
+                {
+                    SubSomethingB *ret = initObj(new SubSomethingB());
+                    ar >> *ret;
+                    return ret;
+                }
+                break;
+
+            default:
+                throw Bu::ExceptionBase("Flagrant error! Invalid type!");
+        }
+
+        return NULL;
+    }
+}
+
+typedef Bu::CachePtr<Bu::Uuid, Something> SomethingPtr;
+typedef Bu::CachePtr<Bu::Uuid, SubSomethingA, Something> SomethingAPtr;
+typedef Bu::CachePtr<Bu::Uuid, SubSomethingB, Something> SomethingBPtr;
+typedef Bu::MyriadCache<Bu::Uuid, Something> SomethingCache;
+
+int main( int, char *[] )
+{
+    Bu::MemBuf mbStore;
+    SomethingCache c( mbStore );
+
+    SomethingPtr ptr;
+    if( time(NULL)%2 )
+        ptr = c.insert( new SubSomethingA("Hello", 55) ).cast<Something>();
+    else
+        ptr = c.insert( new SubSomethingB("Goodbye", "Things") ).cast<Something>();
+
+    Bu::Uuid id = ptr.getKey();
+    Bu::println("Something[%1]: %2").
+        arg( ptr.getKey() ).
+        arg( ptr->getName() );
+   
+    Bu::println("has %1: %2").arg( id ).arg( c.has( id ) );
+    c.erase( ptr.getKey() );
+    Bu::println("has %1: %2").arg( id ).arg( c.has( id ) );
+    SomethingPtr b = ptr;
+
+    SomethingPtr p2 = c.insert( new SubSomethingA("new test", 123) ).cast<Something>();
+    id = p2.getKey();
+    p2.unbind();
+    c.erase( id );
+
+    return 0;
+}
+
+/*
+int main( int argc, char *argv[] )
+{
+    Bu::File fStore("test.myr", Bu::File::Create|Bu::File::ReadWrite);
+    SomethingCache c( fStore );
+
+    for( int j = 1; j < argc; j++ )
+    {
+        SomethingPtr ptr = c.insert( new Something(argv[j]) );
+
+        Bu::println("Something[%1]: %2").
+            arg( ptr.getKey() ).
+            arg( ptr->getName() );
+    }
+    
+    SomethingCache::KeyList lKeys = c.getKeys();
+    Bu::println("Count: %1").arg( lKeys.getSize() );
+    int j = 0;
+    for( SomethingCache::KeyList::iterator i = lKeys.begin(); i; i++ )
+    {
+        Bu::println(" - %1: '%2'").arg( *i ).arg( c.get( *i )->getName() );
+        if( ((j++)%2) )
+            c.erase( *i );
+    }
+    Bu::println("Count: %1").arg( c.getSize() );
+
+    c._debug();
+
+    SomethingPtr p2;
+    SomethingPtr p1( c.get( lKeys.first() ) );
+
+    c._debug();
+
+    {
+        SomethingPtr p2( p1 );
+        c._debug();
+    }
+    
+    c._debug();
+
+    p2 = p1;
+    
+    c._debug();
+
+    p1.unbind();
+    
+    c._debug();
+
+    Bu::println("Name: %1").arg( p1->getName() );
+
+    p1.unbind();
+    p1.lock();
+    p1.unlock();
+    
+    c._debug();
+
+    SomethingPtr p3 = c.getLazy( lKeys.first() );
+
+    c._debug();
+
+    {
+    SomethingPtr::Locker l( p3 );
+
+    Bu::println("Name again: %1").arg( p3->getName() );
+
+    p3->setName( p3->getName() + " - again" );
+    }
+
+    c.sync();
+
+    c._debug();
+
+    return 0;
+}
+*/
diff --git a/src/unstable/cachebase.h b/src/unstable/cachebase.h
index 1584246..b17d377 100644
--- a/src/unstable/cachebase.h
+++ b/src/unstable/cachebase.h
@@ -29,6 +29,7 @@ namespace Bu
     private:
         CacheEntry( obtype *pObject ) :
             iRefCount( 0 ),
+            bDeleted( false ),
             pObject( pObject )
         {
         }
@@ -78,10 +79,29 @@ namespace Bu
             return bRet;
         }
 
+        bool isDeleted()
+        {
+            mEntry.lock();
+            bool bRet = bDeleted;
+            mEntry.unlock();
+            return bRet;
+        }
+
+        // Indicates that the entry was both deleted
+        // and has a refcount of zero
+        bool isReadyForCleanup()
+        {
+            mEntry.lock();
+            bool bRet = bDeleted && iRefCount == 0;
+            mEntry.unlock();
+            return bRet;
+        }
+
     private:
         mutable Bu::Mutex mEntry;
         mutable Bu::Mutex mObject;
         int iRefCount;
+        bool bDeleted;
         obtype *pObject;
     };
 
@@ -104,7 +124,7 @@ namespace Bu
                 obtype * &rpData )
         {
             if( pCache == NULL )
-                throw Bu::ExceptionBase("Invalid pointer");
+                throw Bu::ExceptionBase("Invalid cache pointer");
 
             if( !rpData )
             {
@@ -241,6 +261,12 @@ namespace Bu
             return pCache->template cast<obtype, castto>( *this );
         }
         
+        template<typename castto>
+        CachePtr<keytype, castto, basetype> cast() const
+        {
+            return pCache->template cast<obtype, castto>( *this );
+        }
+        
         bool operator==( const MyType &rhs ) const
         {
             return pCache == rhs.pCache &&
@@ -410,19 +436,46 @@ namespace Bu
             else
                 return CachePtr<keytype, castto, obtype>( this, ptr.kId );
         }
+        
+        template<typename supertype, typename castto>
+        CachePtr<keytype, castto, obtype> cast( const 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 );
+        }
 
         /**
          * Removes an item from the cache.
-         * This routine calls eraseNow for now.  Later the intention is that
-         * this function will always succeed.  It will remove the object from
-         * the backing store and the active tables.  It will not be able to
-         * be requested again, and all changes will be ignored.  When the
-         * object's last references are released the memory will be freed
-         * automatically.
+         * The object in question can have references to it, and those
+         * references will still work after the erase is called.  When erase
+         * is called the object is immediately removed from the backing store
+         * as well as from the main index.  At that point existing references
+         * can be used as normal, but when the last reference is released
+         * the memory will be automatically cleaned up.
          */
         void erase( const keytype &key )
         {
-            eraseNow( key );
+            Bu::ReadWriteMutex::WriteLocker wl( mCacheEntry );
+            if( hCacheEntry.has( key ) )
+            {
+                Entry *pEnt = hCacheEntry.get( key );
+                pEnt->mEntry.lock();
+                if( pEnt->iRefCount == 0 )
+                {
+                    pEnt->mEntry.unlock();
+                    delete pEnt->pObject;
+                    delete pEnt;
+                }
+                else
+                {
+                    pEnt->bDeleted = true;
+                    pEnt->mEntry.unlock();
+                }
+                hCacheEntry.erase( key );
+            }
+            _erase( key );
         }
 
         /**
@@ -467,8 +520,13 @@ namespace Bu
             return pEnt;
         }
 
-        void releaseRef( Entry * )//pEnt )
+        void releaseRef( Entry *pEnt )
         {
+            if( pEnt->isReadyForCleanup() )
+            {
+                delete pEnt->pObject;
+                delete pEnt;
+            }
         }
 
         void objectChanged( const keytype &k )
diff --git a/src/unstable/cacheobject.h b/src/unstable/cacheobject.h
index 6eb507b..47e09de 100644
--- a/src/unstable/cacheobject.h
+++ b/src/unstable/cacheobject.h
@@ -86,7 +86,8 @@ namespace Bu
     protected:
         void changed( bool bChanged=true )
         {
-            if( this->bChanged == false && bChanged == true && pCache )
+            if( this->bChanged == false && bChanged == true && pCache &&
+                    pEntry && !pEntry->isDeleted() )
                 pCache->objectChanged( getKey() );
 
             this->bChanged = bChanged;