cel_storage.h

Go to the documentation of this file.

//----------------------------------------------------------------------------
//
// (C) 2003-2006 Celartem Technology Inc. All rights reserved.
//----------------------------------------------------------------------------

#ifndef _cel_storage_h_
#define _cel_storage_h_

#include "cel_iostream.h"
#include "cel_filepath.h"
#include "cel_time.h"

namespace Celartem
{
    class ResourceBroker;
    
    //------------------------------------------------------------------------
    class Storage : public Stream
    {
    public:
        virtual uint64_t getSize() const = 0;

        virtual uint64_t getPos() const = 0;

        virtual void reserve(uint64_t inReservationSize) = 0;

        virtual void setPos(uint64_t inPosition) = 0;

        virtual void setPosRelative(int64_t inPosition) = 0;

        virtual void setPosFromEnd(int64_t inPosition) = 0;

        virtual void setEof() = 0;
        
        virtual String getStorageId() const = 0;

        virtual AutoPtr<Storage> duplicate() const = 0;

        virtual Time getLastUpdateTime() const = 0;
        
        static AutoPtr<Storage> create(
            const String& inUriOrFileName,
            bool inLateBinding = false,
            ResourceBroker* inBroker = NULL);
    };

    //------------------------------------------------------------------------
    class StorageRollback
    {
    public:
        virtual void commit() = 0;
        
        virtual ~StorageRollback() {}
    };

    //------------------------------------------------------------------------
    //------------------------------------------------------------------------
    enum AccessMode
    {
        accessRead = 1,  
        accessWrite = 2, 
        accessRW = 3,    
    };

    //------------------------------------------------------------------------
    enum CreationMode
    {
        creationDefault = 0,

        openExisting = 1,

        openAlways = 2,

        createNew = 3,

        createAlways = 4,

        truncateExisting = 5
    };

    //------------------------------------------------------------------------
    class StorageRewinder
    {
    public:
        StorageRewinder(Storage *inStorage)
            : m_storage(inStorage), m_pos(inStorage->getPos())
        {
        }

        StorageRewinder()
            : m_storage(NULL), m_pos(0)
        {
        }

        void setStorage(Storage *inStorage)
        {
            releaseStorage();
            m_storage = inStorage;
            m_pos = m_storage->getPos();
        }

        void rewind()
        {
            if(m_storage)
                m_storage->setPos(m_pos);
        }

        void releaseStorage()
        {
            m_storage = NULL;
        }

        ~StorageRewinder()
        {
            rewind();
        }

    private:
        AutoPtr<Storage> m_storage;

        uint64_t m_pos;
    };

    //------------------------------------------------------------------------
    class DiskStorage : public Storage
    {
    public:
        static AutoPtr<DiskStorage> create(
            const Path& inFileName,
            AccessMode inAccessMode = accessRead,
            CreationMode inCreationMode = creationDefault);

        static AutoPtr<DiskStorage> createAnonTemp();

        static AutoPtr<DiskStorage> createTemp(String& ioFileName);

        virtual void* getOSHandle() = 0;
        
        virtual void lockRegion(
            uint64_t inPos,
            uint64_t inSize,
            bool inWriterLock) = 0;

        virtual bool tryLockRegion(
            uint64_t inPos,
            uint64_t inSize,
            bool inWriterLock) = 0;

        virtual void unlockRegion(uint64_t inPos, uint64_t inSize) = 0;

        static AutoPtr<DiskStorage> createFromHandle(
            void* /* HANDLE */ inFileHandle,
            AccessMode inAccessMode = accessRead,
            CreationMode inCreationMode = creationDefault);
    };

    //------------------------------------------------------------------------
    struct LockStorageRegion
    {
        LockStorageRegion(uint64_t inOffset, uint64_t inLength) :
            offset(inOffset), length(inLength)
        {
        }
        
        LockStorageRegion() : offset(0), length(0)
        {
        }
        
        uint64_t offset; 
        uint64_t length; 
    };
    
    //------------------------------------------------------------------------
    class DiskStorageLock
    {
    public:
        enum LockMode
        {
            Shared = 0, 
            Exclusive = 1, 
        };

        DiskStorageLock(DiskStorage* inStorage,
            uint64_t inPos, uint64_t inSize, LockMode inMode = Shared)
        {
            lock(inStorage, inPos, inSize, inMode);
        }

        DiskStorageLock(DiskStorage* inStorage,
            const LockStorageRegion& inRegion, LockMode inMode = Shared)
        {
            lock(inStorage, inRegion.offset, inRegion.length, inMode);
        }
        
        DiskStorageLock()
        {
        }
        
        ~DiskStorageLock()
        {
            unlock();
        }
        
        void lock(DiskStorage* inStorage,
            const LockStorageRegion& inRegion, LockMode inMode = Shared)
        {
            lock(inStorage, inRegion.offset, inRegion.length, inMode);
        }
        
        void lock(DiskStorage* inStorage,
            uint64_t inPos, uint64_t inSize, LockMode inMode = Shared)
        {
            unlock();
            m_ds = inStorage;
            m_region = LockStorageRegion(inPos, inSize);
            m_ds->lockRegion(inPos, inSize, inMode ? true : false);
        }
        
        void unlock()
        {
            if(m_ds.isValid())
            {
                m_ds->unlockRegion(m_region.offset, m_region.length);
                m_ds = NULL;
            }
        }
        
    private:
        AutoPtr<DiskStorage> m_ds;
        LockStorageRegion m_region;
        
        DiskStorageLock(const DiskStorageLock&);
        DiskStorageLock& operator=(const DiskStorageLock&);
    };

    //------------------------------------------------------------------------
    class DiskStorageWithRollback : public DiskStorage, public StorageRollback
    {
    public:
        static AutoPtr<DiskStorageWithRollback> create(
            const Path& inFileName,
            AccessMode inAccessMode = accessRead,
            CreationMode inCreationMode = creationDefault);
    };

    //------------------------------------------------------------------------
    class MemoryStorage : public Storage
    {
    public:
        static AutoPtr<MemoryStorage> create(SimpleArray<u8>& inMemory);

        static AutoPtr<MemoryStorage> create();

        static AutoPtr<MemoryStorage> create(
            const void *inData, size_t inDataSize,
            Endian inEndian = endianHost);

        virtual SimpleArray<u8>& getArray() = 0;
        
        virtual void setAllocationUnit(size_t inAllocationUnitInBytes) = 0;
        
        virtual void setReadOnly(bool inReadOnly) = 0;
    };

    //------------------------------------------------------------------------
    class RomStorage : public Storage
    {
    public:
        static AutoPtr<RomStorage> create(const u8 *inMem, size_t inSize);
    };

    //------------------------------------------------------------------------
    class WrapperStorage : public Storage
    {
    public:
        static AutoPtr<WrapperStorage> create(
            Stream* inStream, bool forWrite);
    };
    
    //------------------------------------------------------------------------
    class StorageOffsetter : public Storage
    {
    public:
        static AutoPtr<StorageOffsetter> create(
            Storage *inStorage, uint64_t inOffset);
    };

    //------------------------------------------------------------------------
    class PartialStorage : public Storage
    {
    public:
        static AutoPtr<PartialStorage> create(
            Storage *inStorage,
            uint64_t inOffset,
            uint64_t inSize,
            bool inReadOnly);
    };

} // namespace Celartem


#endif // _cel_storage_h_

---

This document is automatically generated using doxygen 1.5.4 at Fri Jun 27 18:21:54 2008.