BasicAggregateTransactionsCache.h

Go to the documentation of this file.

 
#pragma once
#include "catapult/model/TransactionChangeTracker.h"
#include <memory>
 
namespace catapult { namespace cache {
 
    template<typename TCacheTraits, typename TChangeSubscriberTraits>
    class BasicAggregateTransactionsCacheModifier : public TCacheTraits::CacheModifierType {
    private:
        using ChangeSubscriberType = typename TCacheTraits::ChangeSubscriberType;
        using CacheModifierProxyType = typename TCacheTraits::CacheModifierProxyType;
        using TransactionInfoType = typename TChangeSubscriberTraits::TransactionInfoType;
 
    public:
        using TCacheTraits::CacheModifierType::add;
 
    public:
        BasicAggregateTransactionsCacheModifier(CacheModifierProxyType&& modifier, ChangeSubscriberType& subscriber)
                : m_modifier(std::move(modifier))
                , m_subscriber(subscriber)
        {}
 
        ~BasicAggregateTransactionsCacheModifier() noexcept(false) override {
            flush();
        }
 
    public:
        size_t size() const override {
            return m_modifier.size();
        }
 
        bool add(const TransactionInfoType& transactionInfo) override {
            if (!m_modifier.add(transactionInfo))
                return false;
 
            m_transactionChangeTracker.add(TChangeSubscriberTraits::ToTransactionInfo(transactionInfo));
            return true;
        }
 
        TransactionInfoType remove(const Hash256& hash) override {
            auto transactionInfo = m_modifier.remove(hash);
            if (transactionInfo)
                remove(transactionInfo);
 
            return transactionInfo;
        }
 
    protected:
        CacheModifierProxyType& modifier() {
            return m_modifier;
        }
 
        const CacheModifierProxyType& modifier() const {
            return m_modifier;
        }
 
        ChangeSubscriberType& subscriber() {
            return m_subscriber;
        }
 
        void remove(const TransactionInfoType& transactionInfo) {
            m_transactionChangeTracker.remove(TChangeSubscriberTraits::ToTransactionInfo(transactionInfo));
        }
 
    private:
        void flush() {
            const auto& removedTransactionInfos = m_transactionChangeTracker.removedTransactionInfos();
            if (!removedTransactionInfos.empty())
                TChangeSubscriberTraits::NotifyRemoves(m_subscriber, m_transactionChangeTracker.removedTransactionInfos());
 
            const auto& addedTransactionInfos = m_transactionChangeTracker.addedTransactionInfos();
            if (!addedTransactionInfos.empty())
                TChangeSubscriberTraits::NotifyAdds(m_subscriber, addedTransactionInfos);
 
            m_subscriber.flush();
            m_transactionChangeTracker.reset();
        }
 
    private:
        CacheModifierProxyType m_modifier;
        ChangeSubscriberType& m_subscriber;
        model::TransactionChangeTracker m_transactionChangeTracker;
    };
 
    template<typename TCacheTraits, typename TAggregateCacheModifier>
    class BasicAggregateTransactionsCache : public TCacheTraits::CacheType {
    private:
        using CacheType = typename TCacheTraits::CacheType;
        using ChangeSubscriberType = typename TCacheTraits::ChangeSubscriberType;
        using CacheModifierProxyType = typename TCacheTraits::CacheModifierProxyType;
 
    public:
        BasicAggregateTransactionsCache(CacheType& cache, std::unique_ptr<ChangeSubscriberType>&& pChangeSubscriber)
                : m_cache(cache)
                , m_pChangeSubscriber(std::move(pChangeSubscriber))
        {}
 
    public:
        CacheModifierProxyType modifier() override {
            return CacheModifierProxyType(std::make_unique<TAggregateCacheModifier>(m_cache.modifier(), *m_pChangeSubscriber));
        }
 
    private:
        CacheType& m_cache;
        std::unique_ptr<ChangeSubscriberType> m_pChangeSubscriber;
    };
}}