All Classes and Interfaces
Class
Description
AccState for yielding a sequence of items without enclosing them in an array;
because the array would be a single object-notation entity on its own.
Base class for acc states that produce GON output.
Transition to a sub-acc state if a condition is met.
The driver is the class that has a reference to the accumulator that will receive the next input.
AccState that creates a new object whether a new objectId is encountered.
AccState that creates a new object whether a new objectId is encountered.
AccState for producing generalized object notation (gon) structures.
An acc state that merely transitions to the root state.
AccStateLiteral:
Extracts a value from the input and forwards it to the writer.
This mapper only generates the keys - it does not generate the enclosing start/end object tags.
Common base class for accumulators of Objects and Fragments.
AccState that creates a new object whether a new objectId is encountered.
Type for accumulators that accept values (arrays as items or fields as values).
Accumulator that produces entries, i.e.
AccState that PRODUCES literals, objects or arrays - but not entries.
Accumulator that produces objects.
A builder for a set of sub-selections.
AggStateBuilderLiteral: Only used with @index as a leaf value.
If the state matches, then a set of fields may be emitted.
Literal properties can suppress emitting null values.
Builder base class that match on a state id and have a single sub-builder.
Builder base class for aggregators that match on a state id.
Subclasses are Literal, Object or Null.
AggState for a preset member key.
AggState that does NOT PRODUCE entries.
Base class for objects that contain multiple selections.
A view over a binding.
Expression by which to filter the parent resources.
Describes the variables for a
Connective but does not specify the graph pattern.The attributes of the node are static, but the children are mutable.
Helper class add child nodes.
Which variables of the parent join with which variables of the child
Could extend to List>Expr< or ExprList
A bottom-up application of a transformation of SPARQL syntax Elements.
Transformation function on an Element that does nothing.
An
ElementTransform which replaces occurences of a variable with a
Node value.A copying transform that applies an ElementTransform syntax pattern of
E_Exist and E_NoExists
Special version of ExprTransform for applying a node transform on syntax
(Elements) only
Reference to a variable in a field.
A data model for RDF tree structures akin to gson's JsonElement.
A literal simply wraps a node.
An RDF counterpart to a JSON object.
This class adds the generic type parameter T for the objects being constructed by the writer.
Enum to capture what types of parents are valid for a given gon element.
Intended uses:
@graph(iri: "http://foo") -> GRAPH <http://foo> { }
@graph(var: "g") -> GRAPH ?g { }
Not yet supported: @graph(iri: ["foo", "bar"]) -> GRAPH ?allocVar { } FILTER(?allocVar IN (<foo>, <bar>))
var and iri would result in FILTER(var = iri)
A restricted graph implementation for traversal over object structures.
Adapter to wrap the execution's intended for individual nodes as one for an overall document.
Builds GraphQl execution objects from a document and variables.
Common interface for graphql-based execution - whether its for individual fields
or whole documents.
Execution for producing the results for a field and its sub-tree in a graphql document.
Intermediate state for generating the final SPARQL query.
Methods to create sinks for use with
GraphQlExec.sendNextItemToWriter(ObjectNotationWriter).Utils to configure a graphql processor from JSON.
Writes out the data streams of a GraphQlExec to the an OutputStream.
Checks for @pattern directives.
@index(by: varOrVarArray[, expr: exprOverVars])
The idea is to allow ordering by a given list of variables, and have a separate expression for the effective output.
@join(this: ['x', 'y'], parent: ['v', 'w'])
The motivation for this abstraction was to have a JsonWriter which can assemble JsonObjects.
Wrapper for Node.
Object notation writers support objects (aka "associative arrays", "dictionaries", "maps")
and arrays.
Deprecated.
Combines a writer for the generic types K, V with an in memory sink for an object notation Java type T (e.g.
Writer with an in-memory destination.
The query mapping contains the final sparql query, the corresponding accumulator, and
any additional information needed to produce the overall object notation result.
Support for transformation of query abstract syntax.
A data model for RDF tree structures akin to gson's JsonElement.
Idea: Instead of accessing fields directly - which may be null - return an API that can create those if desired.
Base class for RDF elements which correspond to resources in an RDF graph -
namely objects and arrays.
If rdfTermMode is true, then all json literals will be strings that
contain RDF terms in n-triples syntax.
Json-NT is simply json where keys and literals are all strings that contain
RDF terms in n-triples serialization.
Visitor the writes out a RON structure in JSON.
A literal simply wraps a node.
An RDF counterpart to a JSON object.
Interface for things that can be traversed with RDF properties in forward or backward direction.
Abstraction akin to JSONPath's JsonProvidere.
If for a field being visited there is no root marker in the parent context then that field must be a root field.
Base type for individual members of selection set.
Interface for things that can be traversed with SPARQL 1.1 property paths.
Transforms a GraphQL document such that all query operations, fields are assigned a
@globalId(id: "abc") directive.Base class for transforms that move a directive on a top level field to the query level.
Expand prefixes in the following directives:
@pattern(of: "?s rdfs:label ?o")
@rdf(iri: "rdf:type")
Expands:
@prefix
@graph
@service
@vocab
@reverse
@iri
@source
@class
@emitRdfKey
Order of resolution:
if vocab is given then build tentative field iri/li>
if iri is given then override the field iri
if class is given then use the field iri to build a @source directive
interplay of source and pattern: source would filter the sources of a given pattern.
Collects all prefix directives and merges them into a single one.
Adapter that converts directives from the Tentris system to those of our system.
Adds
Adds
Adds
Adds
Wrap Jena SDB's Generator to yield objects of type Var
Jena lacks a method that directly extracts all in-scope variables of an Op.
Methods for working with scope levels of SPARQL variables.
Intended use:
myField @vocab(iri: "http://foo/") -> Unless overridden, this field
and all children are interpreted as having the annotation @rdf(iri: vocab + fieldName).