jsoncons 0.1.0

data/lib/jsoncons/jsoncons/include/jsoncons_ext/jsonschema/schema_draft7.hpp

@@ -0,0 +1,198 @@
+// Copyright 2020 Daniel Parker
+// Distributed under the Boost license, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+// See https://github.com/danielaparker/jsoncons for latest version
+
+#ifndef JSONCONS_JSONSCHEMA_SCHEMA_DRAFT7_HPP
+#define JSONCONS_JSONSCHEMA_SCHEMA_DRAFT7_HPP
+
+#include <jsoncons/json.hpp>
+
+namespace jsoncons {
+namespace jsonschema {
+    
+    template <class Json>
+    struct schema_draft7
+    {
+        static Json get_schema() 
+        {
+            static Json schema = Json::parse(R"(
+    {
+        "$schema": "http://json-schema.org/draft-07/schema#",
+        "$id": "http://json-schema.org/draft-07/schema#",
+        "title": "Core schema meta-schema",
+        "definitions": {
+            "schemaArray": {
+                "type": "array",
+                "minItems": 1,
+                "items": { "$ref": "#" }
+            },
+            "nonNegativeInteger": {
+                "type": "integer",
+                "minimum": 0
+            },
+            "nonNegativeIntegerDefault0": {
+                "allOf": [
+                    { "$ref": "#/definitions/nonNegativeInteger" },
+                    { "default": 0 }
+                ]
+            },
+            "simpleTypes": {
+                "enum": [
+                    "array",
+                    "boolean",
+                    "integer",
+                    "null",
+                    "number",
+                    "object",
+                    "string"
+                ]
+            },
+            "stringArray": {
+                "type": "array",
+                "items": { "type": "string" },
+                "uniqueItems": true,
+                "default": []
+            }
+        },
+        "type": ["object", "boolean"],
+        "properties": {
+            "$id": {
+                "type": "string",
+                "format": "uri-reference"
+            },
+            "$schema": {
+                "type": "string",
+                "format": "uri"
+            },
+            "$ref": {
+                "type": "string",
+                "format": "uri-reference"
+            },
+            "$comment": {
+                "type": "string"
+            },
+            "title": {
+                "type": "string"
+            },
+            "description": {
+                "type": "string"
+            },
+            "default": true,
+            "readOnly": {
+                "type": "boolean",
+                "default": false
+            },
+            "examples": {
+                "type": "array",
+                "items": true
+            },
+            "multipleOf": {
+                "type": "number",
+                "exclusiveMinimum": 0
+            },
+            "maximum": {
+                "type": "number"
+            },
+            "exclusiveMaximum": {
+                "type": "number"
+            },
+            "minimum": {
+                "type": "number"
+            },
+            "exclusiveMinimum": {
+                "type": "number"
+            },
+            "maxLength": { "$ref": "#/definitions/nonNegativeInteger" },
+            "minLength": { "$ref": "#/definitions/nonNegativeIntegerDefault0" },
+            "pattern": {
+                "type": "string",
+                "format": "regex"
+            },
+            "additionalItems": { "$ref": "#" },
+            "items": {
+                "anyOf": [
+                    { "$ref": "#" },
+                    { "$ref": "#/definitions/schemaArray" }
+                ],
+                "default": true
+            },
+            "maxItems": { "$ref": "#/definitions/nonNegativeInteger" },
+            "minItems": { "$ref": "#/definitions/nonNegativeIntegerDefault0" },
+            "uniqueItems": {
+                "type": "boolean",
+                "default": false
+            },
+            "contains": { "$ref": "#" },
+            "maxProperties": { "$ref": "#/definitions/nonNegativeInteger" },
+            "minProperties": { "$ref": "#/definitions/nonNegativeIntegerDefault0" },
+            "required": { "$ref": "#/definitions/stringArray" },
+            "additionalProperties": { "$ref": "#" },
+            "definitions": {
+                "type": "object",
+                "additionalProperties": { "$ref": "#" },
+                "default": {}
+            },
+            "properties": {
+                "type": "object",
+                "additionalProperties": { "$ref": "#" },
+                "default": {}
+            },
+            "patternProperties": {
+                "type": "object",
+                "additionalProperties": { "$ref": "#" },
+                "propertyNames": { "format": "regex" },
+                "default": {}
+            },
+            "dependencies": {
+                "type": "object",
+                "additionalProperties": {
+                    "anyOf": [
+                        { "$ref": "#" },
+                        { "$ref": "#/definitions/stringArray" }
+                    ]
+                }
+            },
+            "propertyNames": { "$ref": "#" },
+            "const": true,
+            "enum": {
+                "type": "array",
+                "items": true,
+                "minItems": 1,
+                "uniqueItems": true
+            },
+            "type": {
+                "anyOf": [
+                    { "$ref": "#/definitions/simpleTypes" },
+                    {
+                        "type": "array",
+                        "items": { "$ref": "#/definitions/simpleTypes" },
+                        "minItems": 1,
+                        "uniqueItems": true
+                    }
+                ]
+            },
+            "format": { "type": "string" },
+            "contentMediaType": { "type": "string" },
+            "contentEncoding": { "type": "string" },
+            "if": { "$ref": "#" },
+            "then": { "$ref": "#" },
+            "else": { "$ref": "#" },
+            "allOf": { "$ref": "#/definitions/schemaArray" },
+            "anyOf": { "$ref": "#/definitions/schemaArray" },
+            "oneOf": { "$ref": "#/definitions/schemaArray" },
+            "not": { "$ref": "#" }
+        },
+        "default": true
+    } 
+            )"); 
+
+            return schema;
+        }
+    };
+
+} // namespace jsonschema
+} // namespace jsoncons
+
+#endif // JSONCONS_JSONSCHEMA_SCHEMA_DRAFT7_HPP

