SingleSetCacheTypesAdapter.h

Go to the documentation of this file.

 
#pragma once
#include "CacheDatabaseMixin.h"
#include "CachePatriciaTree.h"
#include "catapult/deltaset/ConditionalContainer.h"
#include <type_traits>
 
namespace catapult { namespace cache {
 
    template<typename TPrimaryTypes, typename IsOrderedFlag = std::false_type>
    struct SingleSetCacheTypesAdapter : public CacheDatabaseMixin {
    public:
        using PrimaryTypes = TPrimaryTypes;
 
    public:
        struct BaseSetDeltaPointers {
            typename TPrimaryTypes::BaseSetDeltaPointerType pPrimary;
        };
 
        struct BaseSets : public CacheDatabaseMixin {
        public:
            using IsOrderedSet = IsOrderedFlag;
 
        private:
            static constexpr auto PruningMode = IsOrderedSet() ? FilterPruningMode::Enabled : FilterPruningMode::Disabled;
 
        public:
            explicit BaseSets(const CacheConfiguration& config)
                    : CacheDatabaseMixin(config, { "default" }, PruningMode)
                    , Primary(GetContainerMode(config), database(), 0)
            {}
 
        public:
            typename TPrimaryTypes::BaseSetType Primary;
 
        public:
            BaseSetDeltaPointers rebase() {
                return { Primary.rebase() };
            }
 
            BaseSetDeltaPointers rebaseDetached() const {
                return { Primary.rebaseDetached() };
            }
 
            template<typename... TArgs>
            void commit(TArgs&&... args) {
                Primary.commit(std::forward<TArgs>(args)...);
                flush();
            }
        };
    };
 
    template<typename TPrimaryTypes, typename TPatriciaTree>
    struct SingleSetAndPatriciaTreeCacheTypesAdapter : public CacheDatabaseMixin {
    public:
        struct BaseSetDeltaPointers {
            typename TPrimaryTypes::BaseSetDeltaPointerType pPrimary;
            std::shared_ptr<typename TPatriciaTree::DeltaType> pPatriciaTree;
        };
 
        template<typename TBaseSetDeltaPointers>
        struct BaseSets : public CacheDatabaseMixin {
        public:
            using IsOrderedSet = std::false_type;
 
        public:
            explicit BaseSets(const CacheConfiguration& config)
                    : CacheDatabaseMixin(config, { "default" })
                    , Primary(GetContainerMode(config), database(), 0)
                    , PatriciaTree(hasPatriciaTreeSupport(), database(), 1)
            {}
 
        public:
            typename TPrimaryTypes::BaseSetType Primary;
            CachePatriciaTree<TPatriciaTree> PatriciaTree;
 
        public:
            TBaseSetDeltaPointers rebase() {
                TBaseSetDeltaPointers deltaPointers;
                deltaPointers.pPrimary = Primary.rebase();
                deltaPointers.pPatriciaTree = PatriciaTree.rebase();
                return deltaPointers;
            }
 
            TBaseSetDeltaPointers rebaseDetached() const {
                TBaseSetDeltaPointers deltaPointers;
                deltaPointers.pPrimary = Primary.rebaseDetached();
                deltaPointers.pPatriciaTree = PatriciaTree.rebaseDetached();
                return deltaPointers;
            }
 
            void commit() {
                Primary.commit();
                PatriciaTree.commit();
                flush();
            }
        };
    };
}}