org.apache.commons.rdf.jena

Class JenaRDF

java.lang.Object

org.apache.commons.rdf.jena.JenaRDF

All Implemented Interfaces:

RDF

public final class JenaRDF
extends Object
implements RDF

Apache Jena RDF implementation.

Instances of JenaRDF can also convert existing objects from Jena with methods like asRDFTerm(Node) and asGraph(org.apache.jena.graph.Graph), and vice versa from any Commons RDF object to Jena with the asJena* methods like asJenaNode(RDFTerm) and asJenaGraph(Graph).

Note that Commons RDF objects created by this class implement the specializations interfaces like JenaRDFTerm, JenaGraph and JenaTriple, which provide access to the underlying Jena objects, e.g. with JenaRDFTerm.asJenaNode().

For the purpose of BlankNode identity when using createBlankNode(String) (see BlankNode.equals(Object) and BlankNode.uniqueReference()), each instance of JenaRDF uses an internal random state. If for some reason consistent/reproducible BlankNode identity is desired, it is possible to retrieve the state as a UUID using salt() for subsequent use with JenaRDF(UUID) - note that such consistency is only guaranteed within the same minor version of Commons RDF.

See Also:

RDF

Constructor Summary

Constructors

Constructor and Description
JenaRDF() Create a JenaRDF.
JenaRDF(UUID salt) Create a JenaRDF.

Method Summary

Modifier and Type	Method and Description
JenaDataset	asDataset(org.apache.jena.query.Dataset datasetGraph) Adapt an existing Jena Dataset to CommonsRDF Dataset.
JenaDataset	asDataset(org.apache.jena.sparql.core.DatasetGraph datasetGraph) Adapt an existing Jena DatasetGraph to CommonsRDF Dataset.
JenaQuadLike<RDFTerm>	asGeneralizedQuad(org.apache.jena.sparql.core.Quad quad) Adapt a generalized Jena Quad to a CommonsRDF QuadLike.
JenaTripleLike	asGeneralizedTriple(org.apache.jena.graph.Triple triple) Adapt a generalized Jena Triple to a CommonsRDF TripleLike.
JenaGraph	asGraph(org.apache.jena.graph.Graph graph) Adapt an existing Jena Graph to CommonsRDF Graph.
JenaGraph	asGraph(org.apache.jena.rdf.model.Model model) Adapt an existing Jena Model to CommonsRDF Graph.
org.apache.jena.query.Dataset	asJenaDataset(Dataset dataset) Convert a CommonsRDF Dataset to a Jena Dataset.
org.apache.jena.sparql.core.DatasetGraph	asJenaDatasetGraph(Dataset dataset) Convert a CommonsRDF Dataset to a Jena DatasetGraph.
org.apache.jena.graph.Graph	asJenaGraph(Graph graph) Convert a CommonsRDF Graph to a Jena Graph.
Optional<org.apache.jena.riot.Lang>	asJenaLang(RDFSyntax rdfSyntax) Return Jena Lang corresponding to a RDFSyntax.
org.apache.jena.graph.Node	asJenaNode(RDFTerm term) Convert a CommonsRDF RDFTerm to a Jena Node.
org.apache.jena.sparql.core.Quad	asJenaQuad(Quad quad) Convert a CommonsRDF Quad to a Jena Quad.
org.apache.jena.graph.Triple	asJenaTriple(Triple triple) Convert a CommonsRDF Triple to a Jena Triple.
JenaQuad	asQuad(org.apache.jena.sparql.core.Quad quad) Adapt an existing Jena Quad to CommonsRDF Quad.
static Quad	asQuad(RDF factory, org.apache.jena.sparql.core.Quad quad) Convert from Jena Quad to a Commons RDF Quad.
Optional<RDFSyntax>	asRDFSyntax(org.apache.jena.riot.Lang lang) Return RDFSyntax corresponding to a Jena Lang.
JenaRDFTerm	asRDFTerm(org.apache.jena.graph.Node node) Adapt an existing Jena Node to CommonsRDF RDFTerm.
static RDFTerm	asRDFTerm(RDF factory, org.apache.jena.graph.Node node) Convert from Jena Node to any Commons RDF implementation.
static Triple	asTriple(RDF factory, org.apache.jena.graph.Triple triple) Convert from Jena Triple to a Commons RDF Triple.
JenaTriple	asTriple(org.apache.jena.graph.Triple triple) Adapt an existing Jena Triple to CommonsRDF Triple.
JenaBlankNode	createBlankNode() Create a new blank node.
JenaBlankNode	createBlankNode(String name) Create a blank node based on the given name.
JenaDataset	createDataset() Create a new dataset.
JenaGeneralizedQuadLike	createGeneralizedQuad(RDFTerm subject, RDFTerm predicate, RDFTerm object, RDFTerm graphName) Create a generalized Jena quad.
JenaGeneralizedTripleLike	createGeneralizedTriple(RDFTerm subject, RDFTerm predicate, RDFTerm object) Create a generalized Jena triple.
JenaGraph	createGraph() Create a new graph.
JenaIRI	createIRI(String iri) Create an IRI from a (possibly escaped) String.
JenaLiteral	createLiteral(String lexicalForm) Create a simple literal.
JenaLiteral	createLiteral(String lexicalForm, IRI dataType) Create a literal with the specified data type.
JenaLiteral	createLiteral(String lexicalForm, String languageTag) Create a language-tagged literal.
JenaQuad	createQuad(BlankNodeOrIRI graphName, BlankNodeOrIRI subject, IRI predicate, RDFTerm object) Create a quad.
JenaTriple	createTriple(BlankNodeOrIRI subject, IRI predicate, RDFTerm object) Create a triple.
UUID	salt() Return the UUID salt used by this factory.
org.apache.jena.riot.system.StreamRDF	streamJenaToGeneralizedQuad(Consumer<QuadLike<RDFTerm>> generalizedConsumer) Create a StreamRDF instance that inserts generalized QuadLikes.
org.apache.jena.riot.system.StreamRDF	streamJenaToGeneralizedTriple(Consumer<TripleLike> generalizedConsumer) Create a StreamRDF instance that inserts generalized TripleLikes.
static org.apache.jena.riot.system.StreamRDF	streamJenaToQuad(RDF factory, Consumer<Quad> consumer) Create a StreamRDF instance that inserts the converted Quads.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

