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(Dataset datasetGraph) Adapt an existing Jena Dataset to CommonsRDF Dataset.
JenaDataset	asDataset(DatasetGraph datasetGraph) Adapt an existing Jena DatasetGraph to CommonsRDF Dataset.
JenaQuadLike<RDFTerm>	asGeneralizedQuad(Quad quad) Adapt a generalized Jena Quad to a CommonsRDF QuadLike.
JenaTripleLike	asGeneralizedTriple(Triple triple) Adapt a generalized Jena Triple to a CommonsRDF TripleLike.
JenaGraph	asGraph(Graph graph) Adapt an existing Jena Graph to CommonsRDF Graph.
JenaGraph	asGraph(Model model) Adapt an existing Jena Model to CommonsRDF Graph.
Graph	asJenaGraph(Graph graph) Convert a CommonsRDF Graph to a Jena Graph.
Optional<Lang>	asJenaLang(RDFSyntax rdfSyntax) Return Jena Lang corresponding to a RDFSyntax.
Node	asJenaNode(RDFTerm term) Convert a CommonsRDF RDFTerm to a Jena Node.
Quad	asJenaQuad(Quad quad) Convert a CommonsRDF Quad to a Jena Quad.
Triple	asJenaTriple(Triple triple) Convert a CommonsRDF Triple to a Jena Triple.
JenaQuad	asQuad(Quad quad) Adapt an existing Jena Quad to CommonsRDF Quad.
static Quad	asQuad(RDF factory, Quad quad) Convert from Jena Quad to a Commons RDF Quad.
Optional<RDFSyntax>	asRDFSyntax(Lang lang) Return RDFSyntax corresponding to a Jena Lang.
JenaRDFTerm	asRDFTerm(Node node) Adapt an existing Jena Node to CommonsRDF RDFTerm.
static RDFTerm	asRDFTerm(RDF factory, Node node) Convert from Jena Node to any Commons RDF implementation.
static Triple	asTriple(RDF factory, Triple triple) Convert from Jena Triple to a Commons RDF Triple.
JenaTriple	asTriple(Triple triple) Adapt an existing Jena Triple to CommonsRDF Triple.
JenaBlankNode	createBlankNode()
JenaBlankNode	createBlankNode(String name)
JenaDataset	createDataset()
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()
JenaIRI	createIRI(String iri)
JenaLiteral	createLiteral(String lexicalForm)
JenaLiteral	createLiteral(String lexicalForm, IRI dataType)
JenaLiteral	createLiteral(String lexicalForm, String languageTag)
JenaQuad	createQuad(BlankNodeOrIRI graphName, BlankNodeOrIRI subject, IRI predicate, RDFTerm object)
JenaTriple	createTriple(BlankNodeOrIRI subject, IRI predicate, RDFTerm object)
UUID	salt() Return the UUID salt used by this factory.
StreamRDF	streamJenaToGeneralizedQuad(Consumer<QuadLike<RDFTerm>> generalizedConsumer) Create a StreamRDF instance that inserts generalized QuadLikes.
StreamRDF	streamJenaToGeneralizedTriple(Consumer<TripleLike> generalizedConsumer) Create a StreamRDF instance that inserts generalized TripleLikes.
static 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()

Specified by:

createBlankNode in interface RDF

createBlankNode

public JenaBlankNode createBlankNode(String name)

Specified by:

createBlankNode in interface RDF

createDataset

public JenaDataset createDataset()

Specified by:

createDataset in interface RDF

createGraph

public JenaGraph createGraph()

Specified by:

createGraph in interface RDF

createIRI

public JenaIRI createIRI(String iri)

Specified by:

createIRI in interface RDF

createLiteral

public JenaLiteral createLiteral(String lexicalForm)

Specified by:

createLiteral in interface RDF

createLiteral

public JenaLiteral createLiteral(String lexicalForm,
                                 IRI dataType)

Specified by:

createLiteral in interface RDF

createLiteral

public JenaLiteral createLiteral(String lexicalForm,
                                 String languageTag)

Specified by:

createLiteral in interface RDF

createTriple

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

Specified by:

createTriple in interface RDF

createQuad

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

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

Throws:

IllegalArgumentException

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(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,
                                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(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(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(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,
                              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(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(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(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(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(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,
                          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(Lang lang)

Return RDFSyntax corresponding to a Jena Lang.

Parameters:

lang - Lang to convert

Returns:

Matched RDFSyntax, otherwise Optional.empty()

asJenaLang

public Optional<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 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 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 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

asJenaGraph

public 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 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 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 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