BlockStorageCache.h

Go to the documentation of this file.

 
#pragma once
#include "BlockStorage.h"
#include "catapult/utils/SpinReaderWriterLock.h"
 
namespace catapult { namespace io { struct CachedData; } }
 
namespace catapult { namespace io {
 
    class BlockStorageView : utils::MoveOnly {
    public:
        explicit BlockStorageView(
                const BlockStorage& storage,
                utils::SpinReaderWriterLock::ReaderLockGuard&& readLock,
                const CachedData& cachedData);
 
    public:
        Height chainHeight() const;
 
        model::HashRange loadHashesFrom(Height height, size_t maxHashes) const;
 
        std::shared_ptr<const model::Block> loadBlock(Height height) const;
 
        std::shared_ptr<const model::BlockElement> loadBlockElement(Height height) const;
 
        std::pair<std::vector<uint8_t>, bool> loadBlockStatementData(Height height) const;
 
    private:
        void requireHeight(Height height, const char* description) const;
 
    private:
        const BlockStorage& m_storage;
        utils::SpinReaderWriterLock::ReaderLockGuard m_readLock;
        const CachedData& m_cachedData;
    };
 
    class BlockStorageModifier : utils::MoveOnly {
    public:
        BlockStorageModifier(
                BlockStorage& storage,
                PrunableBlockStorage& stagingStorage,
                utils::SpinReaderWriterLock::ReaderLockGuard&& readLock,
                CachedData& cachedData);
 
    public:
        void saveBlock(const model::BlockElement& blockElement);
 
        void saveBlocks(const std::vector<model::BlockElement>& blockElements);
 
        void dropBlocksAfter(Height height);
 
        void commit();
 
    private:
        BlockStorage& m_storage;
        PrunableBlockStorage& m_stagingStorage;
        utils::SpinReaderWriterLock::ReaderLockGuard m_readLock;
        utils::SpinReaderWriterLock::WriterLockGuard m_writeLock;
        CachedData& m_cachedData;
        Height m_saveStartHeight;
    };
 
    class BlockStorageCache {
    public:
        BlockStorageCache(std::unique_ptr<BlockStorage>&& pStorage, std::unique_ptr<PrunableBlockStorage>&& pStagingStorage);
 
        ~BlockStorageCache();
 
    public:
        BlockStorageView view() const;
 
        BlockStorageModifier modifier();
 
    private:
        std::unique_ptr<BlockStorage> m_pStorage;
        std::unique_ptr<PrunableBlockStorage> m_pStagingStorage;
        std::unique_ptr<CachedData> m_pCachedData;
        mutable utils::SpinReaderWriterLock m_lock;
    };
}}