ObserverUtils.h

Go to the documentation of this file.

 
#pragma once
#include "ObserverContext.h"
#include "ObserverTypes.h"
 
namespace catapult { namespace observers {
 
    constexpr bool ShouldPrune(const ObserverContext& context, size_t pruneInterval) {
        return NotifyMode::Commit == context.Mode && 0 == context.Height.unwrap() % pruneInterval;
    }
 
    template<typename TAction>
    constexpr bool ShouldLink(TAction action, NotifyMode notifyMode) {
        return NotifyMode::Commit == notifyMode ? TAction::Link == action : TAction::Unlink == action;
    }
 
    template<typename TCache>
    NotificationObserverPointerT<model::BlockNotification> CreateCacheBlockPruningObserver(
            const std::string& name,
            size_t interval,
            BlockDuration gracePeriod) {
        using ObserverType = FunctionalNotificationObserverT<model::BlockNotification>;
        return std::make_unique<ObserverType>(name + "PruningObserver", [interval, gracePeriod](const auto&, auto& context) {
            if (!ShouldPrune(context, interval))
                return;
 
            if (context.Height.unwrap() <= gracePeriod.unwrap())
                return;
 
            auto pruneHeight = Height(context.Height.unwrap() - gracePeriod.unwrap());
            auto& cache = context.Cache.template sub<TCache>();
            cache.prune(pruneHeight);
        });
    }
 
    template<typename TCache>
    NotificationObserverPointerT<model::BlockNotification> CreateCacheTimePruningObserver(const std::string& name, size_t interval) {
        using ObserverType = FunctionalNotificationObserverT<model::BlockNotification>;
        return std::make_unique<ObserverType>(name + "PruningObserver", [interval](const auto& notification, const auto& context) {
            if (!ShouldPrune(context, interval))
                return;
 
            auto& cache = context.Cache.template sub<TCache>();
            cache.prune(notification.Timestamp);
        });
    }
 
    template<typename TCache>
    NotificationObserverPointerT<model::BlockNotification> CreateCacheBlockTouchObserver(
            const std::string& name,
            model::ReceiptType receiptType) {
        using ObserverType = FunctionalNotificationObserverT<model::BlockNotification>;
        return std::make_unique<ObserverType>(name + "TouchObserver", [receiptType](const auto&, auto& context) {
            auto& cache = context.Cache.template sub<TCache>();
            auto expiryIds = cache.touch(context.Height);
 
            if (NotifyMode::Rollback == context.Mode)
                return;
 
            // sort expiry ids because receipts must be generated deterministically
            std::set<typename decltype(expiryIds)::value_type> orderedExpiryIds(expiryIds.cbegin(), expiryIds.cend());
            for (auto id : orderedExpiryIds)
                context.StatementBuilder().addReceipt(model::ArtifactExpiryReceipt<decltype(id)>(receiptType, id));
        });
    }
}}