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);
            }
        }
    };
}