Collaboration diagram for root_schema:

Classes
struct	schema_file

Public Member Functions
	root_schema (schema_loader &&loader, format_checker &&format, content_checker &&content)
	root_schema (schema_loader &&loader, format_checker &&format, content_checker &&content)
format_checker &	format_check ()
format_checker &	format_check ()
content_checker &	content_check ()
content_checker &	content_check ()
void	insert (const json_uri &uri, const std::shared_ptr< schema > &s)
void	insert (const json_uri &uri, const std::shared_ptr< schema > &s)
void	insert_unknown_keyword (const json_uri &uri, const std::string &key, json &value)
void	insert_unknown_keyword (const json_uri &uri, const std::string &key, json &value)
std::shared_ptr< schema >	get_or_create_ref (const json_uri &uri)
std::shared_ptr< schema >	get_or_create_ref (const json_uri &uri)
void	set_root_schema (json sch)
void	set_root_schema (json sch)
void	validate (const json::json_pointer &ptr, const json &instance, json_patch &patch, error_handler &e, const json_uri &initial) const
void	validate (const json::json_pointer &ptr, const json &instance, json_patch &patch, error_handler &e, const json_uri &initial) const

Private Member Functions
schema_file &	get_or_create_file (const std::string &loc)
schema_file &	get_or_create_file (const std::string &loc)

Private Attributes
schema_loader	loader_
format_checker	format_check_
content_checker	content_check_
std::shared_ptr< schema >	root_
std::map< std::string, schema_file >	files_

Detailed Description

Definition at line 142 of file json-validator.cpp.

Constructor & Destructor Documentation

◆ root_schema() [1/2]

nlohmann::json_schema::root_schema::root_schema	(	schema_loader &&	loader,
		format_checker &&	format,
		content_checker &&	content )

inline

Definition at line 169 of file json-validator.cpp.

        : loader_(std::move(loader)),
          format_check_(std::move(format)),
          content_check_(std::move(content))
    {
    }

◆ root_schema() [2/2]

nlohmann::json_schema::root_schema::root_schema	(	schema_loader &&	loader,
		format_checker &&	format,
		content_checker &&	content )

inline

Definition at line 169 of file json-validator.cpp.

        : loader_(std::move(loader)),
          format_check_(std::move(format)),
          content_check_(std::move(content))
    {
    }

Member Function Documentation

◆ content_check() [1/2]

content_checker & nlohmann::json_schema::root_schema::content_check ( )

inline

Definition at line 180 of file json-validator.cpp.

180{ return content_check_; }

root_schema::content_check_

content_checker content_check_

Definition json-validator.cpp:146

◆ content_check() [2/2]

content_checker & nlohmann::json_schema::root_schema::content_check ( )

inline

Definition at line 180 of file json-validator.cpp.

180{ return content_check_; }

◆ format_check() [1/2]

format_checker & nlohmann::json_schema::root_schema::format_check ( )

inline

Definition at line 179 of file json-validator.cpp.

179{ return format_check_; }

root_schema::format_check_

format_checker format_check_

Definition json-validator.cpp:145

◆ format_check() [2/2]

format_checker & nlohmann::json_schema::root_schema::format_check ( )

inline

Definition at line 179 of file json-validator.cpp.

179{ return format_check_; }

◆ get_or_create_file() [1/2]

schema_file & nlohmann::json_schema::root_schema::get_or_create_file ( const std::string & loc )

inlineprivate

Definition at line 159 of file json-validator.cpp.

    {
        auto file = files_.lower_bound(loc);
        if (file != files_.end() && !(files_.key_comp()(loc, file->first)))
            return file->second;
        else
            return files_.insert(file, {loc, {}})->second;
    }

◆ get_or_create_file() [2/2]

schema_file & nlohmann::json_schema::root_schema::get_or_create_file ( const std::string & loc )

inlineprivate

