CacheEntryInfosProducerFactory.h

Go to the documentation of this file.

 
#pragma once
#include "BasicProducer.h"
#include "HandlerTypes.h"
#include "catapult/cache/SynchronizedCache.h"
#include "catapult/model/CacheEntryInfo.h"
#include "catapult/utils/MemoryUtils.h"
 
namespace catapult { namespace handlers {
 
    template<typename KeyType>
    using CacheEntryInfoProducer = supplier<std::shared_ptr<const model::CacheEntryInfo<KeyType>>>;
 
    template<typename TCacheDescriptor>
    class CacheEntryInfosProducerFactory {
    private:
        using KeyType = typename TCacheDescriptor::KeyType;
        using ValueType = typename TCacheDescriptor::ValueType;
        using CacheType = typename TCacheDescriptor::CacheType;
 
        class Producer : BasicProducer<model::EntityRange<KeyType>> {
        private:
            using ViewType = cache::LockedCacheView<typename TCacheDescriptor::CacheViewType>;
            using BasicProducer<model::EntityRange<KeyType>>::next;
 
        public:
            Producer(ViewType&& view, const model::EntityRange<KeyType>& keys)
                    : BasicProducer<model::EntityRange<KeyType>>(keys)
                    , m_pView(std::make_shared<ViewType>(std::move(view)))
            {}
 
        public:
            auto operator()() {
                return next([&view = **m_pView](const auto& key) {
                    using Serializer = typename TCacheDescriptor::PatriciaTree::Serializer;
 
                    auto iter = view.find(key);
                    const auto* pEntry = iter.tryGetUnadapted();
                    return pEntry ? MakeInfo(key, Serializer::SerializeValue(*pEntry)) : MakeInfo(key);
                });
            }
 
        private:
            static std::shared_ptr<model::CacheEntryInfo<KeyType>> MakeInfo(const KeyType& key) {
                auto pInfo = std::make_shared<model::CacheEntryInfo<KeyType>>();
                pInfo->Id = key;
                pInfo->DataSize = 0;
                pInfo->Size = static_cast<uint32_t>(model::CacheEntryInfo<KeyType>::CalculateRealSize(*pInfo));
                return pInfo;
            }
 
            static std::shared_ptr<model::CacheEntryInfo<KeyType>> MakeInfo(const KeyType& key, const std::string& value) {
                auto size = sizeof(model::CacheEntryInfo<KeyType>) + value.size();
                auto pInfo = utils::MakeSharedWithSize<model::CacheEntryInfo<KeyType>>(size);
 
                pInfo->Id = key;
 
                pInfo->DataSize = model::CacheEntryInfo<KeyType>::Max_Data_Size <= value.size()
                        ? model::CacheEntryInfo<KeyType>::Max_Data_Size
                        : static_cast<uint32_t>(value.size());
                pInfo->Size = static_cast<uint32_t>(model::CacheEntryInfo<KeyType>::CalculateRealSize(*pInfo));
                std::memcpy(pInfo->DataPtr(), value.data(), value.size());
                return pInfo;
            }
 
        private:
            std::shared_ptr<ViewType> m_pView;
        };
 
    private:
        CacheEntryInfosProducerFactory(const CacheType& cache)
                : m_cache(cache)
        {}
 
    public:
        static CacheEntryInfosProducerFactory Create(const CacheType& cache) {
            return CacheEntryInfosProducerFactory(cache);
        }
 
    public:
        CacheEntryInfoProducer<KeyType> operator()(const model::EntityRange<KeyType>& ids) const {
            return Producer(m_cache.createView(), ids);
        }
 
    private:
        const CacheType& m_cache;
    };
}}