JsonSchema.h

Go to the documentation of this file.

/*
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 *
 * JsonSchema.h
 * A Json Schema, see json-schema.org
 * Copyright (C) 2014 Simon Newton
 */

#ifndef INCLUDE_OLA_WEB_JSONSCHEMA_H_
#define INCLUDE_OLA_WEB_JSONSCHEMA_H_

#include <ola/base/Macro.h>
#include <ola/stl/STLUtils.h>
#include <ola/web/Json.h>
#include <ola/web/JsonTypes.h>
#include <deque>
#include <map>
#include <memory>
#include <set>
#include <string>
#include <vector>

namespace ola {
namespace web {

class SchemaDefinitions;

class ValidatorInterface : public JsonValueConstVisitorInterface {
 public:
 typedef std::vector<ValidatorInterface*> ValidatorList;

 virtual ~ValidatorInterface() {}

 virtual bool IsValid() const = 0;

 // Do we need a "GetError" here?

 virtual JsonObject* GetSchema() const = 0;

 virtual void SetSchema(const std::string &schema) = 0;

 virtual void SetId(const std::string &id) = 0;

 virtual void SetTitle(const std::string &title) = 0;

 virtual void SetDescription(const std::string &title) = 0;

 virtual void SetDefaultValue(const JsonValue *value) = 0;

 virtual const JsonValue *GetDefaultValue() const = 0;
};

class BaseValidator : public ValidatorInterface {
 protected:
 explicit BaseValidator(JsonType type)
 : m_is_valid(true),
 m_type(type) {
 }

 public:
 virtual ~BaseValidator();

 virtual bool IsValid() const { return m_is_valid; }

 virtual void Visit(const JsonString&) {
 m_is_valid = false;
 }

 virtual void Visit(const JsonBool&) {
 m_is_valid = false;
 }

 virtual void Visit(const JsonNull&) {
 m_is_valid = false;
 }

 virtual void Visit(const JsonRawValue&) {
 m_is_valid = false;
 }

 virtual void Visit(const JsonObject&) {
 m_is_valid = false;
 }

 virtual void Visit(const JsonArray&) {
 m_is_valid = false;
 }

 virtual void Visit(const JsonUInt&) {
 m_is_valid = false;
 }

 virtual void Visit(const JsonUInt64&) {
 m_is_valid = false;
 }

 virtual void Visit(const JsonInt&) {
 m_is_valid = false;
 }

 virtual void Visit(const JsonInt64&) {
 m_is_valid = false;
 }

 virtual void Visit(const JsonDouble&) {
 m_is_valid = false;
 }

 virtual JsonObject* GetSchema() const;

 void SetSchema(const std::string &schema);

 void SetId(const std::string &id);

 void SetTitle(const std::string &title);

 void SetDescription(const std::string &title);

 void SetDefaultValue(const JsonValue *value);

 const JsonValue *GetDefaultValue() const;

 void AddEnumValue(const JsonValue *value);

 protected:
 bool m_is_valid;
 JsonType m_type;
 std::string m_schema;
 std::string m_id;
 std::string m_title;
 std::string m_description;
 std::auto_ptr<const JsonValue> m_default_value;
 std::vector<const JsonValue*> m_enums;

 bool CheckEnums(const JsonValue &value);

 // Child classes can hook in here to extend the schema.
 virtual void ExtendSchema(JsonObject *schema) const {
 (void) schema;
 }
};

class WildcardValidator : public BaseValidator {
 public:
 WildcardValidator() : BaseValidator(JSON_UNDEFINED) {}

 bool IsValid() const { return true; }
};

class ReferenceValidator : public ValidatorInterface {
 public:
 ReferenceValidator(const SchemaDefinitions *definitions,
 const std::string &schema);

 bool IsValid() const;

