ArrayRequirement.h

 
#pragma once 
 
#include "Requirement.h"
#include "StringRequirement.h"
#include "IntegerRequirement.h"
#include "NumberRequirement.h"
#include "ObjectRequirement.h"
#include "RequirementLoader.h"
#include <algorithm>
#include <set>
 
namespace Json
{
 
    class ArrayRequirement : public Requirement
    {
    private:
        RequireList items_; 
        std::unique_ptr<Requirement> item_; 
 
        bool addItems_; 
        bool setMin_; 
        bool setMax_; 
        bool unique_; 
 
        int min_; 
        int max_; 
 
 
        template <class T>
        bool IsUnique(T X) 
        {
          std::set<T> Y(X.begin(), X.end());
          return X.size() == Y.size();
        }
 
    public:
        ArrayRequirement() : 
        items_(0), item_(nullptr), addItems_(true),
        setMin_(false), setMax_(false), unique_(false), 
        min_(0), max_(0) {}
        ~ArrayRequirement() 
        {
            items_.clear();
        }
 
        virtual void ClearErrors() override
        {
            if(item_ != nullptr)
                item_->ClearErrors();
 
            for(auto& c : items_)
                c->ClearErrors();
 
            Requirement::ClearErrors();
        }
 
        virtual void ClearNotices() override
        {
            if(item_ != nullptr)
                item_->ClearNotices();
 
            for(auto& c : items_)
                c->ClearNotices();
 
            Requirement::ClearNotices();
        }
 
        virtual void Reset() override
        {
            items_.clear();
 
            item_.reset();
 
            addItems_ = true;
            setMin_ = setMax_ = unique_ = false;
            min_ = max_ = 0;
        }
 
 
        virtual void Parse(Value json, const std::string& path) override
        {
            Reset();
            RequirementLoader loader;
            
            if(json.isMember("items") && json["items"].isObject())
            {
                if((item_ = loader.LoadRequirement(json["items"])))
                    item_->Parse(json["items"], path);              
            }
            else if(json.isMember("items") && json["items"].isArray())
            {
                for(auto& item : json["items"])
                {           
                    if(auto iptr = loader.LoadRequirement(item))
                    {
                        items_.push_back(std::move(iptr));
                        items_.back()->Parse(item, path);
                    }
                }
            }
 
            if(json.isMember("additionalItems") && json["additionalItems"].isBool())
                addItems_ = json["additionalItems"].asBool();
 
            if(json.isMember("minItems") && json["minItems"].isInt())
            {
                setMin_ = true;
                min_ = json["minItems"].asInt();
            }
 
            if(json.isMember("maxItems") && json["maxItems"].isInt())
            {
                setMax_ = true;
                max_ = json["maxItems"].asInt();
            }
 
            if(json.isMember("uniqueItems") && json["uniqueItems"].isBool())
                unique_ = json["uniqueItems"].asBool();
        }
 
 
        virtual void Validate(const Value& json, const std::string& path) override
        {
            if(!json.isArray())
            {
                PushError(path + ": Must be of type \"array\"");
                return;
            }
 
            if(item_ != nullptr)
            {
                int i = 0;
                for(const auto& item : json)
                {
                    item_->Validate(item, path + "/" + std::to_string(i));
                    ++i;
                }
 
                // Merge errors.
                for(const auto& error : item_->GetErrors())
                    PushError(error);
 
                for(const auto& notice : item_->GetNotices())
                    PushNotice(notice);
            }
 
            if(items_.size() != 0)
            {
                
                if(!addItems_ && json.size() >  items_.size())
                    PushError(path + ": There cannot be any additional items in the array");
 
                int iv = std::min((int)items_.size(), (int)json.size());
                for(int i = 0; i < iv; ++i)
                {
                    items_[i]->Validate(json[i], path);
 
                    // Merge errors.
                    for(const auto& error : items_[i]->GetErrors())
                        PushError(error);
 
                    for(const auto& notice : items_[i]->GetNotices())
                        PushNotice(notice);
                }                   
            }
 
            if(setMin_ && (int)json.size() < min_)
                PushError(path + ": There must be at least " + std::to_string(min_) + " elements in the array");
                
            if(setMax_ && (int)json.size() > max_)
                PushError(path + ": There must be no more than " + std::to_string(max_) + " elements in the array");
 
            if(unique_ && !IsUnique(json))
                PushError(path + ": Entries must be unique");
 
 
        }
    };
}