Specs.hpp

#pragma once
 
#include "rpc/common/Checkers.hpp"
#include "rpc/common/Concepts.hpp"
#include "rpc/common/Types.hpp"
#include "rpc/common/impl/Factories.hpp"
 
#include <boost/json/array.hpp>
#include <boost/json/value.hpp>
 
#include <initializer_list>
#include <string>
#include <utility>
#include <vector>
 
namespace rpc {

struct FieldSpec final {
    template <SomeProcessor... Processors>
    FieldSpec(std::string const& key, Processors&&... processors)
        : processor_{
              impl::makeFieldProcessor<Processors...>(key, std::forward<Processors>(processors)...)
          }
        , checker_{impl::kEMPTY_FIELD_CHECKER}
    {
    }

    template <SomeCheck... Checks>
    FieldSpec(std::string const& key, Checks&&... checks)
        : processor_{impl::kEMPTY_FIELD_PROCESSOR}
        , checker_{impl::makeFieldChecker<Checks...>(key, std::forward<Checks>(checks)...)}
    {
    }

    [[nodiscard]] MaybeError
    process(boost::json::value& value) const;

    [[nodiscard]] check::Warnings
    check(boost::json::value const& value) const;
 
private:
    impl::FieldSpecProcessor processor_;
    impl::FieldChecker checker_;
};

struct RpcSpec final {
    RpcSpec(std::initializer_list<FieldSpec> fields) : fields_{fields}
    {
    }

    RpcSpec(RpcSpec const& other, std::initializer_list<FieldSpec> additionalFields)
        : fields_{other.fields_}
    {
        for (auto& f : additionalFields)
            fields_.push_back(f);
    }

    [[nodiscard]] MaybeError
    process(boost::json::value& value) const;

    [[nodiscard]] boost::json::array
    check(boost::json::value const& value) const;
 
private:
    std::vector<FieldSpec> fields_;
};

using RpcSpecConstRef = RpcSpec const&;
 
}  // namespace rpc