 void Visit(const JsonString &value);
 void Visit(const JsonBool &value);
 void Visit(const JsonNull &value);
 void Visit(const JsonRawValue &value);
 void Visit(const JsonObject &value);
 void Visit(const JsonArray &value);
 void Visit(const JsonUInt &value);
 void Visit(const JsonUInt64 &value);
 void Visit(const JsonInt &value);
 void Visit(const JsonInt64 &value);
 void Visit(const JsonDouble &value);

 JsonObject* GetSchema() const;

 void SetSchema(const std::string &schema);
 void SetId(const std::string &id);
 void SetTitle(const std::string &title);
 void SetDescription(const std::string &title);
 void SetDefaultValue(const JsonValue *value);
 const JsonValue *GetDefaultValue() const;

 private:
 const SchemaDefinitions *m_definitions;
 const std::string m_schema;
 ValidatorInterface *m_validator;

 template <typename T>
 void Validate(const T &value);
};

class StringValidator : public BaseValidator {
 public:
 struct Options {
 Options()
 : min_length(0),
 max_length(-1) {
 }

 unsigned int min_length;
 int max_length;
 // Formats & Regexes aren't supported.
 // std::string pattern
 // std::string format
 };

 explicit StringValidator(const Options &options)
 : BaseValidator(JSON_STRING),
 m_options(options) {
 }

 void Visit(const JsonString &str);

 private:
 const Options m_options;

 void ExtendSchema(JsonObject *schema) const;

 DISALLOW_COPY_AND_ASSIGN(StringValidator);
};

class BoolValidator : public BaseValidator {
 public:
 BoolValidator() : BaseValidator(JSON_BOOLEAN) {}

 void Visit(const JsonBool &value) { m_is_valid = CheckEnums(value); }

 private:
 DISALLOW_COPY_AND_ASSIGN(BoolValidator);
};

class NullValidator : public BaseValidator {
 public:
 NullValidator() : BaseValidator(JSON_NULL) {}

 void Visit(const JsonNull &value) { m_is_valid = CheckEnums(value); }

 private:
 DISALLOW_COPY_AND_ASSIGN(NullValidator);
};

class NumberConstraint {
 public:
 virtual ~NumberConstraint() {}

 virtual bool IsValid(const JsonNumber &value) = 0;

 virtual void ExtendSchema(JsonObject *schema) const = 0;
};

class MultipleOfConstraint : public NumberConstraint {
 public:
 explicit MultipleOfConstraint(const JsonNumber *value)
 : m_multiple_of(value) {
 }

 bool IsValid(const JsonNumber &value) {
 return value.MultipleOf(*m_multiple_of);
 }

 void ExtendSchema(JsonObject *schema) const {
 schema->AddValue("multipleOf", m_multiple_of->Clone());
 }

 private:
 std::auto_ptr<const JsonNumber> m_multiple_of;
};

class MaximumConstraint : public NumberConstraint {
 public:
 MaximumConstraint(const JsonNumber *limit, bool is_exclusive)
 : m_limit(limit),
 m_has_exclusive(true),
 m_is_exclusive(is_exclusive) {
 }

 explicit MaximumConstraint(const JsonNumber *limit)
 : m_limit(limit),
 m_has_exclusive(false),
 m_is_exclusive(false) {
 }

 bool IsValid(const JsonNumber &value) {
 return (m_has_exclusive && m_is_exclusive) ? value < *m_limit
 : value <= *m_limit;
 }

 void ExtendSchema(JsonObject *schema) const {
 schema->AddValue("maximum", m_limit->Clone());
 if (m_has_exclusive) {
 schema->Add("exclusiveMaximum", m_is_exclusive);
 }
 }

 private:
 std::auto_ptr<const JsonNumber> m_limit;
 bool m_has_exclusive, m_is_exclusive;
};

class MinimumConstraint : public NumberConstraint {
 public:
 MinimumConstraint(const JsonNumber *limit, bool is_exclusive)
 : m_limit(limit),
 m_has_exclusive(true),
 m_is_exclusive(is_exclusive) {
 }

