ReadOnlyArtifactCache.h

Go to the documentation of this file.

 
#pragma once
#include "ReadOnlySimpleCache.h"
#include "catapult/types.h"
 
namespace catapult { namespace cache {
 
    template<typename TCache, typename TCacheDelta, typename TKey, typename TValue>
    class ReadOnlyArtifactCache : public ReadOnlySimpleCache<TCache, TCacheDelta, TKey> {
    public:
        template<typename TCacheIterator, typename TCacheDeltaIterator>
        class ReadOnlyFindIterator {
        public:
            ReadOnlyFindIterator() : m_hasCacheIter(false)
            {}
 
            explicit ReadOnlyFindIterator(TCacheIterator&& cacheIter)
                    : m_hasCacheIter(true)
                    , m_cacheIter(std::move(cacheIter))
            {}
 
            explicit ReadOnlyFindIterator(TCacheDeltaIterator&& cacheDeltaIter)
                    : m_hasCacheIter(false)
                    , m_cacheDeltaIter(std::move(cacheDeltaIter))
            {}
 
        public:
            const TValue& get() const {
                return m_hasCacheIter ? m_cacheIter.get() : m_cacheDeltaIter.get();
            }
 
            const TValue* tryGet() const {
                return m_hasCacheIter ? m_cacheIter.tryGet() : m_cacheDeltaIter.tryGet();
            }
 
        private:
            bool m_hasCacheIter;
            TCacheIterator m_cacheIter;
            TCacheDeltaIterator m_cacheDeltaIter;
        };
 
    public:
        explicit ReadOnlyArtifactCache(const TCache& cache)
                : ReadOnlySimpleCache<TCache, TCacheDelta, TKey>(cache)
                , m_pCache(&cache)
                , m_pCacheDelta(nullptr)
        {}
 
        explicit ReadOnlyArtifactCache(const TCacheDelta& cache)
                : ReadOnlySimpleCache<TCache, TCacheDelta, TKey>(cache)
                , m_pCache(nullptr)
                , m_pCacheDelta(&cache)
        {}
 
    public:
        auto find(TKey id) const {
            // note: having alias within function instead of at class scope allows forward declaration of caches
            using FindIterator = ReadOnlyFindIterator<decltype(m_pCache->find(id)), decltype(m_pCacheDelta->find(id))>;
            return m_pCache ? FindIterator(m_pCache->find(id)) : FindIterator(m_pCacheDelta->find(id));
        }
 
        bool isActive(TKey id, Height height) const {
            return m_pCache ? m_pCache->isActive(id, height) : m_pCacheDelta->isActive(id, height);
        }
 
    private:
        const TCache* m_pCache;
        const TCacheDelta* m_pCacheDelta;
    };
}}