JenaRDF

public JenaRDF()

Create a JenaRDF.

This constructor will use a randomly generated UUID as a salt for the purposes of BlankNode identity, see salt().

JenaRDF

public JenaRDF(UUID salt)

Create a JenaRDF.

This constructor will use the specified UUID as a salt for the purposes of BlankNode identity, and should only be used in cases where predictable and consistent BlankNode.uniqueReference() are important.

Parameters:

salt - UUID to use as salt for BlankNode equality

Method Detail

createBlankNode

public JenaBlankNode createBlankNode()

Description copied from interface: RDF

Create a new blank node.

The returned blank node MUST NOT be equal to any existing BlankNode instances according to BlankNode.equals(Object).

Specified by:

createBlankNode in interface RDF

Returns:

A new, unique BlankNode

createBlankNode

public JenaBlankNode createBlankNode(String name)

Description copied from interface: RDF

Create a blank node based on the given name.

All BlankNodes created with the given name on a particular instance of RDF MUST be equivalent according to BlankNode.equals(Object),

The returned BlankNode MUST NOT be equal to BlankNode instances returned for any other name or those returned from RDF.createBlankNode().

The returned BlankNode SHOULD NOT be equivalent to any BlankNodes created on a different RDF instance, e.g. different instances of RDF should produce different blank nodes for the same name unless they purposely are intending to create equivalent BlankNode instances (e.g. a reinstated Serializable factory).

Specified by:

createBlankNode in interface RDF

Parameters:

name - A non-empty, non-null, String that is unique to this blank node in the context of this RDF.

Returns:

A BlankNode for the given name

createDataset

public JenaDataset createDataset()

Description copied from interface: RDF

Create a new dataset. It is undefined if the dataset will be persisted by any underlying storage mechanism.

Specified by:

createDataset in interface RDF

Returns:

A new Dataset

createGraph

