AggregateEntityValidator.h

Go to the documentation of this file.

 
#pragma once
#include "ValidatorTypes.h"
#include "catapult/model/VerifiableEntity.h"
#include "catapult/utils/NamedObject.h"
#include <memory>
 
namespace catapult { namespace validators {
 
    template<typename... TArgs>
    class AggregateEntityValidatorT final {
    public:
        using ValidatorVector = ValidatorVectorT<TArgs...>;
 
    public:
        explicit AggregateEntityValidatorT(ValidatorVector&& validators)
                : m_validators(std::move(validators))
        {}
 
    public:
        class DispatchForwarder {
        public:
            explicit DispatchForwarder(ValidationFunctions&& validationFunctions)
                    : m_validationFunctions(std::move(validationFunctions))
            {}
 
        public:
            template<typename TDispatcher>
            auto dispatch(const TDispatcher& dispatcher, const model::WeakEntityInfos& entityInfos) const {
                return dispatcher(entityInfos, m_validationFunctions);
            }
 
        private:
            ValidationFunctions m_validationFunctions;
        };
 
#ifdef __clang__
#pragma clang diagnostic push
// clang generates this warning when curry() is called without arguments
#pragma clang diagnostic ignored "-Wunused-lambda-capture"
#endif
 
        template<typename... TCurryArgs>
        DispatchForwarder curry(TCurryArgs&&... args) const {
            ValidationFunctions validationFunctions;
            validationFunctions.reserve(m_validators.size());
            auto forwardedArgs = std::make_tuple(std::forward<TCurryArgs>(args)...);
            for (const auto& pValidator : m_validators) {
                validationFunctions.emplace_back([&pValidator, forwardedArgs](const auto& entityInfo) {
                    return pValidator->validate(entityInfo, std::get<TArgs>(forwardedArgs)...);
                });
            }
 
            return DispatchForwarder(std::move(validationFunctions));
        }
 
#ifdef __clang__
#pragma clang diagnostic pop
#endif
 
        std::vector<std::string> names() const {
            return utils::ExtractNames(m_validators);
        }
 
    private:
        ValidatorVector m_validators;
    };
}}