You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@commonsrdf.apache.org by st...@apache.org on 2016/10/28 13:08:19 UTC
[41/50] [abbrv] incubator-commonsrdf git commit: Reformat tab ->
spaces
http://git-wip-us.apache.org/repos/asf/incubator-commonsrdf/blob/413dd09a/rdf4j/src/main/java/org/apache/commons/rdf/rdf4j/RDF4J.java
----------------------------------------------------------------------
diff --git a/rdf4j/src/main/java/org/apache/commons/rdf/rdf4j/RDF4J.java b/rdf4j/src/main/java/org/apache/commons/rdf/rdf4j/RDF4J.java
index 7f70c75..8df26e0 100644
--- a/rdf4j/src/main/java/org/apache/commons/rdf/rdf4j/RDF4J.java
+++ b/rdf4j/src/main/java/org/apache/commons/rdf/rdf4j/RDF4J.java
@@ -53,9 +53,9 @@ import org.eclipse.rdf4j.sail.memory.MemoryStore;
/**
* RDF4J implementation of RDF.
* <p>
- * The {@link #RDF4J()} constructor uses a {@link SimpleValueFactory}
- * to create corresponding RDF4J {@link Value} instances. Alternatively, this
- * factory can be constructed with a different {@link ValueFactory} using
+ * The {@link #RDF4J()} constructor uses a {@link SimpleValueFactory} to create
+ * corresponding RDF4J {@link Value} instances. Alternatively, this factory can
+ * be constructed with a different {@link ValueFactory} using
* {@link #RDF4J(ValueFactory)}.
* <p>
* {@link #asRDFTerm(Value)} can be used to convert any RDF4J {@link Value} to
@@ -67,8 +67,7 @@ import org.eclipse.rdf4j.sail.memory.MemoryStore;
* To use other models, see {@link #asGraph(Model)}.
* <p>
* To adapt a RDF4J {@link Repository} as a {@link Dataset} or {@link Graph},
- * use {@link #asDataset(Repository, Option...)}
- * or
+ * use {@link #asDataset(Repository, Option...)} or
* {@link #asGraph(Repository, Option...)}.
* <p>
* {@link #asTriple(Statement)} can be used to convert a RDF4J {@link Statement}
@@ -93,511 +92,495 @@ import org.eclipse.rdf4j.sail.memory.MemoryStore;
* the same {@link BNode#getID()}, converting them with the above methods might
* cause accidental {@link BlankNode} equivalence. Note that the {@link Graph}
* and {@link Dataset} adapter methods like
- * {@link #asDataset(Repository, Option...)}
- * and
- * {@link #asGraph(Repository, Option...)}
- * therefore uses a unique {@link RDF4J} internally.
+ * {@link #asDataset(Repository, Option...)} and
+ * {@link #asGraph(Repository, Option...)} therefore uses a unique {@link RDF4J}
+ * internally.
*
* @see RDF
*
*/
public final class RDF4J implements RDF {
- /**
- * InternalRDF4JFactory is deliberately abstract
- */
- private static InternalRDF4JFactory rdf4j = new InternalRDF4JFactory() {
- };
-
- public enum Option {
- /**
- * The Graph/Dataset should include any inferred statements
- */
- includeInferred,
- /**
- * The graph/dataset should handle {@link Repository#initialize()} (if
- * needed) and {@link Repository#shutDown()} on {@link Graph#close()} /
- * {@link Dataset#close()}.
- */
- handleInitAndShutdown
- }
-
- private final UUID salt;
-
- private final ValueFactory valueFactory;
-
- /**
- * Construct an {@link RDF4J}.
- *
- */
- public RDF4J() {
- this(SimpleValueFactory.getInstance(), UUID.randomUUID());
- }
-
- /**
- * Construct an {@link RDF4J}.
- * <p>
- * This constructor is intended for use with the value factory from
- * {@link Repository#getValueFactory()} when using
- * Repository-based graphs and datasets.
- *
- * @param valueFactory
- * The RDF4J {@link ValueFactory} to use
- */
- public RDF4J(ValueFactory valueFactory) {
- this(valueFactory, UUID.randomUUID());
- }
-
- /**
- * Construct an {@link RDF4J}.
- * <p>
- * This constructor may be used if reproducible
- * {@link BlankNode#uniqueReference()} in {@link BlankNode} is desirable.
- *
- * @param salt
- * An {@link UUID} salt to be used by any created
- * {@link BlankNode}s for the purpose of
- * {@link BlankNode#uniqueReference()}
- */
- public RDF4J(UUID salt) {
- this(SimpleValueFactory.getInstance(), salt);
- }
- /**
- * Construct an {@link RDF4J}.
- * <p>
- * This constructor may be used if reproducible
- * {@link BlankNode#uniqueReference()} in {@link BlankNode} is desirable.
- *
- * @param valueFactory
- * The RDF4J {@link ValueFactory} to use
- * @param salt
- * An {@link UUID} salt to be used by any created
- * {@link BlankNode}s for the purpose of
- * {@link BlankNode#uniqueReference()}
- */
- public RDF4J(ValueFactory valueFactory, UUID salt) {
- this.valueFactory = valueFactory;
- this.salt = salt;
- }
-
- /**
- * Adapt a RDF4J {@link Statement} as a Commons RDF {@link Quad}.
- * <p>
- * For the purpose of {@link BlankNode} equivalence, this method will use an
- * internal salt UUID that is unique per instance of
- * {@link RDF4J}.
- * <p>
- * <strong>NOTE:</strong> If combining RDF4J {@link Statement}s multiple
- * repositories or models, then their {@link BNode}s may have the same
- * {@link BNode#getID()}, which with this method would become equivalent
- * according to {@link BlankNode#equals(Object)} and
- * {@link BlankNode#uniqueReference()}, unless a separate
- * {@link RDF4J} instance is used per RDF4J repository/model.
- *
- * @param statement
- * The statement to convert
- * @return A {@link RDF4JQuad} that is equivalent to the statement
- */
- public RDF4JQuad asQuad(final Statement statement) {
- return rdf4j.createQuadImpl(statement, salt);
- }
-
- /**
- *
- * Adapt a RDF4J {@link Value} as a Commons RDF {@link RDFTerm}.
- * <p>
- * The value will be of the same kind as the term, e.g. a
- * {@link org.eclipse.rdf4j.model.BNode} is converted to a
- * {@link org.apache.commons.rdf.api.BlankNode}, a
- * {@link org.eclipse.rdf4j.model.IRI} is converted to a
- * {@link org.apache.commons.rdf.api.IRI} and a
- * {@link org.eclipse.rdf4j.model.Literal}. is converted to a
- * {@link org.apache.commons.rdf.api.Literal}
- * <p>
- * For the purpose of {@link BlankNode} equivalence, this method will use an
- * internal salt UUID that is unique per instance of
- * {@link RDF4J}.
- * <p>
- * <strong>NOTE:</strong> If combining RDF4J values from multiple
- * repositories or models, then their {@link BNode}s may have the same
- * {@link BNode#getID()}, which with this method would become equivalent
- * according to {@link BlankNode#equals(Object)} and
- * {@link BlankNode#uniqueReference()}, unless a separate
- * {@link RDF4J} instance is used per RDF4J repository/model.
- *
- * @param value
- * The RDF4J {@link Value} to convert.
- * @return A {@link RDFTerm} that corresponds to the RDF4J value
- * @throws IllegalArgumentException
- * if the value is not a BNode, Literal or IRI
- */
- public RDF4JTerm asRDFTerm(Value value) {
- return asRDFTerm(value, salt);
- }
-
- /**
- * Adapt a RDF4J {@link Value} as a Commons RDF {@link RDFTerm}.
- * <p>
- * The value will be of the same kind as the term, e.g. a
- * {@link org.eclipse.rdf4j.model.BNode} is converted to a
- * {@link org.apache.commons.rdf.api.BlankNode}, a
- * {@link org.eclipse.rdf4j.model.IRI} is converted to a
- * {@link org.apache.commons.rdf.api.IRI} and a
- * {@link org.eclipse.rdf4j.model.Literal}. is converted to a
- * {@link org.apache.commons.rdf.api.Literal}
- *
- * @param value
- * The RDF4J {@link Value} to convert.
- * @param salt
- * A {@link UUID} salt to use for uniquely mapping any
- * {@link BNode}s. The salt should typically be the same for
- * multiple statements in the same {@link Repository} or
- * {@link Model} to ensure {@link BlankNode#equals(Object)} and
- * {@link BlankNode#uniqueReference()} works as intended.
- * @return A {@link RDFTerm} that corresponds to the RDF4J value
- * @throws IllegalArgumentException
- * if the value is not a BNode, Literal or IRI
- */
- public static RDF4JTerm asRDFTerm(final Value value, UUID salt) {
- if (value instanceof BNode) {
- return rdf4j.createBlankNodeImpl((BNode) value, salt);
- }
- if (value instanceof org.eclipse.rdf4j.model.Literal) {
- return rdf4j.createLiteralImpl((org.eclipse.rdf4j.model.Literal) value);
- }
- if (value instanceof org.eclipse.rdf4j.model.IRI) {
- return rdf4j.createIRIImpl((org.eclipse.rdf4j.model.IRI) value);
- }
- throw new IllegalArgumentException("Value is not a BNode, Literal or IRI: " + value.getClass());
- }
-
- /**
- * Adapt an RDF4J {@link Repository} as a Commons RDF {@link Dataset}.
- * <p>
- * Changes to the dataset are reflected in the repository, and vice versa.
- * <p>
- * <strong>Note:</strong> Some operations on the {@link RDF4JDataset}
- * requires the use of try-with-resources to close underlying
- * {@link RepositoryConnection}s, including
- * {@link RDF4JDataset#iterate()},
- * {@link RDF4JDataset#stream()} and {@link RDF4JDataset#getGraphNames()}.
- *
- * @param repository
- * RDF4J {@link Repository} to connect to.
- * @param options
- * Zero or more {@link Option}
- * @return A {@link Dataset} backed by the RDF4J repository.
- */
- public RDF4JDataset asDataset(Repository repository, Option... options) {
- EnumSet<Option> opts = optionSet(options);
- return rdf4j.createRepositoryDatasetImpl(repository,
- opts.contains(Option.handleInitAndShutdown),
- opts.contains(Option.includeInferred));
- }
-
- /**
- * Adapt an RDF4J {@link Model} as a Commons RDF {@link Graph}.
- * <p>
- * Changes to the graph are reflected in the model, and vice versa.
- *
- * @param model
- * RDF4J {@link Model} to adapt.
- * @return Adapted {@link Graph}.
- */
- public RDF4JGraph asGraph(Model model) {
- return rdf4j.createModelGraphImpl(model, this);
- }
-
- /**
- * Adapt an RDF4J {@link Repository} as a Commons RDF {@link Graph}.
- * <p>
- * The graph will only include triples in the default graph (equivalent to
- * context <code>new Resource[0]{null})</code> in RDF4J).
- * <p>
- * Changes to the graph are reflected in the repository, and vice versa.
- * <p>
- * <strong>Note:</strong> Some operations on the {@link RDF4JGraph}
- * requires the use of try-with-resources to close underlying
- * {@link RepositoryConnection}s, including
- * {@link RDF4JGraph#iterate()} and
- * {@link RDF4JGraph#stream()}.
- *
- * @param repository
- * RDF4J {@link Repository} to connect to.
- * @param options
- * Zero or more {@link Option}
- * @return A {@link Graph} backed by the RDF4J repository.
- */
- public RDF4JGraph asGraph(Repository repository, Option... options) {
- EnumSet<Option> opts = optionSet(options);
- return rdf4j.createRepositoryGraphImpl(repository,
- opts.contains(Option.handleInitAndShutdown),
- opts.contains(Option.includeInferred),
- new Resource[]{null}); // default graph
- }
-
- /**
- * Adapt an RDF4J {@link Repository} as a Commons RDF {@link Graph}.
- * <p>
- * The graph will include triples in any contexts (e.g. the union graph).
- * <p>
- * Changes to the graph are reflected in the repository, and vice versa.
- *
- * @param repository
- * RDF4J {@link Repository} to connect to.
- * @param options
- * Zero or more {@link Option}
- * @return A union {@link Graph} backed by the RDF4J repository.
- */
- public RDF4JGraph asGraphUnion(Repository repository, Option... options) {
- EnumSet<Option> opts = optionSet(options);
- return rdf4j.createRepositoryGraphImpl(repository,
- opts.contains(Option.handleInitAndShutdown),
- opts.contains(Option.includeInferred),
- new Resource[]{}); // union graph
-
- }
-
- /**
- * Adapt an RDF4J {@link Repository} as a Commons RDF {@link Graph}.
- * <p>
- * The graph will include triples in the specified contexts.
- * <p>
- * Changes to the graph are reflected in the repository, and vice versa.
- * Triples added/removed to the graph are reflected in all the specified
- * contexts.
- * <p>
- * <strong>Note:</strong> Some operations on the {@link RDF4JGraph}
- * requires the use of try-with-resources to close underlying
- * {@link RepositoryConnection}s, including
- * {@link RDF4JGraph#iterate()} and
- * {@link RDF4JGraph#stream()}.
- *
- * @param repository
- * RDF4J {@link Repository} to connect to.
- * @param contexts
- * A {@link Set} of {@link BlankNodeOrIRI} specifying the graph
- * names to use as a context. The set may include the value
- * <code>null</code> to indicate the default graph. The empty set
- * indicates any context, e.g. the <em>union graph</em>.
- * @param option
- * Zero or more {@link Option}s
- * @return A {@link Graph} backed by the RDF4J repository.
- */
- public RDF4JGraph asGraph(Repository repository, Set<? extends BlankNodeOrIRI> contexts,
- Option... option) {
- EnumSet<Option> opts = optionSet(option);
- /** NOTE: asValue() deliberately CAN handle <code>null</code> */
- Resource[] resources = contexts.stream().map(g -> (Resource) asValue(g)).toArray(Resource[]::new);
- return rdf4j.createRepositoryGraphImpl(Objects.requireNonNull(repository),
- opts.contains(Option.handleInitAndShutdown),
- opts.contains(Option.includeInferred),
- resources);
- }
-
- /**
- * Adapt a Commons RDF {@link Triple} or {@link Quad} as a RDF4J
- * {@link Statement}.
- * <p>
- * If the <code>tripleLike</code> argument is an {@link RDF4JTriple} or a
- * {@link RDF4JQuad}, then its {@link RDF4JTripleLike#asStatement()} is
- * returned as-is. Note that this means that a {@link RDF4JTriple} would
- * preserve its {@link Statement#getContext()}, and that any
- * {@link BlankNode}s would be deemed equivalent in RDF4J if they have the
- * same {@link BNode#getID()}.
- *
- * @param tripleLike
- * A {@link Triple} or {@link Quad} to adapt
- * @return A corresponding {@link Statement}
- */
- public Statement asStatement(TripleLike tripleLike) {
- if (tripleLike instanceof RDF4JTripleLike) {
- // Return original statement - this covers both RDF4JQuad and
- // RDF4JTriple
- return ((RDF4JTripleLike) tripleLike).asStatement();
- }
-
- org.eclipse.rdf4j.model.Resource subject = (org.eclipse.rdf4j.model.Resource) asValue(tripleLike.getSubject());
- org.eclipse.rdf4j.model.IRI predicate = (org.eclipse.rdf4j.model.IRI) asValue(tripleLike.getPredicate());
- Value object = asValue(tripleLike.getObject());
-
- org.eclipse.rdf4j.model.Resource context = null;
- if (tripleLike instanceof Quad) {
- Quad quad = (Quad) tripleLike;
- context = (org.eclipse.rdf4j.model.Resource) asValue(quad.getGraphName().orElse(null));
- }
-
- return getValueFactory().createStatement(subject, predicate, object, context);
- }
-
- /**
- * Adapt a RDF4J {@link Statement} as a Commons RDF {@link Triple}.
- * <p>
- * For the purpose of {@link BlankNode} equivalence, this method will use an
- * internal salt UUID that is unique per instance of
- * {@link RDF4J}.
- * <p>
- * <strong>NOTE:</strong> If combining RDF4J statements from multiple
- * repositories or models, then their {@link BNode}s may have the same
- * {@link BNode#getID()}, which with this method would become equivalent
- * according to {@link BlankNode#equals(Object)} and
- * {@link BlankNode#uniqueReference()}, unless a separate
- * {@link RDF4J} instance is used per RDF4J repository/model.
- *
- * @param statement
- * The RDF4J {@link Statement} to adapt.
- * @return A {@link RDF4JTriple} that is equivalent to the statement
- */
- public RDF4JTriple asTriple(final Statement statement) {
- return rdf4j.createTripleImpl(statement, salt);
- }
-
- /**
- * Adapt a Commons RDF {@link RDFTerm} as a RDF4J {@link Value}.
- * <p>
- * The value will be of the same kind as the term, e.g. a
- * {@link org.apache.commons.rdf.api.BlankNode} is converted to a
- * {@link org.eclipse.rdf4j.model.BNode}, a
- * {@link org.apache.commons.rdf.api.IRI} is converted to a
- * {@link org.eclipse.rdf4j.model.IRI} and a
- * {@link org.apache.commons.rdf.api.Literal} is converted to a
- * {@link org.eclipse.rdf4j.model.Literal}.
- * <p>
- * If the provided {@link RDFTerm} is <code>null</code>, then the returned
- * value is <code>null</code>.
- * <p>
- * If the provided term is an instance of {@link RDF4JTerm}, then the
- * {@link RDF4JTerm#asValue()} is returned without any conversion. Note that
- * this could mean that a {@link Value} from a different kind of
- * {@link ValueFactory} could be returned.
- *
- * @param term
- * RDFTerm to adapt to RDF4J Value
- * @return Adapted RDF4J {@link Value}
- */
- public Value asValue(RDFTerm term) {
- if (term == null) {
- return null;
- }
- if (term instanceof RDF4JTerm) {
- // One of our own - avoid converting again.
- // (This is crucial to avoid double-escaping in BlankNode)
- return ((RDF4JTerm) term).asValue();
- }
- if (term instanceof org.apache.commons.rdf.api.IRI) {
- org.apache.commons.rdf.api.IRI iri = (org.apache.commons.rdf.api.IRI) term;
- return getValueFactory().createIRI(iri.getIRIString());
- }
- if (term instanceof org.apache.commons.rdf.api.Literal) {
- org.apache.commons.rdf.api.Literal literal = (org.apache.commons.rdf.api.Literal) term;
- String label = literal.getLexicalForm();
- if (literal.getLanguageTag().isPresent()) {
- String lang = literal.getLanguageTag().get();
- return getValueFactory().createLiteral(label, lang);
- }
- org.eclipse.rdf4j.model.IRI dataType = (org.eclipse.rdf4j.model.IRI) asValue(literal.getDatatype());
- return getValueFactory().createLiteral(label, dataType);
- }
- if (term instanceof BlankNode) {
- // This is where it gets tricky to support round trips!
- BlankNode blankNode = (BlankNode) term;
- // FIXME: The uniqueReference might not be a valid BlankNode
- // identifier..
- // does it have to be in RDF4J?
- return getValueFactory().createBNode(blankNode.uniqueReference());
- }
- throw new IllegalArgumentException("RDFTerm was not an IRI, Literal or BlankNode: " + term.getClass());
- }
-
- @Override
- public RDF4JBlankNode createBlankNode() {
- BNode bnode = getValueFactory().createBNode();
- return (RDF4JBlankNode) asRDFTerm(bnode);
- }
-
- @Override
- public RDF4JBlankNode createBlankNode(String name) {
- BNode bnode = getValueFactory().createBNode(name);
- return (RDF4JBlankNode) asRDFTerm(bnode);
- }
-
- /**
- * {@inheritDoc}
- * <p>
- * <strong>Note:</strong> Some operations on the {@link RDF4JDataset}
- * requires the use of try-with-resources to close underlying
- * {@link RepositoryConnection}s, including
- * {@link RDF4JDataset#iterate()},
- * {@link RDF4JDataset#stream()} and {@link RDF4JDataset#getGraphNames()}.
- *
- */
- @Override
- public RDF4JDataset createDataset() {
- Sail sail = new MemoryStore();
- Repository repository = new SailRepository(sail);
- return rdf4j.createRepositoryDatasetImpl(repository, true, false);
- }
-
- @Override
- public RDF4JGraph createGraph() {
- return asGraph(new LinkedHashModel());
- }
-
- @Override
- public RDF4JIRI createIRI(String iri) throws IllegalArgumentException {
- return (RDF4JIRI) asRDFTerm(getValueFactory().createIRI(iri));
- }
-
- @Override
- public RDF4JLiteral createLiteral(String lexicalForm)
- throws IllegalArgumentException {
- org.eclipse.rdf4j.model.Literal lit = getValueFactory().createLiteral(lexicalForm);
- return (RDF4JLiteral) asRDFTerm(lit);
- }
-
- @Override
- public org.apache.commons.rdf.api.Literal createLiteral(String lexicalForm, org.apache.commons.rdf.api.IRI dataType)
- throws IllegalArgumentException {
- org.eclipse.rdf4j.model.IRI iri = getValueFactory().createIRI(dataType.getIRIString());
- org.eclipse.rdf4j.model.Literal lit = getValueFactory().createLiteral(lexicalForm, iri);
- return (org.apache.commons.rdf.api.Literal) asRDFTerm(lit);
- }
-
- @Override
- public org.apache.commons.rdf.api.Literal createLiteral(String lexicalForm, String languageTag)
- throws IllegalArgumentException {
- org.eclipse.rdf4j.model.Literal lit = getValueFactory().createLiteral(lexicalForm, languageTag);
- return (org.apache.commons.rdf.api.Literal) asRDFTerm(lit);
- }
-
- @Override
- public RDF4JTriple createTriple(BlankNodeOrIRI subject, org.apache.commons.rdf.api.IRI predicate, RDFTerm object)
- throws IllegalArgumentException {
- final Statement statement = getValueFactory().createStatement(
- (org.eclipse.rdf4j.model.Resource) asValue(subject), (org.eclipse.rdf4j.model.IRI) asValue(predicate),
- asValue(object));
- return asTriple(statement);
- }
-
- @Override
- public Quad createQuad(BlankNodeOrIRI graphName, BlankNodeOrIRI subject, org.apache.commons.rdf.api.IRI predicate,
- RDFTerm object) throws IllegalArgumentException {
- final Statement statement = getValueFactory().createStatement(
- (org.eclipse.rdf4j.model.Resource) asValue(subject), (org.eclipse.rdf4j.model.IRI) asValue(predicate),
- asValue(object), (org.eclipse.rdf4j.model.Resource) asValue(graphName));
- return asQuad(statement);
- }
-
- public ValueFactory getValueFactory() {
- return valueFactory;
- }
-
- private EnumSet<Option> optionSet(Option... options) {
- EnumSet<Option> opts = EnumSet.noneOf(Option.class);
- opts.addAll(Arrays.asList(options));
- return opts;
- }
-
-
-
+ /**
+ * InternalRDF4JFactory is deliberately abstract
+ */
+ private static InternalRDF4JFactory rdf4j = new InternalRDF4JFactory() {
+ };
+
+ public enum Option {
+ /**
+ * The Graph/Dataset should include any inferred statements
+ */
+ includeInferred,
+ /**
+ * The graph/dataset should handle {@link Repository#initialize()} (if
+ * needed) and {@link Repository#shutDown()} on {@link Graph#close()} /
+ * {@link Dataset#close()}.
+ */
+ handleInitAndShutdown
+ }
+
+ private final UUID salt;
+
+ private final ValueFactory valueFactory;
+
+ /**
+ * Construct an {@link RDF4J}.
+ *
+ */
+ public RDF4J() {
+ this(SimpleValueFactory.getInstance(), UUID.randomUUID());
+ }
+
+ /**
+ * Construct an {@link RDF4J}.
+ * <p>
+ * This constructor is intended for use with the value factory from
+ * {@link Repository#getValueFactory()} when using Repository-based graphs
+ * and datasets.
+ *
+ * @param valueFactory
+ * The RDF4J {@link ValueFactory} to use
+ */
+ public RDF4J(ValueFactory valueFactory) {
+ this(valueFactory, UUID.randomUUID());
+ }
+
+ /**
+ * Construct an {@link RDF4J}.
+ * <p>
+ * This constructor may be used if reproducible
+ * {@link BlankNode#uniqueReference()} in {@link BlankNode} is desirable.
+ *
+ * @param salt
+ * An {@link UUID} salt to be used by any created
+ * {@link BlankNode}s for the purpose of
+ * {@link BlankNode#uniqueReference()}
+ */
+ public RDF4J(UUID salt) {
+ this(SimpleValueFactory.getInstance(), salt);
+ }
+
+ /**
+ * Construct an {@link RDF4J}.
+ * <p>
+ * This constructor may be used if reproducible
+ * {@link BlankNode#uniqueReference()} in {@link BlankNode} is desirable.
+ *
+ * @param valueFactory
+ * The RDF4J {@link ValueFactory} to use
+ * @param salt
+ * An {@link UUID} salt to be used by any created
+ * {@link BlankNode}s for the purpose of
+ * {@link BlankNode#uniqueReference()}
+ */
+ public RDF4J(ValueFactory valueFactory, UUID salt) {
+ this.valueFactory = valueFactory;
+ this.salt = salt;
+ }
+
+ /**
+ * Adapt a RDF4J {@link Statement} as a Commons RDF {@link Quad}.
+ * <p>
+ * For the purpose of {@link BlankNode} equivalence, this method will use an
+ * internal salt UUID that is unique per instance of {@link RDF4J}.
+ * <p>
+ * <strong>NOTE:</strong> If combining RDF4J {@link Statement}s multiple
+ * repositories or models, then their {@link BNode}s may have the same
+ * {@link BNode#getID()}, which with this method would become equivalent
+ * according to {@link BlankNode#equals(Object)} and
+ * {@link BlankNode#uniqueReference()}, unless a separate {@link RDF4J}
+ * instance is used per RDF4J repository/model.
+ *
+ * @param statement
+ * The statement to convert
+ * @return A {@link RDF4JQuad} that is equivalent to the statement
+ */
+ public RDF4JQuad asQuad(final Statement statement) {
+ return rdf4j.createQuadImpl(statement, salt);
+ }
+
+ /**
+ *
+ * Adapt a RDF4J {@link Value} as a Commons RDF {@link RDFTerm}.
+ * <p>
+ * The value will be of the same kind as the term, e.g. a
+ * {@link org.eclipse.rdf4j.model.BNode} is converted to a
+ * {@link org.apache.commons.rdf.api.BlankNode}, a
+ * {@link org.eclipse.rdf4j.model.IRI} is converted to a
+ * {@link org.apache.commons.rdf.api.IRI} and a
+ * {@link org.eclipse.rdf4j.model.Literal}. is converted to a
+ * {@link org.apache.commons.rdf.api.Literal}
+ * <p>
+ * For the purpose of {@link BlankNode} equivalence, this method will use an
+ * internal salt UUID that is unique per instance of {@link RDF4J}.
+ * <p>
+ * <strong>NOTE:</strong> If combining RDF4J values from multiple
+ * repositories or models, then their {@link BNode}s may have the same
+ * {@link BNode#getID()}, which with this method would become equivalent
+ * according to {@link BlankNode#equals(Object)} and
+ * {@link BlankNode#uniqueReference()}, unless a separate {@link RDF4J}
+ * instance is used per RDF4J repository/model.
+ *
+ * @param value
+ * The RDF4J {@link Value} to convert.
+ * @return A {@link RDFTerm} that corresponds to the RDF4J value
+ * @throws IllegalArgumentException
+ * if the value is not a BNode, Literal or IRI
+ */
+ public RDF4JTerm asRDFTerm(Value value) {
+ return asRDFTerm(value, salt);
+ }
+
+ /**
+ * Adapt a RDF4J {@link Value} as a Commons RDF {@link RDFTerm}.
+ * <p>
+ * The value will be of the same kind as the term, e.g. a
+ * {@link org.eclipse.rdf4j.model.BNode} is converted to a
+ * {@link org.apache.commons.rdf.api.BlankNode}, a
+ * {@link org.eclipse.rdf4j.model.IRI} is converted to a
+ * {@link org.apache.commons.rdf.api.IRI} and a
+ * {@link org.eclipse.rdf4j.model.Literal}. is converted to a
+ * {@link org.apache.commons.rdf.api.Literal}
+ *
+ * @param value
+ * The RDF4J {@link Value} to convert.
+ * @param salt
+ * A {@link UUID} salt to use for uniquely mapping any
+ * {@link BNode}s. The salt should typically be the same for
+ * multiple statements in the same {@link Repository} or
+ * {@link Model} to ensure {@link BlankNode#equals(Object)} and
+ * {@link BlankNode#uniqueReference()} works as intended.
+ * @return A {@link RDFTerm} that corresponds to the RDF4J value
+ * @throws IllegalArgumentException
+ * if the value is not a BNode, Literal or IRI
+ */
+ public static RDF4JTerm asRDFTerm(final Value value, UUID salt) {
+ if (value instanceof BNode) {
+ return rdf4j.createBlankNodeImpl((BNode) value, salt);
+ }
+ if (value instanceof org.eclipse.rdf4j.model.Literal) {
+ return rdf4j.createLiteralImpl((org.eclipse.rdf4j.model.Literal) value);
+ }
+ if (value instanceof org.eclipse.rdf4j.model.IRI) {
+ return rdf4j.createIRIImpl((org.eclipse.rdf4j.model.IRI) value);
+ }
+ throw new IllegalArgumentException("Value is not a BNode, Literal or IRI: " + value.getClass());
+ }
+
+ /**
+ * Adapt an RDF4J {@link Repository} as a Commons RDF {@link Dataset}.
+ * <p>
+ * Changes to the dataset are reflected in the repository, and vice versa.
+ * <p>
+ * <strong>Note:</strong> Some operations on the {@link RDF4JDataset}
+ * requires the use of try-with-resources to close underlying
+ * {@link RepositoryConnection}s, including {@link RDF4JDataset#iterate()},
+ * {@link RDF4JDataset#stream()} and {@link RDF4JDataset#getGraphNames()}.
+ *
+ * @param repository
+ * RDF4J {@link Repository} to connect to.
+ * @param options
+ * Zero or more {@link Option}
+ * @return A {@link Dataset} backed by the RDF4J repository.
+ */
+ public RDF4JDataset asDataset(Repository repository, Option... options) {
+ EnumSet<Option> opts = optionSet(options);
+ return rdf4j.createRepositoryDatasetImpl(repository, opts.contains(Option.handleInitAndShutdown),
+ opts.contains(Option.includeInferred));
+ }
+
+ /**
+ * Adapt an RDF4J {@link Model} as a Commons RDF {@link Graph}.
+ * <p>
+ * Changes to the graph are reflected in the model, and vice versa.
+ *
+ * @param model
+ * RDF4J {@link Model} to adapt.
+ * @return Adapted {@link Graph}.
+ */
+ public RDF4JGraph asGraph(Model model) {
+ return rdf4j.createModelGraphImpl(model, this);
+ }
+
+ /**
+ * Adapt an RDF4J {@link Repository} as a Commons RDF {@link Graph}.
+ * <p>
+ * The graph will only include triples in the default graph (equivalent to
+ * context <code>new Resource[0]{null})</code> in RDF4J).
+ * <p>
+ * Changes to the graph are reflected in the repository, and vice versa.
+ * <p>
+ * <strong>Note:</strong> Some operations on the {@link RDF4JGraph} requires
+ * the use of try-with-resources to close underlying
+ * {@link RepositoryConnection}s, including {@link RDF4JGraph#iterate()} and
+ * {@link RDF4JGraph#stream()}.
+ *
+ * @param repository
+ * RDF4J {@link Repository} to connect to.
+ * @param options
+ * Zero or more {@link Option}
+ * @return A {@link Graph} backed by the RDF4J repository.
+ */
+ public RDF4JGraph asGraph(Repository repository, Option... options) {
+ EnumSet<Option> opts = optionSet(options);
+ return rdf4j.createRepositoryGraphImpl(repository, opts.contains(Option.handleInitAndShutdown),
+ opts.contains(Option.includeInferred), new Resource[] { null }); // default
+ // graph
+ }
+
+ /**
+ * Adapt an RDF4J {@link Repository} as a Commons RDF {@link Graph}.
+ * <p>
+ * The graph will include triples in any contexts (e.g. the union graph).
+ * <p>
+ * Changes to the graph are reflected in the repository, and vice versa.
+ *
+ * @param repository
+ * RDF4J {@link Repository} to connect to.
+ * @param options
+ * Zero or more {@link Option}
+ * @return A union {@link Graph} backed by the RDF4J repository.
+ */
+ public RDF4JGraph asGraphUnion(Repository repository, Option... options) {
+ EnumSet<Option> opts = optionSet(options);
+ return rdf4j.createRepositoryGraphImpl(repository, opts.contains(Option.handleInitAndShutdown),
+ opts.contains(Option.includeInferred), new Resource[] {}); // union
+ // graph
+
+ }
+
+ /**
+ * Adapt an RDF4J {@link Repository} as a Commons RDF {@link Graph}.
+ * <p>
+ * The graph will include triples in the specified contexts.
+ * <p>
+ * Changes to the graph are reflected in the repository, and vice versa.
+ * Triples added/removed to the graph are reflected in all the specified
+ * contexts.
+ * <p>
+ * <strong>Note:</strong> Some operations on the {@link RDF4JGraph} requires
+ * the use of try-with-resources to close underlying
+ * {@link RepositoryConnection}s, including {@link RDF4JGraph#iterate()} and
+ * {@link RDF4JGraph#stream()}.
+ *
+ * @param repository
+ * RDF4J {@link Repository} to connect to.
+ * @param contexts
+ * A {@link Set} of {@link BlankNodeOrIRI} specifying the graph
+ * names to use as a context. The set may include the value
+ * <code>null</code> to indicate the default graph. The empty set
+ * indicates any context, e.g. the <em>union graph</em>.
+ * @param option
+ * Zero or more {@link Option}s
+ * @return A {@link Graph} backed by the RDF4J repository.
+ */
+ public RDF4JGraph asGraph(Repository repository, Set<? extends BlankNodeOrIRI> contexts, Option... option) {
+ EnumSet<Option> opts = optionSet(option);
+ /** NOTE: asValue() deliberately CAN handle <code>null</code> */
+ Resource[] resources = contexts.stream().map(g -> (Resource) asValue(g)).toArray(Resource[]::new);
+ return rdf4j.createRepositoryGraphImpl(Objects.requireNonNull(repository),
+ opts.contains(Option.handleInitAndShutdown), opts.contains(Option.includeInferred), resources);
+ }
+
+ /**
+ * Adapt a Commons RDF {@link Triple} or {@link Quad} as a RDF4J
+ * {@link Statement}.
+ * <p>
+ * If the <code>tripleLike</code> argument is an {@link RDF4JTriple} or a
+ * {@link RDF4JQuad}, then its {@link RDF4JTripleLike#asStatement()} is
+ * returned as-is. Note that this means that a {@link RDF4JTriple} would
+ * preserve its {@link Statement#getContext()}, and that any
+ * {@link BlankNode}s would be deemed equivalent in RDF4J if they have the
+ * same {@link BNode#getID()}.
+ *
+ * @param tripleLike
+ * A {@link Triple} or {@link Quad} to adapt
+ * @return A corresponding {@link Statement}
+ */
+ public Statement asStatement(TripleLike tripleLike) {
+ if (tripleLike instanceof RDF4JTripleLike) {
+ // Return original statement - this covers both RDF4JQuad and
+ // RDF4JTriple
+ return ((RDF4JTripleLike) tripleLike).asStatement();
+ }
+
+ org.eclipse.rdf4j.model.Resource subject = (org.eclipse.rdf4j.model.Resource) asValue(tripleLike.getSubject());
+ org.eclipse.rdf4j.model.IRI predicate = (org.eclipse.rdf4j.model.IRI) asValue(tripleLike.getPredicate());
+ Value object = asValue(tripleLike.getObject());
+
+ org.eclipse.rdf4j.model.Resource context = null;
+ if (tripleLike instanceof Quad) {
+ Quad quad = (Quad) tripleLike;
+ context = (org.eclipse.rdf4j.model.Resource) asValue(quad.getGraphName().orElse(null));
+ }
+
+ return getValueFactory().createStatement(subject, predicate, object, context);
+ }
+
+ /**
+ * Adapt a RDF4J {@link Statement} as a Commons RDF {@link Triple}.
+ * <p>
+ * For the purpose of {@link BlankNode} equivalence, this method will use an
+ * internal salt UUID that is unique per instance of {@link RDF4J}.
+ * <p>
+ * <strong>NOTE:</strong> If combining RDF4J statements from multiple
+ * repositories or models, then their {@link BNode}s may have the same
+ * {@link BNode#getID()}, which with this method would become equivalent
+ * according to {@link BlankNode#equals(Object)} and
+ * {@link BlankNode#uniqueReference()}, unless a separate {@link RDF4J}
+ * instance is used per RDF4J repository/model.
+ *
+ * @param statement
+ * The RDF4J {@link Statement} to adapt.
+ * @return A {@link RDF4JTriple} that is equivalent to the statement
+ */
+ public RDF4JTriple asTriple(final Statement statement) {
+ return rdf4j.createTripleImpl(statement, salt);
+ }
+
+ /**
+ * Adapt a Commons RDF {@link RDFTerm} as a RDF4J {@link Value}.
+ * <p>
+ * The value will be of the same kind as the term, e.g. a
+ * {@link org.apache.commons.rdf.api.BlankNode} is converted to a
+ * {@link org.eclipse.rdf4j.model.BNode}, a
+ * {@link org.apache.commons.rdf.api.IRI} is converted to a
+ * {@link org.eclipse.rdf4j.model.IRI} and a
+ * {@link org.apache.commons.rdf.api.Literal} is converted to a
+ * {@link org.eclipse.rdf4j.model.Literal}.
+ * <p>
+ * If the provided {@link RDFTerm} is <code>null</code>, then the returned
+ * value is <code>null</code>.
+ * <p>
+ * If the provided term is an instance of {@link RDF4JTerm}, then the
+ * {@link RDF4JTerm#asValue()} is returned without any conversion. Note that
+ * this could mean that a {@link Value} from a different kind of
+ * {@link ValueFactory} could be returned.
+ *
+ * @param term
+ * RDFTerm to adapt to RDF4J Value
+ * @return Adapted RDF4J {@link Value}
+ */
+ public Value asValue(RDFTerm term) {
+ if (term == null) {
+ return null;
+ }
+ if (term instanceof RDF4JTerm) {
+ // One of our own - avoid converting again.
+ // (This is crucial to avoid double-escaping in BlankNode)
+ return ((RDF4JTerm) term).asValue();
+ }
+ if (term instanceof org.apache.commons.rdf.api.IRI) {
+ org.apache.commons.rdf.api.IRI iri = (org.apache.commons.rdf.api.IRI) term;
+ return getValueFactory().createIRI(iri.getIRIString());
+ }
+ if (term instanceof org.apache.commons.rdf.api.Literal) {
+ org.apache.commons.rdf.api.Literal literal = (org.apache.commons.rdf.api.Literal) term;
+ String label = literal.getLexicalForm();
+ if (literal.getLanguageTag().isPresent()) {
+ String lang = literal.getLanguageTag().get();
+ return getValueFactory().createLiteral(label, lang);
+ }
+ org.eclipse.rdf4j.model.IRI dataType = (org.eclipse.rdf4j.model.IRI) asValue(literal.getDatatype());
+ return getValueFactory().createLiteral(label, dataType);
+ }
+ if (term instanceof BlankNode) {
+ // This is where it gets tricky to support round trips!
+ BlankNode blankNode = (BlankNode) term;
+ // FIXME: The uniqueReference might not be a valid BlankNode
+ // identifier..
+ // does it have to be in RDF4J?
+ return getValueFactory().createBNode(blankNode.uniqueReference());
+ }
+ throw new IllegalArgumentException("RDFTerm was not an IRI, Literal or BlankNode: " + term.getClass());
+ }
+
+ @Override
+ public RDF4JBlankNode createBlankNode() {
+ BNode bnode = getValueFactory().createBNode();
+ return (RDF4JBlankNode) asRDFTerm(bnode);
+ }
+
+ @Override
+ public RDF4JBlankNode createBlankNode(String name) {
+ BNode bnode = getValueFactory().createBNode(name);
+ return (RDF4JBlankNode) asRDFTerm(bnode);
+ }
+
+ /**
+ * {@inheritDoc}
+ * <p>
+ * <strong>Note:</strong> Some operations on the {@link RDF4JDataset}
+ * requires the use of try-with-resources to close underlying
+ * {@link RepositoryConnection}s, including {@link RDF4JDataset#iterate()},
+ * {@link RDF4JDataset#stream()} and {@link RDF4JDataset#getGraphNames()}.
+ *
+ */
+ @Override
+ public RDF4JDataset createDataset() {
+ Sail sail = new MemoryStore();
+ Repository repository = new SailRepository(sail);
+ return rdf4j.createRepositoryDatasetImpl(repository, true, false);
+ }
+
+ @Override
+ public RDF4JGraph createGraph() {
+ return asGraph(new LinkedHashModel());
+ }
+
+ @Override
+ public RDF4JIRI createIRI(String iri) throws IllegalArgumentException {
+ return (RDF4JIRI) asRDFTerm(getValueFactory().createIRI(iri));
+ }
+
+ @Override
+ public RDF4JLiteral createLiteral(String lexicalForm) throws IllegalArgumentException {
+ org.eclipse.rdf4j.model.Literal lit = getValueFactory().createLiteral(lexicalForm);
+ return (RDF4JLiteral) asRDFTerm(lit);
+ }
+
+ @Override
+ public org.apache.commons.rdf.api.Literal createLiteral(String lexicalForm, org.apache.commons.rdf.api.IRI dataType)
+ throws IllegalArgumentException {
+ org.eclipse.rdf4j.model.IRI iri = getValueFactory().createIRI(dataType.getIRIString());
+ org.eclipse.rdf4j.model.Literal lit = getValueFactory().createLiteral(lexicalForm, iri);
+ return (org.apache.commons.rdf.api.Literal) asRDFTerm(lit);
+ }
+
+ @Override
+ public org.apache.commons.rdf.api.Literal createLiteral(String lexicalForm, String languageTag)
+ throws IllegalArgumentException {
+ org.eclipse.rdf4j.model.Literal lit = getValueFactory().createLiteral(lexicalForm, languageTag);
+ return (org.apache.commons.rdf.api.Literal) asRDFTerm(lit);
+ }
+
+ @Override
+ public RDF4JTriple createTriple(BlankNodeOrIRI subject, org.apache.commons.rdf.api.IRI predicate, RDFTerm object)
+ throws IllegalArgumentException {
+ final Statement statement = getValueFactory().createStatement(
+ (org.eclipse.rdf4j.model.Resource) asValue(subject), (org.eclipse.rdf4j.model.IRI) asValue(predicate),
+ asValue(object));
+ return asTriple(statement);
+ }
+
+ @Override
+ public Quad createQuad(BlankNodeOrIRI graphName, BlankNodeOrIRI subject, org.apache.commons.rdf.api.IRI predicate,
+ RDFTerm object) throws IllegalArgumentException {
+ final Statement statement = getValueFactory().createStatement(
+ (org.eclipse.rdf4j.model.Resource) asValue(subject), (org.eclipse.rdf4j.model.IRI) asValue(predicate),
+ asValue(object), (org.eclipse.rdf4j.model.Resource) asValue(graphName));
+ return asQuad(statement);
+ }
+
+ public ValueFactory getValueFactory() {
+ return valueFactory;
+ }
+
+ private EnumSet<Option> optionSet(Option... options) {
+ EnumSet<Option> opts = EnumSet.noneOf(Option.class);
+ opts.addAll(Arrays.asList(options));
+ return opts;
+ }
+
}
http://git-wip-us.apache.org/repos/asf/incubator-commonsrdf/blob/413dd09a/rdf4j/src/main/java/org/apache/commons/rdf/rdf4j/RDF4JBlankNode.java
----------------------------------------------------------------------
diff --git a/rdf4j/src/main/java/org/apache/commons/rdf/rdf4j/RDF4JBlankNode.java b/rdf4j/src/main/java/org/apache/commons/rdf/rdf4j/RDF4JBlankNode.java
index 15ca381..14099e0 100644
--- a/rdf4j/src/main/java/org/apache/commons/rdf/rdf4j/RDF4JBlankNode.java
+++ b/rdf4j/src/main/java/org/apache/commons/rdf/rdf4j/RDF4JBlankNode.java
@@ -21,17 +21,17 @@ import org.apache.commons.rdf.api.BlankNode;
import org.eclipse.rdf4j.model.BNode;
/**
- * Marker interface for RDF4J implementations of
- * Commons RDF {@link org.apache.commons.rdf.api.BlankNode}.
+ * Marker interface for RDF4J implementations of Commons RDF
+ * {@link org.apache.commons.rdf.api.BlankNode}.
* <p>
- * The underlying RDF4J {@link BNode} instance can
- * be retrieved with {@link #asValue()}.
+ * The underlying RDF4J {@link BNode} instance can be retrieved with
+ * {@link #asValue()}.
*
- * @see RDF4J#createBlankNode()
+ * @see RDF4J#createBlankNode()
*/
public interface RDF4JBlankNode extends RDF4JBlankNodeOrIRI, BlankNode {
-
- @Override
- public BNode asValue();
-
+
+ @Override
+ public BNode asValue();
+
}
http://git-wip-us.apache.org/repos/asf/incubator-commonsrdf/blob/413dd09a/rdf4j/src/main/java/org/apache/commons/rdf/rdf4j/RDF4JBlankNodeOrIRI.java
----------------------------------------------------------------------
diff --git a/rdf4j/src/main/java/org/apache/commons/rdf/rdf4j/RDF4JBlankNodeOrIRI.java b/rdf4j/src/main/java/org/apache/commons/rdf/rdf4j/RDF4JBlankNodeOrIRI.java
index 75b5a32..dd7259e 100644
--- a/rdf4j/src/main/java/org/apache/commons/rdf/rdf4j/RDF4JBlankNodeOrIRI.java
+++ b/rdf4j/src/main/java/org/apache/commons/rdf/rdf4j/RDF4JBlankNodeOrIRI.java
@@ -31,7 +31,7 @@ import org.eclipse.rdf4j.model.Resource;
*/
public interface RDF4JBlankNodeOrIRI extends RDF4JTerm, BlankNodeOrIRI {
- @Override
- public Resource asValue();
-
+ @Override
+ public Resource asValue();
+
}
http://git-wip-us.apache.org/repos/asf/incubator-commonsrdf/blob/413dd09a/rdf4j/src/main/java/org/apache/commons/rdf/rdf4j/RDF4JDataset.java
----------------------------------------------------------------------
diff --git a/rdf4j/src/main/java/org/apache/commons/rdf/rdf4j/RDF4JDataset.java b/rdf4j/src/main/java/org/apache/commons/rdf/rdf4j/RDF4JDataset.java
index 7b5cbaa..5740f44 100644
--- a/rdf4j/src/main/java/org/apache/commons/rdf/rdf4j/RDF4JDataset.java
+++ b/rdf4j/src/main/java/org/apache/commons/rdf/rdf4j/RDF4JDataset.java
@@ -27,7 +27,6 @@ import org.apache.commons.rdf.api.Quad;
import org.apache.commons.rdf.api.RDFTerm;
import org.apache.commons.rdf.rdf4j.RDF4J.Option;
-
/**
* Marker interface for RDF4J implementations of Dataset.
*
@@ -35,106 +34,109 @@ import org.apache.commons.rdf.rdf4j.RDF4J.Option;
* @see RDF4J#asDataset(org.eclipse.rdf4j.repository.Repository, Option...)
*/
public interface RDF4JDataset extends Dataset, RDF4JGraphLike<Quad> {
-
- /**
- * {@inheritDoc}
- * <p>
- * Note that for datasets backed by a repository ({@link #asRepository()} is
- * present), the stream <strong>must be closed</strong> with
- * {@link Stream#close()}.
- * <p>
- * This can generally achieved using a try-with-resources block, e.g.:
- * <pre>
- * int subjects;
- * try (Stream<RDF4JQuad> s : graph.stream()) {
- * subjects = s.map(RDF4JQuad::getSubject).distinct().count()
- * }
- * </pre>
- */
- @Override
- Stream<RDF4JQuad> stream();
-
- /**
- * {@inheritDoc}
- * <p>
- * Note that for datasets backed by a repository ({@link #asRepository()} is
- * present), the stream <strong>must be closed</strong> with
- * {@link Stream#close()}.
- * <p>
- * This can generally achieved using a try-with-resources block, e.g.:
- * <pre>
- * int subjects;
- * try (Stream<RDF4JQuad> s : graph.stream()) {
- * subjects = s.map(RDF4JQuad::getSubject).distinct().count()
- * }
- * </pre>
- */
- @Override
- Stream<RDF4JQuad> stream(Optional<BlankNodeOrIRI> graphName, BlankNodeOrIRI subject, IRI predicate,
- RDFTerm object);
- /**
- * {@inheritDoc}
- * <p>
- * Note that for datasets backed by a repository ({@link #asRepository()} is
- * present), the stream <strong>must be closed</strong> with
- * {@link Stream#close()}.
- * <p>
- * This can generally achieved using a try-with-resources block, e.g.:
- * <pre>
- * int graphs;
- * try (Stream<BlankNodeOrIRI> s : graph.stream()) {
- * graphs = s.count()
- * }
- * </pre>
- */
- @Override
- Stream<BlankNodeOrIRI> getGraphNames();
-
+ /**
+ * {@inheritDoc}
+ * <p>
+ * Note that for datasets backed by a repository ({@link #asRepository()} is
+ * present), the stream <strong>must be closed</strong> with
+ * {@link Stream#close()}.
+ * <p>
+ * This can generally achieved using a try-with-resources block, e.g.:
+ *
+ * <pre>
+ * int subjects;
+ * try (Stream<RDF4JQuad> s : graph.stream()) {
+ * subjects = s.map(RDF4JQuad::getSubject).distinct().count()
+ * }
+ * </pre>
+ */
+ @Override
+ Stream<RDF4JQuad> stream();
+
+ /**
+ * {@inheritDoc}
+ * <p>
+ * Note that for datasets backed by a repository ({@link #asRepository()} is
+ * present), the stream <strong>must be closed</strong> with
+ * {@link Stream#close()}.
+ * <p>
+ * This can generally achieved using a try-with-resources block, e.g.:
+ *
+ * <pre>
+ * int subjects;
+ * try (Stream<RDF4JQuad> s : graph.stream()) {
+ * subjects = s.map(RDF4JQuad::getSubject).distinct().count()
+ * }
+ * </pre>
+ */
+ @Override
+ Stream<RDF4JQuad> stream(Optional<BlankNodeOrIRI> graphName, BlankNodeOrIRI subject, IRI predicate, RDFTerm object);
- /**
- * {@inheritDoc}
- * <p>
- * Note that for datasets backed by a repository ({@link #asRepository()} is
- * present), the iterable <strong>must be closed</strong> with
- * {@link ClosableIterable#close()}.
- * <p>
- * This can generally achieved using a try-with-resources block, e.g.:
- * <pre>
- * try (ClosableIterable<Quad> s : graph.iterate()) {
+ /**
+ * {@inheritDoc}
+ * <p>
+ * Note that for datasets backed by a repository ({@link #asRepository()} is
+ * present), the stream <strong>must be closed</strong> with
+ * {@link Stream#close()}.
+ * <p>
+ * This can generally achieved using a try-with-resources block, e.g.:
+ *
+ * <pre>
+ * int graphs;
+ * try (Stream<BlankNodeOrIRI> s : graph.stream()) {
+ * graphs = s.count()
+ * }
+ * </pre>
+ */
+ @Override
+ Stream<BlankNodeOrIRI> getGraphNames();
+
+ /**
+ * {@inheritDoc}
+ * <p>
+ * Note that for datasets backed by a repository ({@link #asRepository()} is
+ * present), the iterable <strong>must be closed</strong> with
+ * {@link ClosableIterable#close()}.
+ * <p>
+ * This can generally achieved using a try-with-resources block, e.g.:
+ *
+ * <pre>
+ * try (ClosableIterable<Quad> s : graph.iterate()) {
* for (Quad q : quads) {
* return q; // OK to terminate for-loop early
* }
- * }
- * </pre>
- * If you don't use a try-with-resources block, the iterator will
- * attempt to close the ClosableIterable
- * when reaching the end of the iteration.
- */
- @Override
- ClosableIterable<Quad> iterate();
-
+ * }
+ * </pre>
+ *
+ * If you don't use a try-with-resources block, the iterator will attempt to
+ * close the ClosableIterable when reaching the end of the iteration.
+ */
+ @Override
+ ClosableIterable<Quad> iterate();
- /**
- * {@inheritDoc}
- * <p>
- * Note that for datasets backed by a repository ({@link #asRepository()} is
- * present), the iterable <strong>must be closed</strong> with
- * {@link ClosableIterable#close()}.
- * <p>
- * This can generally achieved using a try-with-resources block, e.g.:
- * <pre>
- * try (ClosableIterable<Quad> s : graph.iterate(g,s,p,o)) {
+ /**
+ * {@inheritDoc}
+ * <p>
+ * Note that for datasets backed by a repository ({@link #asRepository()} is
+ * present), the iterable <strong>must be closed</strong> with
+ * {@link ClosableIterable#close()}.
+ * <p>
+ * This can generally achieved using a try-with-resources block, e.g.:
+ *
+ * <pre>
+ * try (ClosableIterable<Quad> s : graph.iterate(g,s,p,o)) {
* for (Quad q : quads) {
* return q; // OK to terminate for-loop early
* }
- * }
- * </pre>
- * If you don't use a try-with-resources block, the iterator will
- * attempt to close the ClosableIterable
- * when reaching the end of the iteration.
- */
- @Override
- ClosableIterable<Quad> iterate(Optional<BlankNodeOrIRI> graphName, BlankNodeOrIRI subject, IRI predicate, RDFTerm object);
-
+ * }
+ * </pre>
+ *
+ * If you don't use a try-with-resources block, the iterator will attempt to
+ * close the ClosableIterable when reaching the end of the iteration.
+ */
+ @Override
+ ClosableIterable<Quad> iterate(Optional<BlankNodeOrIRI> graphName, BlankNodeOrIRI subject, IRI predicate,
+ RDFTerm object);
+
}
http://git-wip-us.apache.org/repos/asf/incubator-commonsrdf/blob/413dd09a/rdf4j/src/main/java/org/apache/commons/rdf/rdf4j/RDF4JGraph.java
----------------------------------------------------------------------
diff --git a/rdf4j/src/main/java/org/apache/commons/rdf/rdf4j/RDF4JGraph.java b/rdf4j/src/main/java/org/apache/commons/rdf/rdf4j/RDF4JGraph.java
index 65cdf67..ab52310 100644
--- a/rdf4j/src/main/java/org/apache/commons/rdf/rdf4j/RDF4JGraph.java
+++ b/rdf4j/src/main/java/org/apache/commons/rdf/rdf4j/RDF4JGraph.java
@@ -30,7 +30,6 @@ import org.eclipse.rdf4j.model.Model;
import org.eclipse.rdf4j.repository.Repository;
import org.apache.commons.rdf.rdf4j.RDF4J.Option;
-
/**
* Marker interface for RDF4J implementations of Graph.
*
@@ -42,115 +41,117 @@ import org.apache.commons.rdf.rdf4j.RDF4J.Option;
* @see RDF4JDataset#getGraph(BlankNodeOrIRI)
*/
public interface RDF4JGraph extends Graph, RDF4JGraphLike<Triple> {
-
- /**
- * Return a copy of the context mask as a {@link Set} of
- * {@link RDF4JBlankNodeOrIRI} graph names.
- * <p>
- * If the set is not {@link Set#isEmpty()}, the mask determines which
- * <em>contexts</em> in the corresponding RDF4J {@link Model} or
- * {@link Repository} that this graph reflect. Modifications to the graph
- * (e.g. {@link #add(Triple)} will be performed for all the specified
- * contexts, while retrieval (e.g. {@link #contains(Triple)}) will succeed
- * if the triple is in at least one of the specified contexts.
- * <p>
- * The context mask array may contain <code>null</code>, indicating the
- * default context (the <em>default graph</em> in RDF datasets).
- * <p>
- * If the context mask is {@link Set#isEmpty()}, then this is a <em>union
- * graph</em> which triples reflect statements in any contexts. Triples
- * added to the graph will be added in the default context, e.g. equivalent
- * to <code>new Resource[1]{null}</code>) in RDF4J.
- * <p>
- * Note that the context mask itself cannot be <code>null</code>.
- * <p>
- * The returned set is an immutable copy; to specify a different mask, use
- * {@link RDF4J#asGraph(Repository, Set, Option...)}
- *
- * @return The context mask as a set of {@link BlankNodeOrIRI} graph names, which
- * may contain the value <code>null</code>.
- */
- public Set<RDF4JBlankNodeOrIRI> getContextMask();
-
- /**
- * {@inheritDoc}
- * <p>
- * Note that for graphs backed by a repository ({@link #asRepository()} is
- * present), the stream <strong>must be closed</strong> with
- * {@link Stream#close()}.
- * <p>
- * This can generally achieved using a try-with-resources block, e.g.:
- *
- * <pre>
- * int subjects;
- * try (Stream<RDF4JTriple> s : graph.stream()) {
- * subjects = s.map(RDF4JTriple::getSubject).distinct().count()
- * }
- * </pre>
- */
- @Override
- Stream<RDF4JTriple> stream();
- /**
- * {@inheritDoc}
- * <p>
- * Note that for graphs backed by a repository ({@link #asRepository()} is
- * present), the stream <strong>must be closed</strong> with
- * {@link Stream#close()}.
- * <p>
- * This can generally achieved using a try-with-resources block, e.g.:
- * <pre>
- * int subjects;
- * try (Stream<RDF4JTriple> s : graph.stream(s,p,o)) {
- * subjects = s.map(RDF4JTriple::getSubject).distinct().count()
- * }
- * </pre>
- */
- @Override
- Stream<RDF4JTriple> stream(BlankNodeOrIRI subject, IRI predicate, RDFTerm object);
-
-
- /**
- * {@inheritDoc}
- * <p>
- * Note that for graphs backed by a repository ({@link #asRepository()} is
- * present), the iterable <strong>must be closed</strong> with
- * {@link ClosableIterable#close()}.
- * <p>
- * This can generally achieved using a try-with-resources block, e.g.:
- * <pre>
- * try (ClosableIterable<Triple> s : graph.iterate()) {
+ /**
+ * Return a copy of the context mask as a {@link Set} of
+ * {@link RDF4JBlankNodeOrIRI} graph names.
+ * <p>
+ * If the set is not {@link Set#isEmpty()}, the mask determines which
+ * <em>contexts</em> in the corresponding RDF4J {@link Model} or
+ * {@link Repository} that this graph reflect. Modifications to the graph
+ * (e.g. {@link #add(Triple)} will be performed for all the specified
+ * contexts, while retrieval (e.g. {@link #contains(Triple)}) will succeed
+ * if the triple is in at least one of the specified contexts.
+ * <p>
+ * The context mask array may contain <code>null</code>, indicating the
+ * default context (the <em>default graph</em> in RDF datasets).
+ * <p>
+ * If the context mask is {@link Set#isEmpty()}, then this is a <em>union
+ * graph</em> which triples reflect statements in any contexts. Triples
+ * added to the graph will be added in the default context, e.g. equivalent
+ * to <code>new Resource[1]{null}</code>) in RDF4J.
+ * <p>
+ * Note that the context mask itself cannot be <code>null</code>.
+ * <p>
+ * The returned set is an immutable copy; to specify a different mask, use
+ * {@link RDF4J#asGraph(Repository, Set, Option...)}
+ *
+ * @return The context mask as a set of {@link BlankNodeOrIRI} graph names,
+ * which may contain the value <code>null</code>.
+ */
+ public Set<RDF4JBlankNodeOrIRI> getContextMask();
+
+ /**
+ * {@inheritDoc}
+ * <p>
+ * Note that for graphs backed by a repository ({@link #asRepository()} is
+ * present), the stream <strong>must be closed</strong> with
+ * {@link Stream#close()}.
+ * <p>
+ * This can generally achieved using a try-with-resources block, e.g.:
+ *
+ * <pre>
+ * int subjects;
+ * try (Stream<RDF4JTriple> s : graph.stream()) {
+ * subjects = s.map(RDF4JTriple::getSubject).distinct().count()
+ * }
+ * </pre>
+ */
+ @Override
+ Stream<RDF4JTriple> stream();
+
+ /**
+ * {@inheritDoc}
+ * <p>
+ * Note that for graphs backed by a repository ({@link #asRepository()} is
+ * present), the stream <strong>must be closed</strong> with
+ * {@link Stream#close()}.
+ * <p>
+ * This can generally achieved using a try-with-resources block, e.g.:
+ *
+ * <pre>
+ * int subjects;
+ * try (Stream<RDF4JTriple> s : graph.stream(s,p,o)) {
+ * subjects = s.map(RDF4JTriple::getSubject).distinct().count()
+ * }
+ * </pre>
+ */
+ @Override
+ Stream<RDF4JTriple> stream(BlankNodeOrIRI subject, IRI predicate, RDFTerm object);
+
+ /**
+ * {@inheritDoc}
+ * <p>
+ * Note that for graphs backed by a repository ({@link #asRepository()} is
+ * present), the iterable <strong>must be closed</strong> with
+ * {@link ClosableIterable#close()}.
+ * <p>
+ * This can generally achieved using a try-with-resources block, e.g.:
+ *
+ * <pre>
+ * try (ClosableIterable<Triple> s : graph.iterate()) {
* for (Triple t : triples) {
* return t; // OK to terminate for-loop early
* }
- * }
- * </pre>
- * If you don't use a try-with-resources block, the iterator will
- * attempt to close the ClosableIterable
- * when reaching the end of the iteration.
- */
- @Override
- ClosableIterable<Triple> iterate() throws ConcurrentModificationException, IllegalStateException;
+ * }
+ * </pre>
+ *
+ * If you don't use a try-with-resources block, the iterator will attempt to
+ * close the ClosableIterable when reaching the end of the iteration.
+ */
+ @Override
+ ClosableIterable<Triple> iterate() throws ConcurrentModificationException, IllegalStateException;
- /**
- * {@inheritDoc}
- * <p>
- * Note that for graphs backed by a repository ({@link #asRepository()} is
- * present), the iterable <strong>must be closed</strong> with
- * {@link ClosableIterable#close()}.
- * <p>
- * This can generally achieved using a try-with-resources block, e.g.:
- * <pre>
- * try (ClosableIterable<Triple> s : graph.iterate(s,p,o)) {
+ /**
+ * {@inheritDoc}
+ * <p>
+ * Note that for graphs backed by a repository ({@link #asRepository()} is
+ * present), the iterable <strong>must be closed</strong> with
+ * {@link ClosableIterable#close()}.
+ * <p>
+ * This can generally achieved using a try-with-resources block, e.g.:
+ *
+ * <pre>
+ * try (ClosableIterable<Triple> s : graph.iterate(s,p,o)) {
* for (Triple t : triples) {
* return t; // OK to terminate for-loop early
* }
- * }
- * </pre>
- * If you don't use a try-with-resources block, the iterator will
- * attempt to close the ClosableIterable
- * when reaching the end of the iteration.
- */
- @Override
- ClosableIterable<Triple> iterate(BlankNodeOrIRI subject, IRI predicate, RDFTerm object);
+ * }
+ * </pre>
+ *
+ * If you don't use a try-with-resources block, the iterator will attempt to
+ * close the ClosableIterable when reaching the end of the iteration.
+ */
+ @Override
+ ClosableIterable<Triple> iterate(BlankNodeOrIRI subject, IRI predicate, RDFTerm object);
}
http://git-wip-us.apache.org/repos/asf/incubator-commonsrdf/blob/413dd09a/rdf4j/src/main/java/org/apache/commons/rdf/rdf4j/RDF4JGraphLike.java
----------------------------------------------------------------------
diff --git a/rdf4j/src/main/java/org/apache/commons/rdf/rdf4j/RDF4JGraphLike.java b/rdf4j/src/main/java/org/apache/commons/rdf/rdf4j/RDF4JGraphLike.java
index 430369a..4b69bee 100644
--- a/rdf4j/src/main/java/org/apache/commons/rdf/rdf4j/RDF4JGraphLike.java
+++ b/rdf4j/src/main/java/org/apache/commons/rdf/rdf4j/RDF4JGraphLike.java
@@ -37,31 +37,30 @@ import org.eclipse.rdf4j.repository.Repository;
* @see RDF4JDataset
* @see RDF4JGraph
*/
-public interface RDF4JGraphLike<T extends TripleLike>
- extends GraphLike<T>, AutoCloseable {
+public interface RDF4JGraphLike<T extends TripleLike> extends GraphLike<T>, AutoCloseable {
- /**
- * Return the corresponding RDF4J {@link Model}, if present.
- * <p>
- * The return value is {@link Optional#isPresent()} if this is backed by a
- * Model.
- * <p>
- * Changes to the Model are reflected in both directions.
- *
- * @return The corresponding RDF4J Model.
- */
- public Optional<Model> asModel();
+ /**
+ * Return the corresponding RDF4J {@link Model}, if present.
+ * <p>
+ * The return value is {@link Optional#isPresent()} if this is backed by a
+ * Model.
+ * <p>
+ * Changes to the Model are reflected in both directions.
+ *
+ * @return The corresponding RDF4J Model.
+ */
+ public Optional<Model> asModel();
- /**
- * Return the corresponding RDF4J {@link Repository}, if present.
- * <p>
- * The return value is {@link Optional#isPresent()} if this is backed by a
- * Repository.
- * <p>
- * Changes to the Repository are reflected in both directions.
- *
- * @return The corresponding RDF4J Repository.
- */
- public Optional<Repository> asRepository();
+ /**
+ * Return the corresponding RDF4J {@link Repository}, if present.
+ * <p>
+ * The return value is {@link Optional#isPresent()} if this is backed by a
+ * Repository.
+ * <p>
+ * Changes to the Repository are reflected in both directions.
+ *
+ * @return The corresponding RDF4J Repository.
+ */
+ public Optional<Repository> asRepository();
}
http://git-wip-us.apache.org/repos/asf/incubator-commonsrdf/blob/413dd09a/rdf4j/src/main/java/org/apache/commons/rdf/rdf4j/RDF4JIRI.java
----------------------------------------------------------------------
diff --git a/rdf4j/src/main/java/org/apache/commons/rdf/rdf4j/RDF4JIRI.java b/rdf4j/src/main/java/org/apache/commons/rdf/rdf4j/RDF4JIRI.java
index 72c83fa..642ed58 100644
--- a/rdf4j/src/main/java/org/apache/commons/rdf/rdf4j/RDF4JIRI.java
+++ b/rdf4j/src/main/java/org/apache/commons/rdf/rdf4j/RDF4JIRI.java
@@ -18,18 +18,17 @@
package org.apache.commons.rdf.rdf4j;
/**
- * Marker interface for RDF4J implementations of
- * Commons RDF {@link org.apache.commons.rdf.api.IRI}.
+ * Marker interface for RDF4J implementations of Commons RDF
+ * {@link org.apache.commons.rdf.api.IRI}.
* <p>
- * The underlying RDF4J {@link org.eclipse.rdf4j.model.IRI}
- * instance can be retrieved with {@link #asValue()}.
+ * The underlying RDF4J {@link org.eclipse.rdf4j.model.IRI} instance can be
+ * retrieved with {@link #asValue()}.
*
* @see RDF4J#createIRI(String)
*/
-public interface RDF4JIRI
- extends RDF4JBlankNodeOrIRI, org.apache.commons.rdf.api.IRI {
-
- @Override
- org.eclipse.rdf4j.model.IRI asValue();
-
+public interface RDF4JIRI extends RDF4JBlankNodeOrIRI, org.apache.commons.rdf.api.IRI {
+
+ @Override
+ org.eclipse.rdf4j.model.IRI asValue();
+
}
http://git-wip-us.apache.org/repos/asf/incubator-commonsrdf/blob/413dd09a/rdf4j/src/main/java/org/apache/commons/rdf/rdf4j/RDF4JQuad.java
----------------------------------------------------------------------
diff --git a/rdf4j/src/main/java/org/apache/commons/rdf/rdf4j/RDF4JQuad.java b/rdf4j/src/main/java/org/apache/commons/rdf/rdf4j/RDF4JQuad.java
index 23b6cdf..7fedfde 100644
--- a/rdf4j/src/main/java/org/apache/commons/rdf/rdf4j/RDF4JQuad.java
+++ b/rdf4j/src/main/java/org/apache/commons/rdf/rdf4j/RDF4JQuad.java
@@ -22,8 +22,10 @@ import org.apache.commons.rdf.api.Quad;
/**
* Marker interface for RDF4J implementations of Quad.
*
- * @see RDF4J#createQuad(org.apache.commons.rdf.api.BlankNodeOrIRI, org.apache.commons.rdf.api.BlankNodeOrIRI, org.apache.commons.rdf.api.IRI, org.apache.commons.rdf.api.RDFTerm)
+ * @see RDF4J#createQuad(org.apache.commons.rdf.api.BlankNodeOrIRI,
+ * org.apache.commons.rdf.api.BlankNodeOrIRI,
+ * org.apache.commons.rdf.api.IRI, org.apache.commons.rdf.api.RDFTerm)
*/
public interface RDF4JQuad extends Quad, RDF4JTripleLike {
-
+
}
http://git-wip-us.apache.org/repos/asf/incubator-commonsrdf/blob/413dd09a/rdf4j/src/main/java/org/apache/commons/rdf/rdf4j/RDF4JTerm.java
----------------------------------------------------------------------
diff --git a/rdf4j/src/main/java/org/apache/commons/rdf/rdf4j/RDF4JTerm.java b/rdf4j/src/main/java/org/apache/commons/rdf/rdf4j/RDF4JTerm.java
index e500651..1f7b841 100644
--- a/rdf4j/src/main/java/org/apache/commons/rdf/rdf4j/RDF4JTerm.java
+++ b/rdf4j/src/main/java/org/apache/commons/rdf/rdf4j/RDF4JTerm.java
@@ -25,14 +25,15 @@ import org.eclipse.rdf4j.model.Value;
/**
* Marker interface for RDF4J implementations of RDFTerm.
- *
+ *
*/
public interface RDF4JTerm extends RDFTerm {
-
- /**
- * Return the RDF4J {@link Value} that this RDFTerm represents.
- *
- * @return The wrapped {@link Value} (e.g. a {@link Literal}, {@link IRI} or {@link BNode}.
- */
- public Value asValue();
+
+ /**
+ * Return the RDF4J {@link Value} that this RDFTerm represents.
+ *
+ * @return The wrapped {@link Value} (e.g. a {@link Literal}, {@link IRI} or
+ * {@link BNode}.
+ */
+ public Value asValue();
}
http://git-wip-us.apache.org/repos/asf/incubator-commonsrdf/blob/413dd09a/rdf4j/src/main/java/org/apache/commons/rdf/rdf4j/RDF4JTriple.java
----------------------------------------------------------------------
diff --git a/rdf4j/src/main/java/org/apache/commons/rdf/rdf4j/RDF4JTriple.java b/rdf4j/src/main/java/org/apache/commons/rdf/rdf4j/RDF4JTriple.java
index ca32d94..55388ab 100644
--- a/rdf4j/src/main/java/org/apache/commons/rdf/rdf4j/RDF4JTriple.java
+++ b/rdf4j/src/main/java/org/apache/commons/rdf/rdf4j/RDF4JTriple.java
@@ -22,8 +22,9 @@ import org.apache.commons.rdf.api.Triple;
/**
* Marker interface for RDF4J implementations of Triple.
*
- * @see RDF4J#createTriple(org.apache.commons.rdf.api.BlankNodeOrIRI, org.apache.commons.rdf.api.IRI, org.apache.commons.rdf.api.RDFTerm)
+ * @see RDF4J#createTriple(org.apache.commons.rdf.api.BlankNodeOrIRI,
+ * org.apache.commons.rdf.api.IRI, org.apache.commons.rdf.api.RDFTerm)
*/
public interface RDF4JTriple extends Triple, RDF4JTripleLike {
-
+
}
http://git-wip-us.apache.org/repos/asf/incubator-commonsrdf/blob/413dd09a/rdf4j/src/main/java/org/apache/commons/rdf/rdf4j/RDF4JTripleLike.java
----------------------------------------------------------------------
diff --git a/rdf4j/src/main/java/org/apache/commons/rdf/rdf4j/RDF4JTripleLike.java b/rdf4j/src/main/java/org/apache/commons/rdf/rdf4j/RDF4JTripleLike.java
index e204e77..222c2c8 100644
--- a/rdf4j/src/main/java/org/apache/commons/rdf/rdf4j/RDF4JTripleLike.java
+++ b/rdf4j/src/main/java/org/apache/commons/rdf/rdf4j/RDF4JTripleLike.java
@@ -23,20 +23,21 @@ import org.eclipse.rdf4j.model.Statement;
/**
* Marker interface for RDF4J implementations of {@link TripleLike} statements.
* <p>
- * This interface is in common with the more specific {@link RDF4JTriple} or
+ * This interface is in common with the more specific {@link RDF4JTriple} or
* {@link RDF4JQuad}.
* <p>
- * This is backed by a {@link Statement} retrievable with {@link #asStatement()}.
+ * This is backed by a {@link Statement} retrievable with
+ * {@link #asStatement()}.
*
* @see RDF4JTriple
* @see RDF4JQuad
*/
public interface RDF4JTripleLike extends TripleLike {
-
- /**
- * Return the corresponding RDF4J {@link Statement}.
- *
- * @return The corresponding RDF4J Statement.
- */
- public Statement asStatement();
+
+ /**
+ * Return the corresponding RDF4J {@link Statement}.
+ *
+ * @return The corresponding RDF4J Statement.
+ */
+ public Statement asStatement();
}
http://git-wip-us.apache.org/repos/asf/incubator-commonsrdf/blob/413dd09a/rdf4j/src/main/java/org/apache/commons/rdf/rdf4j/experimental/RDF4JParser.java
----------------------------------------------------------------------
diff --git a/rdf4j/src/main/java/org/apache/commons/rdf/rdf4j/experimental/RDF4JParser.java b/rdf4j/src/main/java/org/apache/commons/rdf/rdf4j/experimental/RDF4JParser.java
index 26b3647..87328cd 100644
--- a/rdf4j/src/main/java/org/apache/commons/rdf/rdf4j/experimental/RDF4JParser.java
+++ b/rdf4j/src/main/java/org/apache/commons/rdf/rdf4j/experimental/RDF4JParser.java
@@ -59,174 +59,178 @@ import org.eclipse.rdf4j.rio.helpers.AbstractRDFHandler;
*/
public class RDF4JParser extends AbstractRDFParser<RDF4JParser> implements RDFParser {
- private final class AddToQuadConsumer extends AbstractRDFHandler {
- private final Consumer<Quad> quadTarget;
-
- private AddToQuadConsumer(Consumer<Quad> quadTarget) {
- this.quadTarget = quadTarget;
- }
-
- public void handleStatement(org.eclipse.rdf4j.model.Statement st)
- throws org.eclipse.rdf4j.rio.RDFHandlerException {
- // TODO: if getRdfTermFactory() is a non-rdf4j factory, should
- // we use factory.createQuad() instead?
- // Unsure what is the promise of setting getRdfTermFactory() --
- // does it go all the way down to creating BlankNode, IRI and
- // Literal?
- quadTarget.accept(rdf4jTermFactory.asQuad(st));
- // Performance note:
- // Graph/Quad.add should pick up again our
- // RDF4JGraphLike.asStatement()
- // and avoid double conversion.
- // Additionally the RDF4JQuad and RDF4JTriple implementations
- // are lazily converting subj/obj/pred/graph.s
- }
- }
-
- private final static class AddToModel extends AbstractRDFHandler {
- private final Model model;
-
- public AddToModel(Model model) {
- this.model = model;
- }
-
- public void handleStatement(org.eclipse.rdf4j.model.Statement st)
- throws org.eclipse.rdf4j.rio.RDFHandlerException {
- model.add(st);
- }
-
- @Override
- public void handleNamespace(String prefix, String uri) throws RDFHandlerException {
- model.setNamespace(prefix, uri);
- }
- }
-
- private RDF4J rdf4jTermFactory;
- private ParserConfig parserConfig = new ParserConfig();
-
- @Override
- protected RDF4J createRDFTermFactory() {
- return new RDF4J();
- }
-
- @Override
- protected RDF4JParser prepareForParsing() throws IOException, IllegalStateException {
- RDF4JParser c = super.prepareForParsing();
- // Ensure we have an RDF4J for conversion.
- // We'll make a new one if user has provided a non-RDF4J factory
- c.rdf4jTermFactory = (RDF4J) getRdfTermFactory().filter(RDF4J.class::isInstance)
- .orElseGet(c::createRDFTermFactory);
- return c;
- }
-
- @Override
- protected void parseSynchronusly() throws IOException {
- Optional<RDFFormat> formatByMimeType = getContentType().flatMap(Rio::getParserFormatForMIMEType);
- String base = getBase().map(IRI::getIRIString).orElse(null);
-
- ParserConfig parserConfig = getParserConfig();
- // TODO: Should we need to set anything?
- RDFLoader loader = new RDFLoader(parserConfig, rdf4jTermFactory.getValueFactory());
- RDFHandler rdfHandler = makeRDFHandler();
- if (getSourceFile().isPresent()) {
- // NOTE: While we could have used
- // loader.load(sourcePath.toFile()
- // if the path fs provider == FileSystems.getDefault(),
- // that RDFLoader method does not use absolute path
- // as the base URI, so to be consistent
- // we'll always do it with our own input stream
- //
- // That means we may have to guess format by extensions:
- Optional<RDFFormat> formatByFilename = getSourceFile().map(Path::getFileName).map(Path::toString)
- .flatMap(Rio::getParserFormatForFileName);
- // TODO: for the excited.. what about the extension after following symlinks?
-
- RDFFormat format = formatByMimeType.orElse(formatByFilename.orElse(null));
- try (InputStream in = Files.newInputStream(getSourceFile().get())) {
- loader.load(in, base, format, rdfHandler);
- }
- } else if (getSourceIri().isPresent()) {
- try {
- // TODO: Handle international IRIs properly
- // (Unicode support for for hostname, path and query)
- URL url = new URL(getSourceIri().get().getIRIString());
- // TODO: This probably does not support https:// -> http:// redirections
- loader.load(url, base, formatByMimeType.orElse(null), makeRDFHandler());
- } catch (MalformedURLException ex) {
- throw new IOException("Can't handle source URL: " + getSourceIri().get(), ex);
- }
- }
- // must be getSourceInputStream then, this is guaranteed by super.checkSource();
- loader.load(getSourceInputStream().get(), base, formatByMimeType.orElse(null), rdfHandler);
- }
-
- /**
- * Get the RDF4J {@link ParserConfig} to use.
- * <p>
- * If no parser config is set, the default configuration is provided.
- * <p>
- * <strong>Note:</strong> The parser config is mutable - changes in the
- * returned config is reflected in this instance of the parser.
- * To avoid mutation, create a new {@link ParserConfig} and set
- * {@link #setParserConfig(ParserConfig)}.
- *
- * @return The RDF4J {@link ParserConfig}
- */
- public ParserConfig getParserConfig() {
- return parserConfig;
- }
-
- /**
- * Set an RDF4J {@link ParserConfig} to use
- *
- * @param parserConfig Parser configuration
- */
- public void setParserConfig(ParserConfig parserConfig) {
- this.parserConfig = parserConfig;
- }
-
- protected RDFHandler makeRDFHandler() {
-
- // TODO: Can we join the below DF4JDataset and RDF4JGraph cases
- // using RDF4JGraphLike<TripleLike<BlankNodeOrIRI,IRI,RDFTerm>>
- // or will that need tricky generics types?
-
- if (getTargetDataset().filter(RDF4JDataset.class::isInstance).isPresent()) {
- // One of us, we can add them as Statements directly
- RDF4JDataset dataset = (RDF4JDataset) getTargetDataset().get();
- if (dataset.asRepository().isPresent()) {
- return new RDFInserter(dataset.asRepository().get().getConnection());
- }
- if (dataset.asModel().isPresent()) {
- Model model = dataset.asModel().get();
- return new AddToModel(model);
- }
- // Not backed by Repository or Model?
- // Third-party RDF4JDataset subclass, so we'll fall through to the
- // getTarget() handling further down
- } else if (getTargetGraph().filter(RDF4JGraph.class::isInstance).isPresent()) {
- RDF4JGraph graph = (RDF4JGraph) getTargetGraph().get();
-
- if (graph.asRepository().isPresent()) {
- RDFInserter inserter = new RDFInserter(graph.asRepository().get().getConnection());
- if (! graph.getContextMask().isEmpty()) {
- Stream<RDF4JBlankNodeOrIRI> b = graph.getContextMask().stream();
- Stream<Resource> c = b.map(RDF4JBlankNodeOrIRI::asValue);
- Resource[] contexts = c.toArray(Resource[]::new);
- inserter.enforceContext(contexts);
- }
- return inserter;
- }
- if (graph.asModel().isPresent() && graph.getContextMask().isEmpty()) {
- // the model accepts any quad
- Model model = graph.asModel().get();
- return new AddToModel(model);
- }
- // else - fall through
- }
-
- // Fall thorough: let target() consume our converted quads.
- return new AddToQuadConsumer(getTarget());
- }
+ private final class AddToQuadConsumer extends AbstractRDFHandler {
+ private final Consumer<Quad> quadTarget;
+
+ private AddToQuadConsumer(Consumer<Quad> quadTarget) {
+ this.quadTarget = quadTarget;
+ }
+
+ public void handleStatement(org.eclipse.rdf4j.model.Statement st)
+ throws org.eclipse.rdf4j.rio.RDFHandlerException {
+ // TODO: if getRdfTermFactory() is a non-rdf4j factory, should
+ // we use factory.createQuad() instead?
+ // Unsure what is the promise of setting getRdfTermFactory() --
+ // does it go all the way down to creating BlankNode, IRI and
+ // Literal?
+ quadTarget.accept(rdf4jTermFactory.asQuad(st));
+ // Performance note:
+ // Graph/Quad.add should pick up again our
+ // RDF4JGraphLike.asStatement()
+ // and avoid double conversion.
+ // Additionally the RDF4JQuad and RDF4JTriple implementations
+ // are lazily converting subj/obj/pred/graph.s
+ }
+ }
+
+ private final static class AddToModel extends AbstractRDFHandler {
+ private final Model model;
+
+ public AddToModel(Model model) {
+ this.model = model;
+ }
+
+ public void handleStatement(org.eclipse.rdf4j.model.Statement st)
+ throws org.eclipse.rdf4j.rio.RDFHandlerException {
+ model.add(st);
+ }
+
+ @Override
+ public void handleNamespace(String prefix, String uri) throws RDFHandlerException {
+ model.setNamespace(prefix, uri);
+ }
+ }
+
+ private RDF4J rdf4jTermFactory;
+ private ParserConfig parserConfig = new ParserConfig();
+
+ @Override
+ protected RDF4J createRDFTermFactory() {
+ return new RDF4J();
+ }
+
+ @Override
+ protected RDF4JParser prepareForParsing() throws IOException, IllegalStateException {
+ RDF4JParser c = super.prepareForParsing();
+ // Ensure we have an RDF4J for conversion.
+ // We'll make a new one if user has provided a non-RDF4J factory
+ c.rdf4jTermFactory = (RDF4J) getRdfTermFactory().filter(RDF4J.class::isInstance)
+ .orElseGet(c::createRDFTermFactory);
+ return c;
+ }
+
+ @Override
+ protected void parseSynchronusly() throws IOException {
+ Optional<RDFFormat> formatByMimeType = getContentType().flatMap(Rio::getParserFormatForMIMEType);
+ String base = getBase().map(IRI::getIRIString).orElse(null);
+
+ ParserConfig parserConfig = getParserConfig();
+ // TODO: Should we need to set anything?
+ RDFLoader loader = new RDFLoader(parserConfig, rdf4jTermFactory.getValueFactory());
+ RDFHandler rdfHandler = makeRDFHandler();
+ if (getSourceFile().isPresent()) {
+ // NOTE: While we could have used
+ // loader.load(sourcePath.toFile()
+ // if the path fs provider == FileSystems.getDefault(),
+ // that RDFLoader method does not use absolute path
+ // as the base URI, so to be consistent
+ // we'll always do it with our own input stream
+ //
+ // That means we may have to guess format by extensions:
+ Optional<RDFFormat> formatByFilename = getSourceFile().map(Path::getFileName).map(Path::toString)
+ .flatMap(Rio::getParserFormatForFileName);
+ // TODO: for the excited.. what about the extension after following
+ // symlinks?
+
+ RDFFormat format = formatByMimeType.orElse(formatByFilename.orElse(null));
+ try (InputStream in = Files.newInputStream(getSourceFile().get())) {
+ loader.load(in, base, format, rdfHandler);
+ }
+ } else if (getSourceIri().isPresent()) {
+ try {
+ // TODO: Handle international IRIs properly
+ // (Unicode support for for hostname, path and query)
+ URL url = new URL(getSourceIri().get().getIRIString());
+ // TODO: This probably does not support https:// -> http://
+ // redirections
+ loader.load(url, base, formatByMimeType.orElse(null), makeRDFHandler());
+ } catch (MalformedURLException ex) {
+ throw new IOException("Can't handle source URL: " + getSourceIri().get(), ex);
+ }
+ }
+ // must be getSourceInputStream then, this is guaranteed by
+ // super.checkSource();
+ loader.load(getSourceInputStream().get(), base, formatByMimeType.orElse(null), rdfHandler);
+ }
+
+ /**
+ * Get the RDF4J {@link ParserConfig} to use.
+ * <p>
+ * If no parser config is set, the default configuration is provided.
+ * <p>
+ * <strong>Note:</strong> The parser config is mutable - changes in the
+ * returned config is reflected in this instance of the parser. To avoid
+ * mutation, create a new {@link ParserConfig} and set
+ * {@link #setParserConfig(ParserConfig)}.
+ *
+ * @return The RDF4J {@link ParserConfig}
+ */
+ public ParserConfig getParserConfig() {
+ return parserConfig;
+ }
+
+ /**
+ * Set an RDF4J {@link ParserConfig} to use
+ *
+ * @param parserConfig
+ * Parser configuration
+ */
+ public void setParserConfig(ParserConfig parserConfig) {
+ this.parserConfig = parserConfig;
+ }
+
+ protected RDFHandler makeRDFHandler() {
+
+ // TODO: Can we join the below DF4JDataset and RDF4JGraph cases
+ // using RDF4JGraphLike<TripleLike<BlankNodeOrIRI,IRI,RDFTerm>>
+ // or will that need tricky generics types?
+
+ if (getTargetDataset().filter(RDF4JDataset.class::isInstance).isPresent()) {
+ // One of us, we can add them as Statements directly
+ RDF4JDataset dataset = (RDF4JDataset) getTargetDataset().get();
+ if (dataset.asRepository().isPresent()) {
+ return new RDFInserter(dataset.asRepository().get().getConnection());
+ }
+ if (dataset.asModel().isPresent()) {
+ Model model = dataset.asModel().get();
+ return new AddToModel(model);
+ }
+ // Not backed by Repository or Model?
+ // Third-party RDF4JDataset subclass, so we'll fall through to the
+ // getTarget() handling further down
+ } else if (getTargetGraph().filter(RDF4JGraph.class::isInstance).isPresent()) {
+ RDF4JGraph graph = (RDF4JGraph) getTargetGraph().get();
+
+ if (graph.asRepository().isPresent()) {
+ RDFInserter inserter = new RDFInserter(graph.asRepository().get().getConnection());
+ if (!graph.getContextMask().isEmpty()) {
+ Stream<RDF4JBlankNodeOrIRI> b = graph.getContextMask().stream();
+ Stream<Resource> c = b.map(RDF4JBlankNodeOrIRI::asValue);
+ Resource[] contexts = c.toArray(Resource[]::new);
+ inserter.enforceContext(contexts);
+ }
+ return inserter;
+ }
+ if (graph.asModel().isPresent() && graph.getContextMask().isEmpty()) {
+ // the model accepts any quad
+ Model model = graph.asModel().get();
+ return new AddToModel(model);
+ }
+ // else - fall through
+ }
+
+ // Fall thorough: let target() consume our converted quads.
+ return new AddToQuadConsumer(getTarget());
+ }
}
http://git-wip-us.apache.org/repos/asf/incubator-commonsrdf/blob/413dd09a/rdf4j/src/main/java/org/apache/commons/rdf/rdf4j/experimental/package-info.java
----------------------------------------------------------------------
diff --git a/rdf4j/src/main/java/org/apache/commons/rdf/rdf4j/experimental/package-info.java b/rdf4j/src/main/java/org/apache/commons/rdf/rdf4j/experimental/package-info.java
index 217d003..4f5b070 100644
--- a/rdf4j/src/main/java/org/apache/commons/rdf/rdf4j/experimental/package-info.java
+++ b/rdf4j/src/main/java/org/apache/commons/rdf/rdf4j/experimental/package-info.java
@@ -18,15 +18,13 @@
/**
* Experimental Commons RDF RDF4J implementations.
* <p>
- * Classes in this package should be considered <strong>at
- * risk</strong>; they might change or be removed in the next minor update of
- * Commons RDF.
+ * Classes in this package should be considered <strong>at risk</strong>; they
+ * might change or be removed in the next minor update of Commons RDF.
* <p>
* When a class has stabilized, it will move to the
* {@link org.apache.commons.rdf.rdf4j} package.
* <ul>
- * <li>{@link RDF4JParser} - an RDF4J-backed
- * implementations of
+ * <li>{@link RDF4JParser} - an RDF4J-backed implementations of
* {@link org.apache.commons.rdf.experimental.RDFParser}.</li>
* </ul>
*/
http://git-wip-us.apache.org/repos/asf/incubator-commonsrdf/blob/413dd09a/rdf4j/src/main/java/org/apache/commons/rdf/rdf4j/impl/AbstractRDFTerm.java
----------------------------------------------------------------------
diff --git a/rdf4j/src/main/java/org/apache/commons/rdf/rdf4j/impl/AbstractRDFTerm.java b/rdf4j/src/main/java/org/apache/commons/rdf/rdf4j/impl/AbstractRDFTerm.java
index b54c715..7fce346 100644
--- a/rdf4j/src/main/java/org/apache/commons/rdf/rdf4j/impl/AbstractRDFTerm.java
+++ b/rdf4j/src/main/java/org/apache/commons/rdf/rdf4j/impl/AbstractRDFTerm.java
@@ -21,13 +21,13 @@ import org.apache.commons.rdf.rdf4j.RDF4JTerm;
import org.eclipse.rdf4j.model.Value;
abstract class AbstractRDFTerm<T extends Value> implements RDF4JTerm {
- T value;
+ T value;
- AbstractRDFTerm(T value) {
- this.value = value;
- }
-
- public T asValue() {
- return value;
- }
+ AbstractRDFTerm(T value) {
+ this.value = value;
+ }
+
+ public T asValue() {
+ return value;
+ }
}
\ No newline at end of file