public JenaGraph createGraph()

Description copied from interface: RDF

Create a new graph. It is undefined if the graph will be persisted by any underlying storage mechanism.

Specified by:

createGraph in interface RDF

Returns:

A new Graph

createIRI

public JenaIRI createIRI(String iri)

Description copied from interface: RDF

Create an IRI from a (possibly escaped) String. The provided iri string MUST be valid according to the W3C RDF-1.1 IRI definition.

Specified by:

createIRI in interface RDF

Parameters:

iri - Internationalized Resource Identifier

Returns:

A new IRI

createLiteral

public JenaLiteral createLiteral(String lexicalForm)

Description copied from interface: RDF

Create a simple literal. The provided lexical form should not be escaped in any sense, e.g. should not include "quotes" unless those are part of the literal value. The returned Literal MUST have a Literal.getLexicalForm() that is equal to the provided lexical form, MUST NOT have a Literal.getLanguageTag() present, and SHOULD return a Literal.getDatatype() that is equal to the IRI http://www.w3.org/2001/XMLSchema#string.

Specified by:

createLiteral in interface RDF

Parameters:

lexicalForm - The literal value in plain text

Returns:

The created Literal

createLiteral

public JenaLiteral createLiteral(String lexicalForm,
                                 IRI dataType)

Description copied from interface: RDF

Create a literal with the specified data type. The provided lexical form should not be escaped in any sense, e.g. should not include "quotes" unless those are part of the literal value. It is RECOMMENDED that the provided dataType is one of the RDF-compatible XSD types. The provided lexical form SHOULD be in the lexical space of the provided dataType. The returned Literal SHOULD have a Literal.getLexicalForm() that is equal to the provided lexicalForm, MUST NOT have a Literal.getLanguageTag() present, and MUST return a Literal.getDatatype() that is equivalent to the provided dataType IRI.

Specified by:

createLiteral in interface RDF

Parameters:

lexicalForm - The literal value

dataType - The data type IRI for the literal value, e.g. http://www.w3.org/2001/XMLSchema#integer

Returns:

The created Literal

createLiteral

public JenaLiteral createLiteral(String lexicalForm,
                                 String languageTag)

Description copied from interface: RDF

Create a language-tagged literal. The provided lexical form should not be escaped in any sense, e.g. should not include "quotes" unless those are part of the literal value. The provided language tag MUST be valid according to BCP47, e.g. en. The provided language tag MAY be converted to lower case. The returned Literal SHOULD have a Literal.getLexicalForm() which is equal to the provided lexicalForm, MUST return a Literal.getDatatype() that is equal to the IRI http://www.w3.org/1999/02/22-rdf-syntax-ns#langString, and MUST have a Literal.getLanguageTag() present which SHOULD be equal to the provided language tag (compared as String.toLowerCase(Locale) using Locale.ENGLISH).

Specified by:

createLiteral in interface RDF

Parameters:

lexicalForm - The literal value

languageTag - The non-empty language tag as defined by BCP47

Returns:

The created Literal

createTriple

public JenaTriple createTriple(BlankNodeOrIRI subject,
                               IRI predicate,
                               RDFTerm object)

Description copied from interface: RDF

Create a triple. The returned Triple SHOULD have a Triple.getSubject() that is equal to the provided subject, a Triple.getPredicate() that is equal to the provided predicate, and a Triple.getObject() that is equal to the provided object.

Specified by:

createTriple in interface RDF

Parameters:

subject - The IRI or BlankNode that is the subject of the triple

predicate - The IRI that is the predicate of the triple

object - The IRI, BlankNode or Literal that is the object of the triple

Returns:

The created Triple

createQuad

public JenaQuad createQuad(BlankNodeOrIRI graphName,
                           BlankNodeOrIRI subject,
                           IRI predicate,
                           RDFTerm object)
                    throws IllegalArgumentException,
                           UnsupportedOperationException

Create a quad.

The returned Quad SHOULD have a Quad.getGraphName() that is equal to the provided graphName, a Quad.getSubject() that is equal to the provided subject, a Quad.getPredicate() that is equal to the provided predicate, and a Quad.getObject() that is equal to the provided object.

