DemuxValidatorBuilder.h

Go to the documentation of this file.

 
#pragma once
#include "AggregateValidatorBuilder.h"
#include "ValidatorTypes.h"
#include <functional>
#include <vector>
 
namespace catapult { namespace validators {
 
    template<typename... TArgs>
    class DemuxValidatorBuilderT {
    private:
        template<typename TNotification>
        using NotificationValidatorPointerT = std::unique_ptr<const NotificationValidatorT<TNotification, TArgs...>>;
        using NotificationValidatorPredicate = predicate<const model::Notification&>;
        using AggregateValidatorPointer = std::unique_ptr<const AggregateNotificationValidatorT<model::Notification, TArgs...>>;
 
    public:
        template<typename TNotification>
        DemuxValidatorBuilderT& add(NotificationValidatorPointerT<TNotification>&& pValidator) {
            if constexpr (!std::is_same_v<model::Notification, TNotification>) {
                auto predicate = [type = TNotification::Notification_Type](const auto& notification) {
                    return model::AreEqualExcludingChannel(type, notification.Type);
                };
                m_builder.add(std::make_unique<ConditionalValidator<TNotification>>(std::move(pValidator), predicate));
                return *this;
            } else {
                m_builder.add(std::move(pValidator));
                return *this;
            }
        }
 
        DemuxValidatorBuilderT& add(NotificationValidatorPointerT<model::Notification>&& pValidator) {
            return add<model::Notification>(std::move(pValidator));
        }
 
        AggregateValidatorPointer build(const ValidationResultPredicate& isSuppressedFailure) {
            return m_builder.build(isSuppressedFailure);
        }
 
    private:
        template<typename TNotification>
        class ConditionalValidator : public NotificationValidatorT<model::Notification, TArgs...> {
        public:
            ConditionalValidator(
                    NotificationValidatorPointerT<TNotification>&& pValidator,
                    const NotificationValidatorPredicate& predicate)
                    : m_pValidator(std::move(pValidator))
                    , m_predicate(predicate)
            {}
 
        public:
            const std::string& name() const override {
                return m_pValidator->name();
            }
 
            ValidationResult validate(const model::Notification& notification, TArgs&&... args) const override {
                if (!m_predicate(notification))
                    return ValidationResult::Success;
 
                return m_pValidator->validate(static_cast<const TNotification&>(notification), std::forward<TArgs>(args)...);
            }
 
        private:
            NotificationValidatorPointerT<TNotification> m_pValidator;
            NotificationValidatorPredicate m_predicate;
        };
 
    private:
        AggregateValidatorBuilder<model::Notification, TArgs...> m_builder;
    };
}}