CacheChanges.h

Go to the documentation of this file.

 
#pragma once
#include "CatapultCacheDelta.h"
#include <unordered_set>
#include <vector>
 
namespace catapult { namespace cache {
 
    // region MemoryCacheChanges
 
    struct MemoryCacheChanges : public utils::NonCopyable {
        virtual ~MemoryCacheChanges() = default;
    };
 
    template<typename TValue>
    struct MemoryCacheChangesT : public MemoryCacheChanges {
        std::vector<TValue> Added;
 
        std::vector<TValue> Removed;
 
        std::vector<TValue> Copied;
    };
 
    // endregion
 
    // region SingleCacheChanges
 
    struct SingleCacheChanges : public utils::NonCopyable {};
 
    template<typename TCacheDelta, typename TValue>
    class SingleCacheChangesT : public SingleCacheChanges {
    private:
        using PointerContainer = std::unordered_set<const TValue*>;
 
    public:
        explicit SingleCacheChangesT(const TCacheDelta& cacheDelta)
                : m_pCacheDelta(&cacheDelta)
                , m_pMemoryCacheChanges(nullptr)
        {}
 
        explicit SingleCacheChangesT(const MemoryCacheChangesT<TValue>& memoryCacheChanges)
                : m_pCacheDelta(nullptr)
                , m_pMemoryCacheChanges(&memoryCacheChanges)
        {}
 
    public:
        PointerContainer addedElements() const {
            return m_pCacheDelta ? m_pCacheDelta->addedElements() : CollectAllPointers(m_pMemoryCacheChanges->Added);
        }
 
        PointerContainer modifiedElements() const {
            return m_pCacheDelta ? m_pCacheDelta->modifiedElements() : CollectAllPointers(m_pMemoryCacheChanges->Copied);
        }
 
        PointerContainer removedElements() const {
            return m_pCacheDelta ? m_pCacheDelta->removedElements() : CollectAllPointers(m_pMemoryCacheChanges->Removed);
        }
 
    private:
        static PointerContainer CollectAllPointers(const std::vector<TValue>& values) {
            PointerContainer pointers;
            for (const auto& value : values)
                pointers.insert(&value);
 
            return pointers;
        }
 
    private:
        const TCacheDelta* m_pCacheDelta;
        const MemoryCacheChangesT<TValue>* m_pMemoryCacheChanges;
    };
 
    // endregion
 
    // region CacheChanges
 
    class CacheChanges : public utils::MoveOnly {
    public:
        using MemoryCacheChangesContainer = std::vector<std::unique_ptr<const MemoryCacheChanges>>;
 
    public:
        explicit CacheChanges(const CatapultCacheDelta& cacheDelta) : m_pCacheDelta(&cacheDelta)
        {}
 
        explicit CacheChanges(MemoryCacheChangesContainer&& memoryCacheChangesContainer)
                : m_pCacheDelta(nullptr)
                , m_memoryCacheChangesContainer(std::move(memoryCacheChangesContainer))
        {}
 
    public:
        template<typename TCache>
        auto sub() const {
            using SubCacheChanges = SingleCacheChangesT<typename TCache::CacheDeltaType, typename TCache::CacheValueType>;
            if (m_pCacheDelta)
                return SubCacheChanges(m_pCacheDelta->sub<TCache>());
 
            using TypedMemoryCacheChanges = MemoryCacheChangesT<typename TCache::CacheValueType>;
            return SubCacheChanges(*static_cast<const TypedMemoryCacheChanges*>(m_memoryCacheChangesContainer[TCache::Id].get()));
        }
 
    private:
        const CatapultCacheDelta* m_pCacheDelta;
        MemoryCacheChangesContainer m_memoryCacheChangesContainer;
    };
 
    // endregion
}}