Definition at line 159 of file json-validator.cpp.

    {
        auto file = files_.lower_bound(loc);
        if (file != files_.end() && !(files_.key_comp()(loc, file->first)))
            return file->second;
        else
            return files_.insert(file, {loc, {}})->second;
    }

◆ get_or_create_ref() [1/2]

std::shared_ptr< schema > nlohmann::json_schema::root_schema::get_or_create_ref ( const json_uri & uri )

inline

Definition at line 244 of file json-validator.cpp.

    {
        auto &file = get_or_create_file(uri.location());
 
        // existing schema
        auto sch = file.schemas.find(uri.fragment());
        if (sch != file.schemas.end())
            return sch->second;
 
        // referencing an unknown keyword, turn it into schema
        //
        // an unknown keyword can only be referenced by a json-pointer,
        // not by a plain name fragment
        if (!uri.pointer().to_string().empty()) {
            bool contains_pointer = file.unknown_keywords.contains(uri.pointer());
            if (contains_pointer) {
                auto &subschema = file.unknown_keywords.at(uri.pointer());
                auto s = schema::make(subschema, this, {}, {{uri}});
                if (s) { // if schema is valid (non-null)
                    file.unknown_keywords.erase(uri.fragment());
                    return s;
                }
            }
        }
 
        // get or create a schema_ref
        auto r = file.unresolved.lower_bound(uri.fragment());
        if (r != file.unresolved.end() && !(file.unresolved.key_comp()(uri.fragment(), r->first))) {
            return r->second; // unresolved, already seen previously - use existing reference
        } else {
            return file.unresolved.insert(r,
                                          {uri.fragment(), std::make_shared<schema_ref>(uri.to_string(), this)})
                ->second; // unresolved, create reference
        }
    }

◆ get_or_create_ref() [2/2]

std::shared_ptr< schema > nlohmann::json_schema::root_schema::get_or_create_ref ( const json_uri & uri )

inline

Definition at line 244 of file json-validator.cpp.

    {
        auto &file = get_or_create_file(uri.location());
 
        // existing schema
        auto sch = file.schemas.find(uri.fragment());
        if (sch != file.schemas.end())
            return sch->second;
 
        // referencing an unknown keyword, turn it into schema
        //
        // an unknown keyword can only be referenced by a json-pointer,
        // not by a plain name fragment
        if (!uri.pointer().to_string().empty()) {
            bool contains_pointer = file.unknown_keywords.contains(uri.pointer());
            if (contains_pointer) {
                auto &subschema = file.unknown_keywords.at(uri.pointer());
                auto s = schema::make(subschema, this, {}, {{uri}});
                if (s) { // if schema is valid (non-null)
                    file.unknown_keywords.erase(uri.fragment());
                    return s;
                }
            }
        }
 
        // get or create a schema_ref
        auto r = file.unresolved.lower_bound(uri.fragment());
        if (r != file.unresolved.end() && !(file.unresolved.key_comp()(uri.fragment(), r->first))) {
            return r->second; // unresolved, already seen previously - use existing reference
        } else {
            return file.unresolved.insert(r,
                                          {uri.fragment(), std::make_shared<schema_ref>(uri.to_string(), this)})
                ->second; // unresolved, create reference
        }
    }

◆ insert() [1/2]

void nlohmann::json_schema::root_schema::insert	(	const json_uri &	uri,
		const std::shared_ptr< schema > &	s )

inline

Definition at line 182 of file json-validator.cpp.

    {
        auto &file = get_or_create_file(uri.location());
        auto sch = file.schemas.lower_bound(uri.fragment());
        if (sch != file.schemas.end() && !(file.schemas.key_comp()(uri.fragment(), sch->first))) {
            throw std::invalid_argument("schema with " + uri.to_string() + " already inserted");
            return;
        }
 
        file.schemas.insert({uri.fragment(), s});
 
        // was someone referencing this newly inserted schema?
        auto unresolved = file.unresolved.find(uri.fragment());
        if (unresolved != file.unresolved.end()) {
            unresolved->second->set_target(s);
            file.unresolved.erase(unresolved);
        }
    }