 explicit MinimumConstraint(const JsonNumber *limit)
 : m_limit(limit),
 m_has_exclusive(false),
 m_is_exclusive(false) {
 }

 bool IsValid(const JsonNumber &value) {
 return (m_has_exclusive && m_is_exclusive) ? value > *m_limit
 : value >= *m_limit;
 }

 void ExtendSchema(JsonObject *schema) const {
 schema->AddValue("minimum", m_limit->Clone());
 if (m_has_exclusive) {
 schema->Add("exclusiveMinimum", m_is_exclusive);
 }
 }

 private:
 std::auto_ptr<const JsonNumber> m_limit;
 bool m_has_exclusive, m_is_exclusive;
};

class IntegerValidator : public BaseValidator {
 public:
 IntegerValidator() : BaseValidator(JSON_INTEGER) {}
 virtual ~IntegerValidator();

 void AddConstraint(NumberConstraint *constraint);

 void Visit(const JsonUInt&);
 void Visit(const JsonInt&);
 void Visit(const JsonUInt64&);
 void Visit(const JsonInt64&);
 virtual void Visit(const JsonDouble&);

 protected:
 explicit IntegerValidator(JsonType type) : BaseValidator(type) {}

 void CheckValue(const JsonNumber &value);

 private:
 std::vector<NumberConstraint*> m_constraints;

 void ExtendSchema(JsonObject *schema) const;

 DISALLOW_COPY_AND_ASSIGN(IntegerValidator);
};


class NumberValidator : public IntegerValidator {
 public:
 NumberValidator() : IntegerValidator(JSON_NUMBER) {}

 void Visit(const JsonDouble&);

 private:
 DISALLOW_COPY_AND_ASSIGN(NumberValidator);
};

class ObjectValidator : public BaseValidator, JsonObjectPropertyVisitor {
 public:
 struct Options {
 Options()
 : max_properties(-1),
 min_properties(0),
 has_required_properties(false),
 has_allow_additional_properties(false),
 allow_additional_properties(false) {
 }

 void SetRequiredProperties(
 const std::set<std::string> &required_properties_arg) {
 required_properties = required_properties_arg;
 has_required_properties = true;
 }

 void SetAdditionalProperties(bool allow_additional) {
 has_allow_additional_properties = true;
 allow_additional_properties = allow_additional;
 }

 int max_properties;
 unsigned int min_properties;
 bool has_required_properties;
 std::set<std::string> required_properties;
 bool has_allow_additional_properties;
 bool allow_additional_properties;
 };

 explicit ObjectValidator(const Options &options);
 ~ObjectValidator();

 void AddValidator(const std::string &property, ValidatorInterface *validator);

 void SetAdditionalValidator(ValidatorInterface *validator);

 void AddSchemaDependency(const std::string &property,
 ValidatorInterface *validator);

 void AddPropertyDependency(const std::string &property,
 const std::set<std::string> &properties);

 void Visit(const JsonObject &obj);

 void VisitProperty(const std::string &property, const JsonValue &value);

 private:
 typedef std::set<std::string> StringSet;
 typedef std::map<std::string, ValidatorInterface*> PropertyValidators;
 typedef std::map<std::string, ValidatorInterface*> SchemaDependencies;
 typedef std::map<std::string, StringSet> PropertyDependencies;

 const Options m_options;

 PropertyValidators m_property_validators;
 std::auto_ptr<ValidatorInterface> m_additional_property_validator;
 PropertyDependencies m_property_dependencies;
 SchemaDependencies m_schema_dependencies;

 StringSet m_seen_properties;

 void ExtendSchema(JsonObject *schema) const;

 DISALLOW_COPY_AND_ASSIGN(ObjectValidator);
};

class ArrayValidator : public BaseValidator {
 public:
 class Items {
 public:
 explicit Items(ValidatorInterface *validator)
 : m_validator(validator) {
 }

