HandlerFactory.h

Go to the documentation of this file.

 
#pragma once
#include "catapult/ionet/PacketEntityUtils.h"
#include "catapult/ionet/PacketHandlers.h"
#include "catapult/ionet/PacketPayloadBuilder.h"
#include "catapult/model/EntityRange.h"
 
namespace catapult { namespace handlers {
 
    template<typename TRequestTraits>
    class BatchHandlerFactory {
    public:
        static constexpr auto Packet_Type = TRequestTraits::Packet_Type;
 
    public:
        template<typename TResultsProducerFactory>
        static void RegisterZero(ionet::ServerPacketHandlers& handlers, TResultsProducerFactory resultsProducerFactory) {
            auto maxPacketDataSize = handlers.maxPacketDataSize();
            handlers.registerHandler(Packet_Type, [resultsProducerFactory, maxPacketDataSize](const auto& packet, auto& context) {
                if (!IsPacketValid(packet, Packet_Type))
                    return;
 
                // always send a response (even if empty) in order to always acknowledge the request
                SetResponse(context, maxPacketDataSize, resultsProducerFactory());
            });
        }
 
        template<typename TResultsProducerFactory>
        static void RegisterOne(ionet::ServerPacketHandlers& handlers, TResultsProducerFactory resultsProducerFactory) {
            auto maxPacketDataSize = handlers.maxPacketDataSize();
            handlers.registerHandler(Packet_Type, [resultsProducerFactory, maxPacketDataSize](const auto& packet, auto& context) {
                auto info = BatchHandlerFactory::ProcessRequest(packet);
                if (!info.IsValid)
                    return;
 
                // always send a response (even if empty) in order to always acknowledge the request
                SetResponse(context, maxPacketDataSize, resultsProducerFactory(info.Range));
            });
        }
 
    private:
        template<typename TProducer>
        static void SetResponse(ionet::ServerPacketHandlerContext& context, uint32_t maxPacketDataSize, TProducer&& producer) {
            auto builder = ionet::PacketPayloadBuilder(Packet_Type, maxPacketDataSize);
            Append(AppendAccessor<TRequestTraits>(), builder, producer);
            context.response(builder.build());
        }
 
    private:
        enum class AppendType { Entities, Values };
        using EntitiesAppendFlag = std::integral_constant<AppendType, AppendType::Entities>;
        using ValuesAppendFlag = std::integral_constant<AppendType, AppendType::Values>;
 
        template<typename T, typename = void>
        struct AppendAccessor : EntitiesAppendFlag {};
 
        template<typename T>
        struct AppendAccessor<T, utils::traits::is_type_expression_t<decltype(T::Should_Append_As_Values)>> : ValuesAppendFlag {};
 
    private:
        template<typename TProducer>
        static void Append(EntitiesAppendFlag, ionet::PacketPayloadBuilder& builder, TProducer& producer) {
            builder.appendGeneratedEntities(producer);
        }
 
        template<typename TProducer>
        static void Append(ValuesAppendFlag, ionet::PacketPayloadBuilder& builder, TProducer& producer) {
            builder.appendGeneratedValues(producer);
        }
 
    private:
        template<typename TRange>
        struct PacketInfo {
        public:
            explicit PacketInfo(TRange&& range)
                    : Range(std::move(range))
                    , IsValid(!Range.empty())
            {}
 
        public:
            TRange Range;
            bool IsValid;
        };
 
    private:
        static auto ProcessRequest(const ionet::Packet& packet) {
            using RequestStructureType = typename TRequestTraits::RequestStructureType;
            using RequestRangeType = model::EntityRange<RequestStructureType>;
 
            return TRequestTraits::Packet_Type != packet.Type
                    ? PacketInfo<RequestRangeType>(RequestRangeType())
                    : PacketInfo<RequestRangeType>(ionet::ExtractFixedSizeStructuresFromPacket<RequestStructureType>(packet));
        }
    };
}}