In addition to supporting a graphName of null for representing a triple in the default graph, this method also recognize a JenaIRI which JenaRDFTerm.asJenaNode() represent the default graph according to Quad.isDefaultGraph(Node), in which case the returned JenaQuad will have a Quad.getGraphName() of Optional.empty() rather than the provided IRI.

Specified by:

createQuad in interface RDF

Parameters:

graphName - The IRI or BlankNode that this quad belongs to, or null for the public graph

subject - The IRI or BlankNode that is the subject of the quad

predicate - The IRI that is the predicate of the quad

object - The IRI, BlankNode or Literal that is the object of the quad

Returns:

The created Quad

Throws:

IllegalArgumentException - If any of the provided arguments are not acceptable, e.g. because a Literal has a lexicalForm that is too large for an underlying storage.

UnsupportedOperationException

createGeneralizedTriple

public JenaGeneralizedTripleLike createGeneralizedTriple(RDFTerm subject,
                                                         RDFTerm predicate,
                                                         RDFTerm object)

Create a generalized Jena triple.

The generalized triple supports any RDFTerm as its TripleLike.getSubject() TripleLike.getPredicate() or TripleLike.getObject().

Parameters:

subject - The subject of the statement

predicate - The predicate of the statement

object - The object of the statement

Returns:

Generalized TripleLike. Note that the generalized triple does not implement Triple.equals(Object) or Triple.hashCode().

See Also:

createTriple(BlankNodeOrIRI, IRI, RDFTerm), createGeneralizedQuad(RDFTerm, RDFTerm, RDFTerm, RDFTerm)

createGeneralizedQuad

public JenaGeneralizedQuadLike createGeneralizedQuad(RDFTerm subject,
                                                     RDFTerm predicate,
                                                     RDFTerm object,
                                                     RDFTerm graphName)

Create a generalized Jena quad.

The generalized quad supports any RDFTerm as its TripleLike.getSubject() TripleLike.getPredicate(), TripleLike.getObject() or TripleLike.getObject().

In addition to supporting a graphName of null for representing a triple in the default graph, this method also recognize a JenaIRI which JenaRDFTerm.asJenaNode() represent the default graph according to Quad.isDefaultGraph(Node), in which case the returned JenaQuad will have a Quad.getGraphName() of Optional.empty() rather than the provided IRI.

Parameters:

subject - The subject of the statement

predicate - The predicate of the statement

object - The object of the statement

graphName - The graph name of the statement

Returns:

Generalized QuadLike. Note that the generalized quad does not implement Quad.equals(Object) or Quad.hashCode().

See Also:

createQuad(BlankNodeOrIRI, BlankNodeOrIRI, IRI, RDFTerm), createGeneralizedTriple(RDFTerm, RDFTerm, RDFTerm)

asRDFTerm

public JenaRDFTerm asRDFTerm(org.apache.jena.graph.Node node)
                      throws ConversionException

Adapt an existing Jena Node to CommonsRDF RDFTerm.

