IntegerRequirement.h

 
#pragma once 
 
#include "Requirement.h"
 
namespace Json
{
 
    class IntegerRequirement : public Requirement
    {
    private:
        std::string path_; 
        int multipleOf_; 
        int min_; 
        int max_; 
        bool multSet_; 
        bool minSet_; 
        bool maxSet_; 
        bool exclMin_; 
        bool exclMax_; 
 
    public:
        IntegerRequirement() : 
        path_(), multipleOf_(0), min_(0), max_(0), multSet_(false), 
        minSet_(false), maxSet_(false), exclMin_(false), exclMax_(false)
        {}
 
        virtual void Reset() override
        {
            multipleOf_ = 0;
            minSet_ = maxSet_ = false;
            exclMin_ = exclMax_ = false; 
            min_ = max_ = 0;
            multSet_ = false;
            ClearErrors();
            ClearNotices();
        }
 
 
        virtual void Parse(Value json, const std::string& path) override
        {
            Reset();
            
            path_ = path;
            if(json.isMember("multipleOf") && json["multipleOf"].isInt())
            {
                multSet_ = true;
                multipleOf_ = json["multipleOf"].asInt();
            }
 
            if(json.isMember("minimum") && json["minimum"].isInt())
            {
                minSet_ = true;
                min_ = json["minimum"].asInt();
            }
 
            if(json.isMember("maximum") && json["maximum"].isInt())
            {
                maxSet_ = true;
                max_ = json["maximum"].asInt();
            }
 
            if(json.isMember("exclusiveMinimum") && json["exclusiveMinimum"].isBool())
            {
                exclMin_ = json["exclusiveMinimum"].asBool();
            }
 
            if(json.isMember("exclusiveMaximum") && json["exclusiveMaximum"].isBool())
            {
                exclMax_ = json["exclusiveMaximum"].asBool();
            }
        }
 
 
        virtual void Validate(const Value& json, const std::string& path) override
        {
            if(!json.isInt())
            {
                PushError(path + ": Must be of type \"integer\".");
                return;
            }
 
            if(multSet_ && (json.asInt() % multipleOf_ != 0))
                PushError(path + ": Value must be a multiple of " + std::to_string(multipleOf_));
 
            if(minSet_)
            {
                if(exclMin_ && json.asInt() <= min_)
                    PushError(path + ": Value must be greater than " + std::to_string(min_));
                else if(json.asInt() < min_)
                    PushError(path + ": Value cannot be less than " + std::to_string(min_));
            }
 
            if(maxSet_)
            {
                if(exclMax_ && json.asInt() >= max_)
                    PushError(path + ": Value must be less than " + std::to_string(max_));
                else if(json.asInt() > max_)
                    PushError(path + ": Value cannot be greater than " + std::to_string(max_));
            }
        }
    };
}