NumberRequirement.h

 
#pragma once 
 
#include <cmath>
#include "Requirement.h"
 
namespace Json
{
 
    class NumberRequirement : public Requirement
    {
    private:
        std::string path_; 
        double multipleOf_; 
        double min_; 
        double max_; 
        bool multSet_; 
        bool minSet_; 
        bool maxSet_; 
        bool exclMin_; 
        bool exclMax_; 
 
 
    public:
        NumberRequirement() : 
        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"].isNumeric())
            {
                multSet_ = true;
                multipleOf_ = json["multipleOf"].asDouble();
            }
 
            if(json.isMember("minimum") && json["minimum"].isNumeric())
            {
                minSet_ = true;
                min_ = json["minimum"].asDouble();
            }
 
            if(json.isMember("maximum") && json["maximum"].isNumeric())
            {
                maxSet_ = true;
                max_ = json["maximum"].asDouble();
            }
 
            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.isNumeric())
            {
                PushError(path + ": Must be of type \"number\".");
                return;
            }
 
            if(multSet_ && fmod(json.asDouble(), multipleOf_) != 0)
                PushError(path + ": Value must be a multiple of " + std::to_string(multipleOf_));
 
            if(minSet_)
            {
                if(exclMin_ && json.asDouble() <= min_)
                    PushError(path + ": Value must be greater than " + std::to_string(min_));
                else if(json.asDouble() < min_)
                    PushError(path + ": Value cannot be less than " + std::to_string(min_));
            }
 
            if(maxSet_)
            {
                if(exclMax_ && json.asDouble() >= max_)
                    PushError(path + ": Value must be less than " + std::to_string(max_));
                else if(json.asDouble() > max_)
                    PushError(path + ": Value cannot be greater than " + std::to_string(max_));
            }
        }
    };
}