◆ insert() [2/2]

void nlohmann::json_schema::root_schema::insert	(	const json_uri &	uri,
		const std::shared_ptr< schema > &	s )

inline

Definition at line 182 of file json-validator.cpp.

    {
        auto &file = get_or_create_file(uri.location());
        auto sch = file.schemas.lower_bound(uri.fragment());
        if (sch != file.schemas.end() && !(file.schemas.key_comp()(uri.fragment(), sch->first))) {
            throw std::invalid_argument("schema with " + uri.to_string() + " already inserted");
            return;
        }
 
        file.schemas.insert({uri.fragment(), s});
 
        // was someone referencing this newly inserted schema?
        auto unresolved = file.unresolved.find(uri.fragment());
        if (unresolved != file.unresolved.end()) {
            unresolved->second->set_target(s);
            file.unresolved.erase(unresolved);
        }
    }

◆ insert_unknown_keyword() [1/2]

void nlohmann::json_schema::root_schema::insert_unknown_keyword	(	const json_uri &	uri,
		const std::string &	key,
		json &	value )

inline

Definition at line 201 of file json-validator.cpp.

    {
        auto &file = get_or_create_file(uri.location());
        auto new_uri = uri.append(key);
        auto fragment = new_uri.pointer();
 
        // is there a reference looking for this unknown-keyword, which is thus no longer a unknown keyword but a schema
        auto unresolved = file.unresolved.find(fragment.to_string());
        if (unresolved != file.unresolved.end())
            schema::make(value, this, {}, {{new_uri}});
        else { // no, nothing ref'd it, keep for later
 
            // need to create an object for each reference-token in the
            // JSON-Pointer When not existing, a stringified integer reference
            // token (e.g. "123") in the middle of the pointer will be
            // interpreted a an array-index and an array will be created.
 
            // json_pointer's reference_tokens is private - get them
            std::deque<std::string> ref_tokens;
            auto uri_pointer = uri.pointer();
            while (!uri_pointer.empty()) {
                ref_tokens.push_front(uri_pointer.back());
                uri_pointer.pop_back();
            }
 
            // for each token create an object, if not already existing
            auto unk_kw = &file.unknown_keywords;
            for (auto &rt : ref_tokens) {
                // create a json_pointer from rt as rt can be an stringified integer doing find on an array won't work
                json::json_pointer rt_ptr{"/" + rt};
                if (unk_kw->contains(rt_ptr) == false)
                    (*unk_kw)[rt] = json::object();
                unk_kw = &(*unk_kw)[rt_ptr];
            }
            (*unk_kw)[key] = value;
        }
 
        // recursively add possible subschemas of unknown keywords
        if (value.type() == json::value_t::object)
            for (auto &subsch : value.items())
                insert_unknown_keyword(new_uri, subsch.key(), subsch.value());
    }

◆ insert_unknown_keyword() [2/2]

void nlohmann::json_schema::root_schema::insert_unknown_keyword	(	const json_uri &	uri,
		const std::string &	key,
		json &	value )

inline

Definition at line 201 of file json-validator.cpp.

    {
        auto &file = get_or_create_file(uri.location());
        auto new_uri = uri.append(key);
        auto fragment = new_uri.pointer();
 
        // is there a reference looking for this unknown-keyword, which is thus no longer a unknown keyword but a schema
        auto unresolved = file.unresolved.find(fragment.to_string());
        if (unresolved != file.unresolved.end())
            schema::make(value, this, {}, {{new_uri}});
        else { // no, nothing ref'd it, keep for later
 
            // need to create an object for each reference-token in the
            // JSON-Pointer When not existing, a stringified integer reference
            // token (e.g. "123") in the middle of the pointer will be
            // interpreted a an array-index and an array will be created.
 
            // json_pointer's reference_tokens is private - get them
            std::deque<std::string> ref_tokens;
            auto uri_pointer = uri.pointer();
            while (!uri_pointer.empty()) {
                ref_tokens.push_front(uri_pointer.back());
                uri_pointer.pop_back();
            }
 
            // for each token create an object, if not already existing
            auto unk_kw = &file.unknown_keywords;
            for (auto &rt : ref_tokens) {
                // create a json_pointer from rt as rt can be an stringified integer doing find on an array won't work
                json::json_pointer rt_ptr{"/" + rt};
                if (unk_kw->contains(rt_ptr) == false)
                    (*unk_kw)[rt] = json::object();
                unk_kw = &(*unk_kw)[rt_ptr];
            }
            (*unk_kw)[key] = value;
        }
 
        // recursively add possible subschemas of unknown keywords
        if (value.type() == json::value_t::object)
            for (auto &subsch : value.items())
                insert_unknown_keyword(new_uri, subsch.key(), subsch.value());
    }