 explicit Items(ValidatorList *validators)
 : m_validator(NULL),
 m_validator_list(*validators) {
 }

 ~Items() {
 STLDeleteElements(&m_validator_list);
 }

 ValidatorInterface* Validator() const { return m_validator.get(); }
 const ValidatorList& Validators() const { return m_validator_list; }

 private:
 std::auto_ptr<ValidatorInterface> m_validator;
 ValidatorList m_validator_list;

 DISALLOW_COPY_AND_ASSIGN(Items);
 };

 class AdditionalItems {
 public:
 explicit AdditionalItems(bool allow_additional)
 : m_allowed(allow_additional),
 m_validator(NULL) {
 }

 explicit AdditionalItems(ValidatorInterface *validator)
 : m_allowed(true),
 m_validator(validator) {
 }

 ValidatorInterface* Validator() const { return m_validator.get(); }
 bool AllowAdditional() const { return m_allowed; }

 private:
 bool m_allowed;
 std::auto_ptr<ValidatorInterface> m_validator;

 DISALLOW_COPY_AND_ASSIGN(AdditionalItems);
 };

 struct Options {
 Options()
 : max_items(-1),
 min_items(0),
 unique_items(false) {
 }

 int max_items;
 unsigned int min_items;
 bool unique_items;
 };

 ArrayValidator(Items *items, AdditionalItems *additional_items,
 const Options &options);

 ~ArrayValidator();

 void Visit(const JsonArray &array);

 private:
 typedef std::deque<ValidatorInterface*> ValidatorQueue;

 const std::auto_ptr<Items> m_items;
 const std::auto_ptr<AdditionalItems> m_additional_items;
 const Options m_options;

 // This is used if items is missing, or if additionalItems is true.
 std::auto_ptr<WildcardValidator> m_wildcard_validator;

 class ArrayElementValidator : public BaseValidator {
 public:
 ArrayElementValidator(const ValidatorList &validators,
 ValidatorInterface *default_validator);

 void Visit(const JsonString&);
 void Visit(const JsonBool&);
 void Visit(const JsonNull&);
 void Visit(const JsonRawValue&);
 void Visit(const JsonObject&);
 void Visit(const JsonArray &array);
 void Visit(const JsonUInt&);
 void Visit(const JsonUInt64&);
 void Visit(const JsonInt&);
 void Visit(const JsonInt64&);
 void Visit(const JsonDouble&);

 private:
 ValidatorQueue m_item_validators;
 ValidatorInterface *m_default_validator;

 template <typename T>
 void ValidateItem(const T &item);

 DISALLOW_COPY_AND_ASSIGN(ArrayElementValidator);
 };

 void ExtendSchema(JsonObject *schema) const;
 ArrayElementValidator* ConstructElementValidator() const;

 DISALLOW_COPY_AND_ASSIGN(ArrayValidator);
};


class ConjunctionValidator : public BaseValidator {
 public:
 ConjunctionValidator(const std::string &keyword, ValidatorList *validators);
 virtual ~ConjunctionValidator();

 void Visit(const JsonString &value) {
 Validate(value);
 }

 void Visit(const JsonBool &value) {
 Validate(value);
 }

 void Visit(const JsonNull &value) {
 Validate(value);
 }

 void Visit(const JsonRawValue &value) {
 Validate(value);
 }

 void Visit(const JsonObject &value) {
 Validate(value);
 }

 void Visit(const JsonArray &value) {
 Validate(value);
 }

 void Visit(const JsonUInt &value) {
 Validate(value);
 }

 void Visit(const JsonUInt64 &value) {
 Validate(value);
 }

 void Visit(const JsonInt &value) {
 Validate(value);
 }

 void Visit(const JsonInt64 &value) {
 Validate(value);
 }

 void Visit(const JsonDouble &value) {
 Validate(value);
 }