data/lib/jsoncons/jsoncons/include/jsoncons_ext/jsonschema/schema_location.hpp

@@ -0,0 +1,200 @@
+// Copyright 2020 Daniel Parker
+// Distributed under the Boost license, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+// See https://github.com/danielaparker/jsoncons for latest version
+
+#ifndef JSONCONS_JSONSCHEMA_SCHEMA_LOCATION_HPP
+#define JSONCONS_JSONSCHEMA_SCHEMA_LOCATION_HPP
+
+#include <jsoncons/config/jsoncons_config.hpp>
+#include <jsoncons/uri.hpp>
+#include <jsoncons/json.hpp>
+#include <jsoncons_ext/jsonpointer/jsonpointer.hpp>
+#include <jsoncons_ext/jsonschema/jsonschema_error.hpp>
+
+namespace jsoncons {
+namespace jsonschema {
+
+    class schema_location
+    {
+        jsoncons::uri uri_;
+        std::string identifier_;
+    public:
+        schema_location()
+        {
+        }
+
+        schema_location(const std::string& uri)
+        {
+            auto pos = uri.find('#');
+            if (pos != std::string::npos)
+            {
+                identifier_ = uri.substr(pos + 1); 
+                unescape_percent(identifier_);
+            }
+            uri_ = jsoncons::uri(uri);
+        }
+
+        jsoncons::uri uri() const
+        {
+            return uri_;
+        }
+
+        bool has_fragment() const
+        {
+            return !identifier_.empty();
+        }
+
+        bool has_identifier() const
+        {
+            return !identifier_.empty() && identifier_.front() != '/';
+        }
+
+        jsoncons::string_view base() const
+        {
+            return uri_.base();
+        }
+
+        jsoncons::string_view path() const
+        {
+            return uri_.path();
+        }
+
+        bool is_absolute() const
+        {
+            return uri_.is_absolute();
+        }
+
+        std::string identifier() const
+        {
+            return identifier_;
+        }
+
+        std::string fragment() const
+        {
+            return identifier_;
+        }
+
+        schema_location resolve(const schema_location& uri) const
+        {
+            schema_location new_uri;
+            new_uri.identifier_ = identifier_;
+            new_uri.uri_ = uri_.resolve(uri.uri_);
+            return new_uri;
+        }
+
+        int compare(const schema_location& other) const
+        {
+            int result = uri_.compare(other.uri_);
+            if (result != 0) 
+            {
+                return result;
+            }
+            return result; 
+        }
+
+        schema_location append(const std::string& field) const
+        {
+            if (has_identifier())
+                return *this;
+
+            jsoncons::jsonpointer::json_pointer pointer(std::string(uri_.fragment()));
+            pointer /= field;
+
+            jsoncons::uri new_uri(uri_.scheme(),
+                                  uri_.userinfo(),
+                                  uri_.host(),
+                                  uri_.port(),
+                                  uri_.path(),
+                                  uri_.query(),
+                                  pointer.to_string());
+
+            schema_location wrapper;
+            wrapper.uri_ = new_uri;
+            wrapper.identifier_ = pointer.to_string();
+
+            return wrapper;
+        }
+
+        schema_location append(std::size_t index) const
+        {
+            if (has_identifier())
+                return *this;
+
+            jsoncons::jsonpointer::json_pointer pointer(std::string(uri_.fragment()));
+            pointer /= index;
+
+            jsoncons::uri new_uri(uri_.scheme(),
+                                  uri_.userinfo(),
+                                  uri_.host(),
+                                  uri_.port(),
+                                  uri_.path(),
+                                  uri_.query(),
+                                  pointer.to_string());
+
+            schema_location wrapper;
+            wrapper.uri_ = new_uri;
+            wrapper.identifier_ = pointer.to_string();
+
+            return wrapper;
+        }
+
+        std::string string() const
+        {
+            std::string s = uri_.string();
+            return s;
+        }
+
+        friend bool operator==(const schema_location& lhs, const schema_location& rhs)
+        {
+            return lhs.compare(rhs) == 0;
+        }
+
+        friend bool operator!=(const schema_location& lhs, const schema_location& rhs)
+        {
+            return lhs.compare(rhs) != 0;
+        }
+
+        friend bool operator<(const schema_location& lhs, const schema_location& rhs)
+        {
+            return lhs.compare(rhs) < 0;
+        }
+
+        friend bool operator<=(const schema_location& lhs, const schema_location& rhs)
+        {
+            return lhs.compare(rhs) <= 0;
+        }
+
+        friend bool operator>(const schema_location& lhs, const schema_location& rhs)
+        {
+            return lhs.compare(rhs) > 0;
+        }
+
+        friend bool operator>=(const schema_location& lhs, const schema_location& rhs)
+        {
+            return lhs.compare(rhs) >= 0;
+        }
+    private:
+        static void unescape_percent(std::string& s)
+        {
+            if (s.size() >= 3)
+            {
+                std::size_t pos = s.size() - 2;
+                while (pos-- >= 1)
+                {
+                    if (s[pos] == '%')
+                    {
+                        std::string hex = s.substr(pos + 1, 2);
+                        char ch = (char) std::strtoul(hex.c_str(), nullptr, 16);
+                        s.replace(pos, 3, 1, ch);
+                    }
+                }
+            }
+        }
+    };
+
+} // namespace jsonschema
+} // namespace jsoncons
+
+#endif // JSONCONS_JSONSCHEMA_RULE_HPP