◆ set_root_schema() [1/2]

void nlohmann::json_schema::root_schema::set_root_schema ( json sch )

inline

Definition at line 280 of file json-validator.cpp.

    {
        files_.clear();
        root_ = schema::make(sch, this, {}, {{"#"}});
 
        // load all files which have not yet been loaded
        do {
            bool new_schema_loaded = false;
 
            // files_ is modified during parsing, iterators are invalidated
            std::vector<std::string> locations;
            for (auto &file : files_)
                locations.push_back(file.first);
 
            for (auto &loc : locations) {
                if (files_[loc].schemas.size() == 0) { // nothing has been loaded for this file
                    if (loader_) {
                        json loaded_schema;
 
                        loader_(loc, loaded_schema);
 
                        schema::make(loaded_schema, this, {}, {{loc}});
                        new_schema_loaded = true;
                    } else {
                        throw std::invalid_argument("external schema reference '" + loc + "' needs loading, but no loader callback given");
                    }
                }
            }
 
            if (!new_schema_loaded) // if no new schema loaded, no need to try again
                break;
        } while (1);
 
        for (const auto &file : files_) {
            if (file.second.unresolved.size() != 0) {
                // Build a representation of the undefined
                // references as a list of comma-separated strings.
                auto n_urefs = file.second.unresolved.size();
                std::string urefs = "[";
 
                decltype(n_urefs) counter = 0;
                for (const auto &p : file.second.unresolved) {
                    urefs += p.first;
 
                    if (counter != n_urefs - 1u) {
                        urefs += ", ";
                    }
 
                    ++counter;
                }
 
                urefs += "]";
 
                throw std::invalid_argument("after all files have been parsed, '" +
                                            (file.first == "" ? "<root>" : file.first) +
                                            "' has still the following undefined references: " + urefs);
            }
        }
    }

◆ set_root_schema() [2/2]

void nlohmann::json_schema::root_schema::set_root_schema ( json sch )

inline

Definition at line 280 of file json-validator.cpp.

    {
        files_.clear();
        root_ = schema::make(sch, this, {}, {{"#"}});
 
        // load all files which have not yet been loaded
        do {
            bool new_schema_loaded = false;
 
            // files_ is modified during parsing, iterators are invalidated
            std::vector<std::string> locations;
            for (auto &file : files_)
                locations.push_back(file.first);
 
            for (auto &loc : locations) {
                if (files_[loc].schemas.size() == 0) { // nothing has been loaded for this file
                    if (loader_) {
                        json loaded_schema;
 
                        loader_(loc, loaded_schema);
 
                        schema::make(loaded_schema, this, {}, {{loc}});
                        new_schema_loaded = true;
                    } else {
                        throw std::invalid_argument("external schema reference '" + loc + "' needs loading, but no loader callback given");
                    }
                }
            }
 
            if (!new_schema_loaded) // if no new schema loaded, no need to try again
                break;
        } while (1);
 
        for (const auto &file : files_) {
            if (file.second.unresolved.size() != 0) {
                // Build a representation of the undefined
                // references as a list of comma-separated strings.
                auto n_urefs = file.second.unresolved.size();
                std::string urefs = "[";
 
                decltype(n_urefs) counter = 0;
                for (const auto &p : file.second.unresolved) {
                    urefs += p.first;
 
                    if (counter != n_urefs - 1u) {
                        urefs += ", ";
                    }
 
                    ++counter;
                }
 
                urefs += "]";
 
                throw std::invalid_argument("after all files have been parsed, '" +
                                            (file.first == "" ? "<root>" : file.first) +
                                            "' has still the following undefined references: " + urefs);
            }
        }
    }

