AnyHandler.hpp

#pragma once
 
#include "rpc/common/Concepts.hpp"
#include "rpc/common/Types.hpp"
#include "rpc/common/impl/Processors.hpp"
 
#include <boost/json/value.hpp>
 
#include <memory>
 
namespace rpc {

class AnyHandler final {
public:
    template <
        SomeHandler HandlerType,
        typename ProcessingStrategy = impl::DefaultProcessor<HandlerType>>
    /* implicit */ AnyHandler(HandlerType&& handler)
        : pimpl_{std::make_unique<Model<HandlerType, ProcessingStrategy>>(
              std::forward<HandlerType>(handler)
          )}
    {
    }

    ~AnyHandler() = default;
    AnyHandler(AnyHandler const& other) : pimpl_{other.pimpl_->clone()}
    {
    }
 
    AnyHandler&
    operator=(AnyHandler const& rhs)
    {
        AnyHandler copy{rhs};
        pimpl_.swap(copy.pimpl_);
        return *this;
    }
 
    AnyHandler(AnyHandler&&) = default;
    AnyHandler&
    operator=(AnyHandler&&) = default;

    [[nodiscard]] ReturnType
    process(boost::json::value const& value, Context const& ctx) const
    {
        return pimpl_->process(value, ctx);
    }
 
private:
    struct Concept {
        virtual ~Concept() = default;
 
        [[nodiscard]] virtual ReturnType
        process(boost::json::value const& value, Context const& ctx) const = 0;
 
        [[nodiscard]] virtual std::unique_ptr<Concept>
        clone() const = 0;
    };
 
    template <typename HandlerType, typename ProcessorType>
    struct Model : Concept {
        HandlerType handler;
        ProcessorType processor;
 
        Model(HandlerType&& handler) : handler{std::move(handler)}
        {
        }
 
        [[nodiscard]] ReturnType
        process(boost::json::value const& value, Context const& ctx) const override
        {
            return processor(handler, value, ctx);
        }
 
        [[nodiscard]] std::unique_ptr<Concept>
        clone() const override
        {
            return std::make_unique<Model>(*this);
        }
    };
 
private:
    std::unique_ptr<Concept> pimpl_;
};
 
}  // namespace rpc