StringRequirement.h

 
#pragma once 
 
#include <regex>
#include "Requirement.h"
 
namespace Json
{
 
    class StringRequirement : public Requirement 
    {
    private: 
        bool minSet_; 
        bool maxSet_; 
        bool rgxSet_; 
        size_t minLength_; 
        size_t maxLength_; 
        std::regex regex_; 
        std::string expr_; 
        std::string path_; 
        std::vector<std::string> enum_; 
 
    public:
        StringRequirement() : 
        minSet_(false), maxSet_(false), rgxSet_(false),
        minLength_(0), maxLength_(0), regex_(), expr_(), path_(), enum_(0)
        {}
        
        virtual void Reset() override
        {
            minSet_ = false;
            maxSet_ = false;
            rgxSet_ = false;
            minLength_ = 0;
            maxLength_ = 0;
            regex_ = "";
            expr_ = "";
            path_  = "";
            enum_.clear();
            ClearErrors();
            ClearNotices();
        }
 
 
        virtual void Parse(Value json, const std::string& path) override
        {
            Reset();
            
            path_ = path;
            if(json.isMember("minLength") && json["minLength"].isUInt())
            {
                minSet_ = true;
                minLength_ = json["minLength"].asUInt();
            }
            
            if(json.isMember("maxLength") && json["maxLength"].isUInt())
            {
                maxSet_ = true;
                maxLength_ = json["maxLength"].asUInt();
            
            }
 
            if(json.isMember("pattern") && json["pattern"].isString())
            {
                rgxSet_ = true;
                expr_ = json["pattern"].asString();
                regex_ = std::regex(expr_, std::regex::ECMAScript);
            }
 
            if(json.isMember("enum") && json["enum"].isArray())
            {
                for(const auto& val : json["enum"])
                    enum_.push_back(val.asString());
            }
        }
 
 
        virtual void Validate(const Value& json, const std::string& path) override
        {
            if(!json.isString())
            {
                PushError(path + ": Must be of type \"string\"");
                return;
            }
            
            if(minSet_ && json.asString().length() < minLength_)
                PushError(path + ": Length must be greater than " + std::to_string(minLength_));
            
            if(maxSet_ && json.asString().length() > maxLength_)
                PushError(path + ": Length must be less than " + std::to_string(minLength_));
 
            if(rgxSet_ && !std::regex_match(json.asString(), regex_))
                PushError(path + ": String must match regular expression \"" + expr_ + "\"");
 
            if(enum_.size() && std::find(enum_.begin(),enum_.end(), json.asString()) == enum_.end())
                PushError(path + ": String is not a valid entry");
        }
    };
}