◆ validate() [1/2]

void nlohmann::json_schema::root_schema::validate	(	const json::json_pointer &	ptr,
		const json &	instance,
		json_patch &	patch,
		error_handler &	e,
		const json_uri &	initial ) const

inline

Definition at line 340 of file json-validator.cpp.

    {
        if (!root_) {
            e.error(ptr, "", "no root schema has yet been set for validating an instance");
            return;
        }
 
        auto file_entry = files_.find(initial.location());
        if (file_entry == files_.end()) {
            e.error(ptr, "", "no file found serving requested root-URI. " + initial.location());
            return;
        }
 
        auto &file = file_entry->second;
        auto sch = file.schemas.find(initial.fragment());
        if (sch == file.schemas.end()) {
            e.error(ptr, "", "no schema find for request initial URI: " + initial.to_string());
            return;
        }
 
        sch->second->validate(ptr, instance, patch, e);
    }

◆ validate() [2/2]

void nlohmann::json_schema::root_schema::validate	(	const json::json_pointer &	ptr,
		const json &	instance,
		json_patch &	patch,
		error_handler &	e,
		const json_uri &	initial ) const

inline

Definition at line 340 of file json-validator.cpp.

    {
        if (!root_) {
            e.error(ptr, "", "no root schema has yet been set for validating an instance");
            return;
        }
 
        auto file_entry = files_.find(initial.location());
        if (file_entry == files_.end()) {
            e.error(ptr, "", "no file found serving requested root-URI. " + initial.location());
            return;
        }
 
        auto &file = file_entry->second;
        auto sch = file.schemas.find(initial.fragment());
        if (sch == file.schemas.end()) {
            e.error(ptr, "", "no schema find for request initial URI: " + initial.to_string());
            return;
        }
 
        sch->second->validate(ptr, instance, patch, e);
    }

Member Data Documentation

◆ content_check_

content_checker nlohmann::json_schema::root_schema::content_check_

private

Definition at line 146 of file json-validator.cpp.

◆ files_

std::map< std::string, schema_file > nlohmann::json_schema::root_schema::files_

private

Definition at line 157 of file json-validator.cpp.

◆ format_check_

format_checker nlohmann::json_schema::root_schema::format_check_

private

Definition at line 145 of file json-validator.cpp.

◆ loader_

schema_loader nlohmann::json_schema::root_schema::loader_

private

Definition at line 144 of file json-validator.cpp.

◆ root_

std::shared_ptr< schema > nlohmann::json_schema::root_schema::root_

private

Definition at line 148 of file json-validator.cpp.

The documentation for this class was generated from the following file:

lib/json-schema-validator/src/json-validator.cpp

MQTTSuite

Classes

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ root_schema() [1/2]

◆ root_schema() [2/2]

Member Function Documentation

◆ content_check() [1/2]

◆ content_check() [2/2]

◆ format_check() [1/2]

◆ format_check() [2/2]

◆ get_or_create_file() [1/2]

◆ get_or_create_file() [2/2]

◆ get_or_create_ref() [1/2]

◆ get_or_create_ref() [2/2]

◆ insert() [1/2]

◆ insert() [2/2]

◆ insert_unknown_keyword() [1/2]

◆ insert_unknown_keyword() [2/2]

◆ set_root_schema() [1/2]

◆ set_root_schema() [2/2]

◆ validate() [1/2]

◆ validate() [2/2]

Member Data Documentation

◆ content_check_

◆ files_

◆ format_check_

◆ loader_

◆ root_