valijson

The function valijson::internal::uri::resolveRelativeUri is used to resolve URI references against a base resolution scope.

Warning for Developers: The current implementation has several documented deviations from the RFC 3986 standard. If your application relies on strict RFC 3986 compliance for URI resolution, be aware of the following behaviors:

• Scheme Detection: The implementation only recognizes schemes followed by ://. Absolute references like mailto:user@example.com, data:..., or file:/... may not be recognized as absolute and might be incorrectly resolved against the base URI.
• Network-path References: References starting with // are treated as absolute paths that retain the old authority, rather than supplying a new authority. This also causes leading slashes to be collapsed.
• Query and Fragment Handling: Resolving a fragment-only reference (e.g., #s) against a base URI that contains a query (e.g., ?q) will cause the base query to be lost.
• Dot Segments: Terminal . and .. segments do not preserve the trailing slash that RFC 3986 implies.
• Path Normalization: The implementation discards empty path segments (e.g., g//h becomes g/h).
• Authority Extraction: The implementation may incorrectly include query strings or fragments in the authority if the base URI does not contain a / before the ? or #.

When building a schema programmatically using the Schema class, Valijson uses RAII semantics. The root Schema object manages the memory for all allocated constraints and sub-schemas.

• schema.createSubschema() returns a const Subschema*. This memory is owned by the root Schema and is freed when the root object goes out of scope.
• Constraints added via schema.addConstraintToSubschema or schema.addConstraint are copied into the memory managed by the root Schema object.

{
    Schema schema;
    const Subschema *subschema = schema.createSubschema();

    {
        TypeConstraint typeConstraint;
        typeConstraint.addNamedType(TypeConstraint::kString);
        schema.addConstraintToSubschema(typeConstraint, subschema);
    }

    PropertiesConstraint propertiesConstraint;
    propertiesConstraint.addPropertySubschema("description", subschema);
    schema.addConstraint(propertiesConstraint);
}
// All allocated memory is freed here when 'schema' goes out of scope

Keywords that require a nested schema (such as properties, additionalProperties, or patternProperties) trigger a recursive parsing step.

Valijson uses makeOrReuseSchema() to handle this. This function manages the creation of new subschemas or the reuse of existing ones from the SchemaRegistry, ensuring that the hierarchical structure of the JSON Schema is correctly captured in the internal Schema representation.

template<typename AdapterType>
const Subschema * makeOrReuseSchema(
    Schema &rootSchema,
    const AdapterType &rootNode,
    const AdapterType &node,
    const opt::optional<std::string> currentScope,
    const std::string &nodePath,
    const typename FunctionPtrs<AdapterType>::FetchDoc fetchDoc,
    const Subschema *parentSubschema,
    const std::string *ownName,
    typename DocumentCache<AdapterType>::Type &docCache,
    SchemaRegistry &schemaRegistry);

Valijson uses an adapter-based architecture to support multiple JSON parser libraries (such as NlohmannJSON, RapidJSON, and JsonCpp) without sacrificing performance.

Instead of using heavy dynamic dispatch (polymorphism) for all operations, Valijson uses C++ Class Templates (a variation of Policy-based Design). This allows the compiler to optimize the validation logic specifically for the chosen parser, providing performance competitive with hand-written validators.

Key Concepts:

• Parser Adapter: A facade for a specific JSON parser that conforms to the interface required by Valijson's validator.
• Static Dispatch: Used for the performance-critical validation paths via templates.
• Dynamic Dispatch & Frozen Values: Used when the validator needs to store schema values (like those in an enum or const keyword) that must be compared against documents from potentially different parsers. The adapter provides a freeze operation that type-erases the data into a FrozenValue object, allowing the validator to interact with it through a uniform virtual interface.