All Classes and Interfaces
Class
Description
An evaluator with building function extensions.
A function extension that can make new JSON values (RFC 9535, Section 2.4).
A side of a comparison, or a ValueType function argument: a literal, a singular query, or a
function with the result type ValueType (RFC 9535, Sections 2.3.5.1 and 2.4.3).
A comparison operator (RFC 9535, Section 2.3.5.1).
Runs the test suites of RFC 9535 and RFC 6902 on a model, as JUnit dynamic tests.
The reason why the evaluator cannot give a correct result.
A function extension returned an instance of the wrong type.
An index or a slice parameter is outside the I-JSON range.
Overflow indication: a nodelist has more nodes than the limit (RFC 9535, Section 2.1).
The query has more nested expressions than
JsonPathEvaluator.MAX_QUERY_DEPTH.Overflow indication: a regular expression of match() or search() is valid, but too complex
to evaluate in the resource limits (RFC 9485, Section 8).
A function call has a result type, a number of arguments, or argument types that do not
agree with the signature of the function.
The query calls a function that the evaluator does not have.
An error in the function extensions given to
JsonPathEvaluator.withFunctions(List).Two functions have the same name.
The name does not agree with the grammar rule
function-name.A read-only
FunctionExtension has a ValueType parameter.A query in a filter expression:
@ or $ followed by zero or more segments
(RFC 9535, Section 2.3.5.1).A function argument, with the declared type of its parameter (RFC 9535, Section 2.4.3).
An argument for a LogicalType parameter.
An argument for a NodesType parameter.
An argument for a ValueType parameter.
A function expression (RFC 9535, Section 2.4).
A call of a function with the result type LogicalType.
A call of a function with the result type NodesType.
A call of a function with the result type ValueType.
A read-only function extension (RFC 9535, Section 2.4).
An error in the function signatures given to
JsonPathParser.withFunctions(List).Two functions have the same name.
The name does not agree with the grammar rule
function-name.The name and the declared types of a function extension (RFC 9535, Section 2.4).
The declared type of a function parameter or result (RFC 9535, Section 2.4.1).
The start of a query in a filter expression (RFC 9535, Sections 2.2 and 2.3.5).
An instance of a declared type: a function argument or a function result
(RFC 9535, Section 2.4.1, Table 13).
An instance of LogicalType: LogicalTrue or LogicalFalse.
An instance of NodesType: a nodelist.
An instance of ValueType: a node, or Nothing.
A
JsonModel for Jackson 3 JsonNode values.A JSON document that a Jackson streaming
JsonParser reads on demand, with no tree.A value of a
JacksonStream.An exact decimal number with no limit on its size or on its exponent.
Changes the caller's JSON values in place.
Tests that a model that also implements
JsonEditor is well-formed: each change gives the
expected value, each method returns the value that it replaced or removed, and the reverse
changes give the original value again.Builds nodes of the caller's JSON representation.
Tests that a model that also implements
JsonFactory is well-formed: each built node has
the correct kind, and the read methods give the exact value again.The kind of a JSON value, as RFC 8259 defines it.
Gives jsonlens read access to JSON values in the caller's own representation.
Tests that a
JsonModel obeys its contract, as JUnit tests.A JSON number in a representation that the model chooses.
A JSON Patch (RFC 6902): a sequence of operations that changes a JSON document.
Applies a
JsonPathQuery to a JSON value (RFC 9535).Resource limits.
Makes a
JsonPathQuery from query text (RFC 9535).A JSONPath query: the root identifier
$ followed by zero or more segments
(RFC 9535, Section 2.1.1).A JSON Pointer (RFC 6901): a sequence of reference tokens that identifies a value in a JSON
document.
A JSON string in a representation that the model chooses.
A literal value in a filter expression (RFC 9535, Section 2.3.5.1).
The literal
true or false.The literal
null.A number literal.
A string literal.
An expression with a logical result: LogicalTrue or LogicalFalse (RFC 9535, Section 2.3.5).
A conjunction:
a && b && ....A comparison:
left op right (Section 2.3.5.2.2).A negation:
!a.A disjunction:
a || b || ....A JSON text in UTF-8 bytes, for example a memory-mapped file, with a read-only
JsonModel.The reason why
MappedJson cannot read the bytes or the file.The file is too large.
The bytes do not agree with the JSON grammar of RFC 8259.
The bytes are not well-formed UTF-8 (RFC 3629).
The file cannot be opened or mapped.
A JSON value in a
MappedJson.A value that can be absent:
Maybe.Some value or Maybe.None.An absent value.
A present value.
Walks the members of one object, in order: the result of
JsonModel.memberCursor(Object).A node: a JSON value and its location in the query argument (RFC 9535, Section 1.1).
A NodesType function argument: a query or a function with the result type NodesType
(RFC 9535, Section 2.4.3).
The location of a node in a JSON value, as RFC 9535, Section 2.7 defines it.
The path of an array element:
parent[index].The path of a member value:
parent['name'].The path of the root node:
$.An operation of a JSON Patch (RFC 6902, Section 4).
add (Section 4.1): adds a member, inserts an array element, or replaces the whole
document.copy (Section 4.5): adds a copy of the value at from at the target location.move (Section 4.4): removes the value at from and adds it at the target location.remove (Section 4.2): removes the value at the target location.replace (Section 4.3): replaces the value at the target location.test (Section 4.6): tests that the value at the target location is equal to a value.The reason why a query is not well-formed or not valid (RFC 9535, Section 2.1).
An argument does not agree with the declared type of its parameter (Section 2.4.3).
A string literal contains an unescaped control character, U+0000 to U+001F (Section 2.3.1.1).
An index or a slice parameter is outside the I-JSON range (Section 2.1).
A string literal contains an escape that is not permitted (Section 2.3.1.1).
An integer has a leading zero, or is
-0 where only an int is permitted.The bytes are not well-formed UTF-8 (Section 2.1).
A literal is a test expression.
The query has too many nested levels (Section 4.1).
A query that is not singular is a side of a comparison, or a ValueType argument
(Sections 2.3.5.1 and 2.4.3).
A function with the result type LogicalType or NodesType is a side of a comparison
(Section 2.4.3).
A number literal has an exponent that is too large to represent.
The grammar does not permit the character at this position.
The query ends before it is complete.
The query calls a function that is not registered (Section 2.4).
The query contains an unpaired surrogate, or a backslash-u escape for one
(Sections 1.1 and 2.3.1.1).
A function with the result type ValueType is a test expression (Section 2.4.3).
A function call has the wrong number of arguments (Section 2.4.3).
An error of a JSON Patch: a patch document that violates RFC 6902, or an operation that is not
successful (RFC 6902, Section 5).
An operation has a member more than once.
The
from location of a move or a copy does not exist (Sections 4.4 and 4.5).The
path or from member of an operation is not a valid JSON Pointer.An operation has no member that it needs:
op and path (Section 4), value for add,
replace, and test, or from for move and copy.The
from location of a move is a proper prefix of its path (Section 4.4).The patch document is not an array (RFC 6902, Section 3).
An operation is not an object (RFC 6902, Section 3).
The
op, path, or from member of an operation is not a string.The target location does not exist.
A
remove has the whole document as its target.The value at the target location of a
test is not equal to its value (Section 4.6).The
op of an operation is not one of the six operations (Section 4).The value of an operation cannot be added to the target document: the target model cannot
hold one of its numbers, for example
1e99999999999 in a Jackson tree, or an object of the
value has duplicate member names, which have no defined value (RFC 8259, Section 4).An error of a JSON Pointer (RFC 6901, Section 7): invalid syntax, or a pointer that does not
reference a value.
An object has more than one member with the name of a token.
An array index is not less than the length of the array.
A
~ is not followed by 0 or 1 (RFC 6901, Section 3).A URI fragment identifier is not a valid JSON Pointer (RFC 6901, Section 6): it does not
start with
#, it has a character that a fragment does not permit, a percent-encoding is
not complete, or the bytes are not UTF-8.A token for an array is not an array index: digits without a leading zero (RFC 6901,
Section 4).
An object has no member with the name of a token.
A pointer that is not empty does not start with
/ (RFC 6901, Section 3).A token follows a value that is not an object or an array.
A member of a JSON object: a name and a value (RFC 9535, Section 1.1).
Makes random JSON texts (RFC 8259) from a seed.
The result of an operation that can fail: a success value (
Result.Ok) or an error value (Result.Err).An error value.
A success value.
A rule of the
JsonModel contract that ModelVerifier checks.A segment: it applies its selectors to the children or descendants of a node (RFC 9535, Section 2.5).
A child segment:
[<selectors>], .name, or .* (Section 2.5.1).A descendant segment:
..[<selectors>], ..name, or ..* (Section 2.5.2).A selector in a segment (RFC 9535, Section 2.3).
A filter selector:
?<logical-expr> (Section 2.3.5).An index selector (Section 2.3.3).
A name selector:
'name' or "name" (Section 2.3.1).An array slice selector:
start:end:step (Section 2.3.4).The wildcard selector:
* (Section 2.3.2).A singular query: a query that selects at most one node (RFC 9535, Section 2.3.5.1).
A segment of a singular query (RFC 9535, Section 2.3.5.1).
An index segment:
[index].A name segment:
['name'] or .name.An error of a
JacksonStream: the parser could not give a JSON text.The input has no value.
The parser gave a token that is not a JSON value.
The parser failed.
The input has more tokens after the root value.
A value of a document that breaks a
Rule.