MemoryPtCache.h

Go to the documentation of this file.

 
#pragma once
#include "MemoryCacheOptions.h"
#include "MemoryCacheProxy.h"
#include "PtCache.h"
#include "ShortHashPair.h"
#include "catapult/model/CosignedTransactionInfo.h"
#include "catapult/model/WeakCosignedTransactionInfo.h"
#include "catapult/utils/Hashers.h"
#include "catapult/utils/SpinReaderWriterLock.h"
#include <unordered_map>
 
namespace catapult { namespace cache { class PtData; } }
 
namespace catapult { namespace cache {
 
    using PtDataContainer = std::unordered_map<Hash256, PtData, utils::ArrayHasher<Hash256>>;
 
    class MemoryPtCacheView {
    private:
        using UnknownTransactionInfos = std::vector<model::CosignedTransactionInfo>;
 
    public:
        explicit MemoryPtCacheView(
                uint64_t maxResponseSize,
                const PtDataContainer& transactionDataContainer,
                utils::SpinReaderWriterLock::ReaderLockGuard&& readLock);
 
    public:
        size_t size() const;
 
        model::WeakCosignedTransactionInfo find(const Hash256& hash) const;
 
        ShortHashPairRange shortHashPairs() const;
 
        UnknownTransactionInfos unknownTransactions(const ShortHashPairMap& knownShortHashPairs) const;
 
    private:
        uint64_t m_maxResponseSize;
        const PtDataContainer& m_transactionDataContainer;
        utils::SpinReaderWriterLock::ReaderLockGuard m_readLock;
    };
 
    class MemoryPtCache : public PtCache {
    public:
        explicit MemoryPtCache(const MemoryCacheOptions& options);
 
        ~MemoryPtCache() override;
 
    public:
        MemoryPtCacheView view() const;
 
    public:
        PtCacheModifierProxy modifier() override;
 
    private:
        struct Impl;
 
    private:
        MemoryCacheOptions m_options;
        std::unique_ptr<Impl> m_pImpl;
        mutable utils::SpinReaderWriterLock m_lock;
    };
 
    class MemoryPtCacheProxy : public MemoryCacheProxy<MemoryPtCache, PtCache, PtCacheModifierProxy> {
        using MemoryCacheProxy<MemoryPtCache, PtCache, PtCacheModifierProxy>::MemoryCacheProxy;
    };
}}