 protected:
 std::string m_keyword;
 ValidatorList m_validators;

 void ExtendSchema(JsonObject *schema) const;

 virtual void Validate(const JsonValue &value) = 0;
};

class AllOfValidator : public ConjunctionValidator {
 public:
 explicit AllOfValidator(ValidatorList *validators)
 : ConjunctionValidator("allOf", validators) {
 }

 protected:
 void Validate(const JsonValue &value);

 private:
 DISALLOW_COPY_AND_ASSIGN(AllOfValidator);
};

class AnyOfValidator : public ConjunctionValidator {
 public:
 explicit AnyOfValidator(ValidatorList *validators)
 : ConjunctionValidator("anyOf", validators) {
 }

 protected:
 void Validate(const JsonValue &value);

 private:
 DISALLOW_COPY_AND_ASSIGN(AnyOfValidator);
};

class OneOfValidator : public ConjunctionValidator {
 public:
 explicit OneOfValidator(ValidatorList *validators)
 : ConjunctionValidator("oneOf", validators) {
 }

 protected:
 void Validate(const JsonValue &value);

 private:
 DISALLOW_COPY_AND_ASSIGN(OneOfValidator);
};

class NotValidator : public BaseValidator {
 public:
 explicit NotValidator(ValidatorInterface *validator)
 : BaseValidator(JSON_UNDEFINED),
 m_validator(validator) {
 }

 void Visit(const JsonString &value) {
 Validate(value);
 }

 void Visit(const JsonBool &value) {
 Validate(value);
 }

 void Visit(const JsonNull &value) {
 Validate(value);
 }

 void Visit(const JsonRawValue &value) {
 Validate(value);
 }

 void Visit(const JsonObject &value) {
 Validate(value);
 }

 void Visit(const JsonArray &value) {
 Validate(value);
 }

 void Visit(const JsonUInt &value) {
 Validate(value);
 }

 void Visit(const JsonUInt64 &value) {
 Validate(value);
 }

 void Visit(const JsonInt &value) {
 Validate(value);
 }

 void Visit(const JsonInt64 &value) {
 Validate(value);
 }

 void Visit(const JsonDouble &value) {
 Validate(value);
 }

 private:
 std::auto_ptr<ValidatorInterface> m_validator;

 void Validate(const JsonValue &value);

 void ExtendSchema(JsonObject *schema) const;

 DISALLOW_COPY_AND_ASSIGN(NotValidator);
};

class SchemaDefinitions {
 public:
 SchemaDefinitions() {}
 ~SchemaDefinitions();

 void Add(const std::string &schema_name, ValidatorInterface *validator);
 ValidatorInterface *Lookup(const std::string &schema_name) const;

 void AddToJsonObject(JsonObject *json) const;

 bool HasDefinitions() const { return !m_validators.empty(); }

 private:
 typedef std::map<std::string, ValidatorInterface*> SchemaMap;

 SchemaMap m_validators;

 DISALLOW_COPY_AND_ASSIGN(SchemaDefinitions);
};


class JsonSchema {
 public:
 ~JsonSchema() {}

 /*
 * @brief The URI which defines which version of the schema this is.
 */
 std::string SchemaURI() const;

 bool IsValid(const JsonValue &value);

 const JsonObject* AsJson() const;

 static JsonSchema* FromString(const std::string& schema_string,
 std::string *error);

 private:
 std::string m_schema_uri;
 std::auto_ptr<ValidatorInterface> m_root_validator;
 std::auto_ptr<SchemaDefinitions> m_schema_defs;

 JsonSchema(const std::string &schema_url,
 ValidatorInterface *root_validator,
 SchemaDefinitions *schema_defs);

 DISALLOW_COPY_AND_ASSIGN(JsonSchema);
};

} // namespace web
} // namespace ola
#endif // INCLUDE_OLA_WEB_JSONSCHEMA_H_