AnyOfRequirement.h

 
#pragma once 
 
#include "Requirement.h"
#include "RequirementLoader.h"
 
namespace Json
{
 
    class AnyOfRequirement : public Requirement
    {
    private:
        RequireList reqs_; 
 
    public:
        AnyOfRequirement() : reqs_(0) {}
 
        virtual void ClearErrors() override
        {
            for(auto& r : reqs_)
                r->ClearErrors();
 
            Requirement::ClearErrors();
        }
 
        virtual void ClearNotices() override
        {
            for(auto& r : reqs_)
                r->ClearNotices();
 
            Requirement::ClearNotices();
        } 
 
        virtual void Reset() override
        {
            ClearErrors();
            ClearNotices();
            reqs_.clear();
        }
 
 
        virtual void Parse(Value json, const std::string& path) override
        {
            Reset();
            RequirementLoader loader;
 
            auto& head = json.isMember("anyOf") ? json["anyOf"] : json;
 
            for(auto& val : head)
                if(auto req = loader.LoadRequirement(val))
                {
                    reqs_.push_back(std::move(req));
                    reqs_.back()->Parse(val, path);
                }
 
        }
 
 
        virtual void Validate(const Value& json, const std::string& path) override
        {
            for(auto& r : reqs_)
            {
                r->Validate(json, path);
                if(!r->HasErrors())
                    return;
            }
 
            // Collect errors.
            for(auto& r : reqs_)
            {
                if(r->HasErrors())
                    for(const auto& error : r->GetErrors())
                        PushError(error);
        
                if(r->HasNotices())
                    for(const auto& notice : r->GetNotices())
                        PushNotice(notice);
            }
        }
    };
}