data/lib/jsoncons/jsoncons/include/jsoncons_ext/jsonschema/schema_version.hpp

@@ -0,0 +1,35 @@
+// Copyright 2021 Daniel Parker
+// Distributed under the Boost license, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+// See https://github.com/danielaparker/jsoncons for latest version
+
+#ifndef JSONCONS_JSONSCHEMA_SCHEMA_VERSION_HPP
+#define JSONCONS_JSONSCHEMA_SCHEMA_VERSION_HPP
+
+#include <jsoncons/json.hpp>
+
+namespace jsoncons {
+namespace jsonschema {
+
+    class schema_version
+    {
+    public:
+        static bool contains(const string_view& url)
+        {
+            if (url.find("json-schema.org/draft-07/schema#") != string_view::npos)
+            {
+                return true;
+            }
+            else
+            {
+                return false;
+            }
+        }
+    };
+
+
+} // namespace jsonschema
+} // namespace jsoncons
+
+#endif // JSONCONS_JSONSCHEMA_JSONSCHEMA_VERSION_HPP

data/lib/jsoncons/jsoncons/include/jsoncons_ext/jsonschema/subschema.hpp

@@ -0,0 +1,144 @@
+// Copyright 2020 Daniel Parker
+// Distributed under the Boost license, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+// See https://github.com/danielaparker/jsoncons for latest version
+
+#ifndef JSONCONS_JSONSCHEMA_SUBSCHEMA_HPP
+#define JSONCONS_JSONSCHEMA_SUBSCHEMA_HPP
+
+#include <jsoncons/config/jsoncons_config.hpp>
+#include <jsoncons/uri.hpp>
+#include <jsoncons/json.hpp>
+#include <jsoncons_ext/jsonpointer/jsonpointer.hpp>
+#include <jsoncons_ext/jsonschema/jsonschema_error.hpp>
+#include <jsoncons_ext/jsonschema/schema_location.hpp>
+
+namespace jsoncons {
+namespace jsonschema {
+
+    // Interface for validation error handlers
+    class error_reporter
+    {
+        bool fail_early_;
+        std::size_t error_count_;
+    public:
+        error_reporter(bool fail_early = false)
+            : fail_early_(fail_early), error_count_(0)
+        {
+        }
+
+        virtual ~error_reporter() = default;
+
+        void error(const validation_output& o)
+        {
+            ++error_count_;
+            do_error(o);
+        }
+
+        std::size_t error_count() const
+        {
+            return error_count_;
+        }
+
+        bool fail_early() const
+        {
+            return fail_early_;
+        }
+
+    private:
+        virtual void do_error(const validation_output& /* e */) = 0;
+    };
+
+    template <class Json>
+    class keyword_validator 
+    {
+        std::string absolute_keyword_location_;
+    public:
+        using self_pointer = keyword_validator<Json>*;
+
+        keyword_validator(const std::string& absolute_keyword_location)
+            : absolute_keyword_location_(absolute_keyword_location)
+        {
+        }
+
+        keyword_validator(const keyword_validator&) = delete;
+        keyword_validator(keyword_validator&&) = default;
+        keyword_validator& operator=(const keyword_validator&) = delete;
+        keyword_validator& operator=(keyword_validator&&) = default;
+
+        virtual ~keyword_validator() = default;
+
+        const std::string& absolute_keyword_location() const
+        {
+            return absolute_keyword_location_;
+        }
+
+        void validate(const Json& instance, 
+                      const jsonpointer::json_pointer& instance_location, 
+                      error_reporter& reporter, 
+                      Json& patch) const 
+        {
+            do_validate(instance, 
+                        instance_location,
+                        reporter,
+                        patch);
+        }
+
+        virtual jsoncons::optional<Json> get_default_value(const jsonpointer::json_pointer&, const Json&, error_reporter&) const
+        {
+            return jsoncons::optional<Json>();
+        }
+
+    private:
+        virtual void do_validate(const Json& instance, 
+                                 const jsonpointer::json_pointer& instance_location, 
+                                 error_reporter& reporter, 
+                                 Json& patch) const = 0;
+    };
+
+    template <class Json>
+    std::vector<schema_location> update_uris(const Json& schema,
+                                         const std::vector<schema_location>& uris,
+                                         const std::vector<std::string>& keys)
+    {
+        // Exclude uri's that are not plain name identifiers
+        std::vector<schema_location> new_uris;
+        for (const auto& uri : uris)
+        {
+            if (!uri.has_identifier())
+                new_uris.push_back(uri);
+        }
+
+        // Append the keys for this sub-schema to the uri's
+        for (const auto& key : keys)
+        {
+            for (auto& uri : new_uris)
+            {
+                auto new_u = uri.append(key);
+                uri = schema_location(new_u);
+            }
+        }
+        if (schema.type() == json_type::object_value)
+        {
+            auto it = schema.find("$id"); // If $id is found, this schema can be referenced by the id
+            if (it != schema.object_range().end()) 
+            {
+                std::string id = it->value().template as<std::string>(); 
+                // Add it to the list if it is not already there
+                if (std::find(new_uris.begin(), new_uris.end(), id) == new_uris.end())
+                {
+                    schema_location relative(id); 
+                    schema_location new_uri = relative.resolve(new_uris.back());
+                    new_uris.emplace_back(new_uri); 
+                }
+            }
+        }
+
+        return new_uris;
+    }
+
+} // namespace jsonschema
+} // namespace jsoncons
+
+#endif // JSONCONS_JSONSCHEMA_RULE_HPP