If Node.isLiteral(), then the returned value is a Literal. If Node.isURI(), the returned value is a IRI. If {$@link Node#isBlank()}, the returned value is a BlankNode, which will use a UUID salt from this JenaRDF instance in combination with Node.getBlankNodeId() for the purpose of its BlankNode.uniqueReference().

Parameters:

node - The Jena Node to adapt. It's Node.isConcrete() must be true.

Returns:

Adapted JenaRDFTerm

Throws:

ConversionException - If the Node can't be represented as an RDFTerm, e.g. if the node is not concrete or represents a variable in Jena.

See Also:

asRDFTerm(RDF, Node)

asRDFTerm

public static RDFTerm asRDFTerm(RDF factory,
                                org.apache.jena.graph.Node node)

Convert from Jena Node to any Commons RDF implementation.

Note that if the Node.isBlank(), then the factory's RDF.createBlankNode(String) will be used, meaning that care should be taken if reusing an RDF instance for multiple conversion sessions.

Parameters:

factory - RDF to use for creating RDFTerm.

node - The Jena Node to adapt. It's Node.isConcrete() must be true.

Returns:

Adapted RDFTerm

Throws:

ConversionException - If the Node can't be represented as an RDFTerm, e.g. if the node is not concrete or represents a variable in Jena.

See Also:

asRDFTerm(Node)

asTriple

public JenaTriple asTriple(org.apache.jena.graph.Triple triple)
                    throws ConversionException

Adapt an existing Jena Triple to CommonsRDF Triple.

If the triple contains any Node.isBlank(), then any corresponding BlankNode will use a UUID salt from this JenaRDF instance in combination with Node.getBlankNodeId() for the purpose of its BlankNode.uniqueReference().

Parameters:

triple - Jena Triple to adapt

Returns:

Adapted JenaTriple

Throws:

ConversionException - if any of the triple's nodes are not concrete or the triple is a generalized triple

See Also:

asTriple(RDF, org.apache.jena.graph.Triple)

asGeneralizedTriple

public JenaTripleLike asGeneralizedTriple(org.apache.jena.graph.Triple triple)
                                   throws ConversionException

Adapt a generalized Jena Triple to a CommonsRDF TripleLike.

The generalized triple supports any RDFTerm as its TripleLike.getSubject() TripleLike.getPredicate() or TripleLike.getObject().

If the Jena triple contains any Node.isBlank(), then any corresponding BlankNode will use a UUID salt from this JenaRDF instance in combination with Node.getBlankNodeId() for the purpose of its BlankNode.uniqueReference().

Parameters:

triple - Jena triple

Returns:

Adapted TripleLike. Note that the generalized triple does not implement Triple.equals(Object) or Triple.hashCode().

Throws:

ConversionException - if any of the triple's nodes are not concrete

See Also:

asTriple(RDF, org.apache.jena.graph.Triple)

asGeneralizedQuad

public JenaQuadLike<RDFTerm> asGeneralizedQuad(org.apache.jena.sparql.core.Quad quad)
                                        throws ConversionException

Adapt a generalized Jena Quad to a CommonsRDF QuadLike.

The generalized quad supports any RDFTerm as its QuadLike.getGraphName(), TripleLike.getSubject() TripleLike.getPredicate() or TripleLike.getObject().

If the Jena quad contains any Node.isBlank(), then any corresponding BlankNode will use a UUID salt from this JenaRDF instance in combination with Node.getBlankNodeId() for the purpose of its BlankNode.uniqueReference().

If the provided quad Quad.isDefaultGraph(), the returned JenaQuadLike has a QuadLike.getGraphName() of Optional.empty().

Parameters:

quad - Jena quad

Returns:

Adapted QuadLike. Note that the generalized quad does not implement Quad.equals(Object) or Quad.hashCode().

Throws:

ConversionException - if any of the quad nodes are not concrete

See Also:

asQuad(org.apache.jena.sparql.core.Quad), asGeneralizedTriple(org.apache.jena.graph.Triple)

asTriple

public static Triple asTriple(RDF factory,
                              org.apache.jena.graph.Triple triple)
                       throws ConversionException

Convert from Jena Triple to a Commons RDF Triple.

Note that if any of the triple's nodes Node.isBlank(), then the factory's RDF.createBlankNode(String) will be used, meaning that care should be taken if reusing an RDF instance for multiple conversion sessions.

Parameters:

factory - RDF to use for creating the Triple and its RDFTerms.

triple - Jena triple

Returns:

Converted triple

Throws:

ConversionException - if any of the triple's nodes are not concrete or the triple is a generalized triple

See Also:

asTriple(org.apache.jena.graph.Triple)

asQuad

public JenaQuad asQuad(org.apache.jena.sparql.core.Quad quad)

Adapt an existing Jena Quad to CommonsRDF Quad.

If the quad contains any Node.isBlank(), then any corresponding BlankNode will use a UUID salt from this JenaRDF instance in combination with Node.getBlankNodeId() for the purpose of its BlankNode.uniqueReference().

If the provided quad Quad.isDefaultGraph(), the returned JenaQuad has a Quad.getGraphName() of Optional.empty().

Parameters:

quad - Jena quad

Returns:

Adapted quad

asGraph

public JenaGraph asGraph(org.apache.jena.graph.Graph graph)

Adapt an existing Jena Graph to CommonsRDF Graph.

This does not take a copy, changes to the CommonsRDF Graph are reflected in the jena graph, which is accessible from JenaGraph.asJenaGraph().

If the graph contains any Node.isBlank(), then any corresponding BlankNode will use a UUID salt from this JenaRDF instance in combination with Node.getBlankNodeId() for the purpose of its BlankNode.uniqueReference().

Parameters:

graph - Jena Graph to adapt

Returns:

Adapted JenaGraph

asGraph

public JenaGraph asGraph(org.apache.jena.rdf.model.Model model)

Adapt an existing Jena Model to CommonsRDF Graph.

This does not ake a copy, changes to the CommonsRDF Graph are reflected in the jena graph, which is accessible from JenaGraph.asJenaGraph().

If the graph contains any Node.isBlank(), then any corresponding BlankNode will use a UUID salt from this JenaRDF instance in combination with Node.getBlankNodeId() for the purpose of its BlankNode.uniqueReference().

Parameters:

model - Jena Model to adapt

Returns:

Adapted JenaGraph

asDataset

public JenaDataset asDataset(org.apache.jena.sparql.core.DatasetGraph datasetGraph)

Adapt an existing Jena DatasetGraph to CommonsRDF Dataset.

This does not take a copy, changes to the CommonsRDF Dataset are reflected in the jena dataset graph, which is accessible from JenaDataset.asJenaDatasetGraph().

If the dataset contains any Node.isBlank(), then any corresponding BlankNode will use a UUID salt from this JenaRDF instance in combination with Node.getBlankNodeId() for the purpose of its BlankNode.uniqueReference().

Parameters:

datasetGraph - Jena DatasetGraph to adapt

Returns:

Adapted JenaDataset

asDataset

public JenaDataset asDataset(org.apache.jena.query.Dataset datasetGraph)

Adapt an existing Jena Dataset to CommonsRDF Dataset.

This does not take a copy, changes to the CommonsRDF Dataset are reflected in the jena dataset graph, which is accessible from JenaDataset.asJenaDatasetGraph().

If the dataset contains any Node.isBlank(), then any corresponding BlankNode will use a UUID salt from this JenaRDF instance in combination with Node.getBlankNodeId() for the purpose of its BlankNode.uniqueReference().

Parameters:

datasetGraph - Jena Dataset to adapt

Returns:

Adapted JenaDataset

asQuad

public static Quad asQuad(RDF factory,
                          org.apache.jena.sparql.core.Quad quad)

Convert from Jena Quad to a Commons RDF Quad.

Note that if any of the quad's nodes Node.isBlank(), then the factory's RDF.createBlankNode(String) will be used, meaning that care should be taken if reusing an RDF instance for multiple conversion sessions.

If the provided quad Quad.isDefaultGraph(), the returned JenaQuadLike has a QuadLike.getGraphName() of Optional.empty().

Parameters:

factory - RDF to use for creating the Triple and its RDFTerms.

quad - Jena Quad to adapt

Returns:

Converted Quad

Throws:

ConversionException - if any of the quad's nodes are not concrete or the quad is a generalized quad

See Also:

asQuad(org.apache.jena.sparql.core.Quad), asGeneralizedQuad(org.apache.jena.sparql.core.Quad)

asRDFSyntax

public Optional<RDFSyntax> asRDFSyntax(org.apache.jena.riot.Lang lang)

Return RDFSyntax corresponding to a Jena Lang.

Parameters:

lang - Lang to convert

Returns:

Matched RDFSyntax, otherwise Optional.empty()

asJenaLang

public Optional<org.apache.jena.riot.Lang> asJenaLang(RDFSyntax rdfSyntax)

Return Jena Lang corresponding to a RDFSyntax.

Parameters:

rdfSyntax - RDFSyntax to convert

Returns:

Matched Lang, otherwise Optional.empty()

streamJenaToQuad

public static org.apache.jena.riot.system.StreamRDF streamJenaToQuad(RDF factory,
                                                                     Consumer<Quad> consumer)

Create a StreamRDF instance that inserts the converted Quads. into a the provided Consumer.

The returned StreamRDF can be used for instance with Jena's RDFDataMgr.parse(StreamRDF, String).

Parameters:

factory - RDF to use for creating RDFTerms and Quads.

consumer - A Consumer of Quads

Returns:

A StreamRDF that will stream converted quads to the consumer

streamJenaToGeneralizedTriple

public org.apache.jena.riot.system.StreamRDF streamJenaToGeneralizedTriple(Consumer<TripleLike> generalizedConsumer)

Create a StreamRDF instance that inserts generalized TripleLikes. into a the provided Consumer.

A generalized triple allows any RDFTerm for TripleLike.getSubject(), TripleLike.getPredicate() and TripleLike.getObject().

The returned StreamRDF can be used for instance with Jena's RDFDataMgr.parse(StreamRDF, String).

Parameters:

generalizedConsumer - A Consumer of generalized TripleLikes

Returns:

A StreamRDF that will stream generalized triples to the consumer

streamJenaToGeneralizedQuad

public org.apache.jena.riot.system.StreamRDF streamJenaToGeneralizedQuad(Consumer<QuadLike<RDFTerm>> generalizedConsumer)

Create a StreamRDF instance that inserts generalized QuadLikes. into a the provided Consumer.

A generalized quad allows any RDFTerm for TripleLike.getSubject(), TripleLike.getPredicate(), TripleLike.getObject() and QuadLike.getGraphName() .

The returned StreamRDF can be used for instance with Jena's RDFDataMgr.parse(StreamRDF, String).

Parameters:

generalizedConsumer - A Consumer of generalized QuadLikes

Returns:

A StreamRDF that will stream generalized quads to the consumer

asJenaDataset

public org.apache.jena.query.Dataset asJenaDataset(Dataset dataset)

Convert a CommonsRDF Dataset to a Jena Dataset. If the Dataset was from Jena originally, return that original object wrapped else create a copy using Jena objects.

Parameters:

dataset - Commons RDF Dataset to convert

Returns:

Converted Jena Dataset

asJenaDatasetGraph

public org.apache.jena.sparql.core.DatasetGraph asJenaDatasetGraph(Dataset dataset)

Convert a CommonsRDF Dataset to a Jena DatasetGraph. If the Dataset was from Jena originally, return that original object's underlying DatasetGraph else create a copy using Jena objects.

Parameters:

dataset - Commons RDF Dataset to convert

Returns:

Converted Jena DatasetGraph

asJenaGraph

public org.apache.jena.graph.Graph asJenaGraph(Graph graph)

Convert a CommonsRDF Graph to a Jena Graph. If the Graph was from Jena originally, return that original object else create a copy using Jena objects.

Parameters:

graph - Commons RDF Graph to convert

Returns:

Converted Jena Graph

asJenaNode

public org.apache.jena.graph.Node asJenaNode(RDFTerm term)

Convert a CommonsRDF RDFTerm to a Jena Node. If the RDFTerm was from Jena originally, return that original object, else create a copy using Jena objects.

Parameters:

term - Commons RDF RDFTerm to convert

Returns:

Converted Jena Node

asJenaTriple

public org.apache.jena.graph.Triple asJenaTriple(Triple triple)

Convert a CommonsRDF Triple to a Jena Triple.

If the triple was from Jena originally, return that original object, else create a copy using Jena objects.

Parameters:

triple - Commons RDF Triple to convert

Returns:

Converted Jena Triple

asJenaQuad

public org.apache.jena.sparql.core.Quad asJenaQuad(Quad quad)

Convert a CommonsRDF Quad to a Jena Quad.

If the quad was from Jena originally, return that original object, otherwise create a copy using Jena objects.

Parameters:

quad - Commons RDF Quad to convert

Returns:

Converted Jena Quad

salt

public UUID salt()

Return the UUID salt used by this factory.

The salt is used for the purposes of BlankNode identity, see BlankNode.uniqueReference() for details.

This salt can be used with the constructor JenaRDF(UUID) if consistent or reproducible BlankNodes are desirable.

Returns:

The UUID used as salt