MemoryUtCache.h

Go to the documentation of this file.

 
#pragma once
#include "MemoryCacheOptions.h"
#include "MemoryCacheProxy.h"
#include "UtCache.h"
#include "catapult/model/RangeTypes.h"
#include "catapult/utils/Hashers.h"
#include "catapult/utils/SpinReaderWriterLock.h"
#include <set>
#include <unordered_map>
 
namespace catapult { namespace cache { struct TransactionData; } }
 
namespace catapult { namespace cache {
 
    using TransactionDataContainer = std::set<TransactionData>;
 
    class MemoryUtCacheView {
    private:
        using UnknownTransactions = std::vector<std::shared_ptr<const model::Transaction>>;
        using IdLookup = std::unordered_map<Hash256, size_t, utils::ArrayHasher<Hash256>>;
        using TransactionInfoConsumer = predicate<const model::TransactionInfo&>;
 
    public:
        explicit MemoryUtCacheView(
                uint64_t maxResponseSize,
                const TransactionDataContainer& transactionDataContainer,
                const IdLookup& idLookup,
                utils::SpinReaderWriterLock::ReaderLockGuard&& readLock);
 
    public:
        size_t size() const;
 
        bool contains(const Hash256& hash) const;
 
        void forEach(const TransactionInfoConsumer& consumer) const;
 
        model::ShortHashRange shortHashes() const;
 
        UnknownTransactions unknownTransactions(BlockFeeMultiplier minFeeMultiplier, const utils::ShortHashesSet& knownShortHashes) const;
 
    private:
        uint64_t m_maxResponseSize;
        const TransactionDataContainer& m_transactionDataContainer;
        const IdLookup& m_idLookup;
        utils::SpinReaderWriterLock::ReaderLockGuard m_readLock;
    };
 
    class MemoryUtCache : public UtCache {
    public:
        explicit MemoryUtCache(const MemoryCacheOptions& options);
 
        ~MemoryUtCache() override;
 
    public:
        MemoryUtCacheView view() const;
 
    public:
        UtCacheModifierProxy modifier() override;
 
    private:
        struct Impl;
 
    private:
        MemoryCacheOptions m_options;
        size_t m_idSequence;
        std::unique_ptr<Impl> m_pImpl;
        mutable utils::SpinReaderWriterLock m_lock;
    };
 
    class MemoryUtCacheProxy : public MemoryCacheProxy<MemoryUtCache, UtCache, UtCacheModifierProxy> {
        using MemoryCacheProxy<MemoryUtCache, UtCache, UtCacheModifierProxy>::MemoryCacheProxy;
    };
}}