data/lib/jsoncons/jsoncons/include/jsoncons_ext/mergepatch/mergepatch.hpp

@@ -0,0 +1,103 @@
+// Copyright 2017 Daniel Parker
+// Distributed under the Boost license, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+// See https://github.com/danielaparker/jsoncons for latest version
+
+#ifndef JSONCONS_JSONMERGEPATCH_JSONMERGEPATCH_HPP
+#define JSONCONS_JSONMERGEPATCH_JSONMERGEPATCH_HPP
+
+#include <string>
+#include <vector> 
+#include <memory>
+#include <algorithm> // std::min
+#include <utility> // std::move
+#include <jsoncons/json.hpp>
+
+namespace jsoncons { 
+namespace mergepatch {
+
+    template <class Json>
+    Json from_diff(const Json& source, const Json& target)
+    {
+        if (!source.is_object() || !target.is_object())
+        {
+            return target;
+        }
+        Json result(json_object_arg);
+
+        for (const auto& member : source.object_range())
+        {
+            auto it = target.find(member.key());
+            if (it != target.object_range().end())
+            {
+                if (member.value() != it->value())
+                {
+                    result.try_emplace(member.key(), from_diff(member.value(), it->value()));
+                }
+            }
+            else
+            {
+                result.try_emplace(member.key(), Json::null());
+            }
+        }
+
+        for (const auto& member : target.object_range())
+        {
+            auto it = source.find(member.key());
+            if (it == source.object_range().end())
+            {
+                result.try_emplace(member.key(), member.value());
+            }
+        }
+
+        return result;
+    }
+
+    namespace detail {
+        template <class Json>
+        Json apply_merge_patch_(Json& target, const Json& patch)
+        {
+            if (patch.is_object())
+            {
+                if (!target.is_object())
+                {
+                    target = Json(json_object_arg);
+                }
+                for (auto& member : patch.object_range())
+                {
+                    auto it = target.find(member.key());
+                    if (it != target.object_range().end())
+                    {
+                        Json item = it->value();
+                        target.erase(it);
+                        if (!member.value().is_null())
+                        {
+                            target.try_emplace(member.key(), apply_merge_patch_(item, member.value()));
+                        }
+                    }
+                    else if (!member.value().is_null())
+                    {
+                        Json item(json_object_arg);
+                        target.try_emplace(member.key(), apply_merge_patch_(item, member.value()));
+                    }
+                }
+                return target;
+            }
+            else
+            {
+                return patch;
+            }
+        }
+    } // namespace detail
+
+    template <class Json>
+    void apply_merge_patch(Json& target, const Json& patch)
+    {
+        target = detail::apply_merge_patch_(target, patch);
+    }
+
+} // namespace mergepatch
+} // namespace jsoncons
+
+#endif