Repository: incubator-commonsrdf Updated Branches: refs/heads/master 5aa8d6cb7 -> 0bb936968
RDF4JTermFactory -> RDF4JFactory Project: http://git-wip-us.apache.org/repos/asf/incubator-commonsrdf/repo Commit: http://git-wip-us.apache.org/repos/asf/incubator-commonsrdf/commit/d043b075 Tree: http://git-wip-us.apache.org/repos/asf/incubator-commonsrdf/tree/d043b075 Diff: http://git-wip-us.apache.org/repos/asf/incubator-commonsrdf/diff/d043b075 Branch: refs/heads/master Commit: d043b0759e8bd6d261db3fa03cdd0248b46cf47e Parents: 5aa8d6c Author: Stian Soiland-Reyes <st...@apache.org> Authored: Wed Oct 19 09:47:54 2016 +0100 Committer: Stian Soiland-Reyes <st...@apache.org> Committed: Wed Oct 19 09:47:54 2016 +0100 ---------------------------------------------------------------------- rdf4j/pom.xml | 2 +- .../commons/rdf/rdf4j/RDF4JBlankNode.java | 2 +- .../apache/commons/rdf/rdf4j/RDF4JDataset.java | 4 +- .../apache/commons/rdf/rdf4j/RDF4JFactory.java | 601 +++++++++++++++++++ .../apache/commons/rdf/rdf4j/RDF4JGraph.java | 10 +- .../org/apache/commons/rdf/rdf4j/RDF4JIRI.java | 2 +- .../apache/commons/rdf/rdf4j/RDF4JLiteral.java | 2 +- .../org/apache/commons/rdf/rdf4j/RDF4JQuad.java | 2 +- .../commons/rdf/rdf4j/RDF4JTermFactory.java | 601 ------------------- .../apache/commons/rdf/rdf4j/RDF4JTriple.java | 2 +- .../rdf/rdf4j/experimental/RDF4JParser.java | 12 +- .../rdf4j/impl/AbstractRepositoryGraphLike.java | 6 +- .../rdf/rdf4j/impl/InternalRDF4JFactory.java | 14 +- .../commons/rdf/rdf4j/impl/ModelGraphImpl.java | 6 +- .../apache/commons/rdf/rdf4j/impl/QuadImpl.java | 10 +- .../commons/rdf/rdf4j/impl/TripleImpl.java | 8 +- .../apache/commons/rdf/rdf4j/package-info.java | 8 +- .../apache/commons/rdf/rdf4j/BlankNodeTest.java | 2 +- .../org/apache/commons/rdf/rdf4j/GraphTest.java | 2 +- .../commons/rdf/rdf4j/MemoryGraphTest.java | 2 +- .../commons/rdf/rdf4j/NativeStoreGraphTest.java | 2 +- .../rdf/rdf4j/Rdf4JRDFTermFactoryTest.java | 2 +- src/site/markdown/implementations.md | 12 +- 23 files changed, 657 insertions(+), 657 deletions(-) ---------------------------------------------------------------------- http://git-wip-us.apache.org/repos/asf/incubator-commonsrdf/blob/d043b075/rdf4j/pom.xml ---------------------------------------------------------------------- diff --git a/rdf4j/pom.xml b/rdf4j/pom.xml index ce21b98..0c6cb28 100644 --- a/rdf4j/pom.xml +++ b/rdf4j/pom.xml @@ -121,7 +121,7 @@ <!-- There are multiple RDF4J sail/repository implementations, we use the - below from RDF4JTermFactory. --> + below from RDF4JFactory. --> <dependency> <groupId>org.eclipse.rdf4j</groupId> <artifactId>rdf4j-sail-memory</artifactId> http://git-wip-us.apache.org/repos/asf/incubator-commonsrdf/blob/d043b075/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 3e5a055..2ed616f 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 @@ -27,7 +27,7 @@ import org.eclipse.rdf4j.model.BNode; * The underlying RDF4J {@link BNode} instance can * be retrieved with {@link #asValue()}. * - * @see RDF4JTermFactory#createBlankNode() + * @see RDF4JFactory#createBlankNode() */ public interface RDF4JBlankNode extends RDF4JBlankNodeOrIRI, BlankNode { http://git-wip-us.apache.org/repos/asf/incubator-commonsrdf/blob/d043b075/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 b00ab39..2066c34 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 @@ -30,8 +30,8 @@ import org.apache.commons.rdf.api.RDFTerm; /** * Marker interface for RDF4J implementations of Dataset. * - * @see RDF4JTermFactory#createDataset() - * @see RDF4JTermFactory#asRDFTermDataset(org.eclipse.rdf4j.repository.Repository, org.apache.commons.rdf.rdf4j.RDF4JTermFactory.Option...) + * @see RDF4JFactory#createDataset() + * @see RDF4JFactory#asRDFTermDataset(org.eclipse.rdf4j.repository.Repository, org.apache.commons.rdf.rdf4j.RDF4JFactory.Option...) */ public interface RDF4JDataset extends Dataset, RDF4JGraphLike<Quad> { http://git-wip-us.apache.org/repos/asf/incubator-commonsrdf/blob/d043b075/rdf4j/src/main/java/org/apache/commons/rdf/rdf4j/RDF4JFactory.java ---------------------------------------------------------------------- diff --git a/rdf4j/src/main/java/org/apache/commons/rdf/rdf4j/RDF4JFactory.java b/rdf4j/src/main/java/org/apache/commons/rdf/rdf4j/RDF4JFactory.java new file mode 100644 index 0000000..7d4eabe --- /dev/null +++ b/rdf4j/src/main/java/org/apache/commons/rdf/rdf4j/RDF4JFactory.java @@ -0,0 +1,601 @@ +/** + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.apache.commons.rdf.rdf4j; + +import java.util.Arrays; +import java.util.EnumSet; +import java.util.Objects; +import java.util.Set; +import java.util.UUID; + +// To avoid confusion, avoid importing +// classes that are in both +// commons.rdf and openrdf.model (e.g. IRI, Literal) +import org.apache.commons.rdf.api.BlankNode; +import org.apache.commons.rdf.api.BlankNodeOrIRI; +import org.apache.commons.rdf.api.Dataset; +import org.apache.commons.rdf.api.Graph; +import org.apache.commons.rdf.api.Quad; +import org.apache.commons.rdf.api.RDFTerm; +import org.apache.commons.rdf.api.RDFTermFactory; +import org.apache.commons.rdf.api.Triple; +import org.apache.commons.rdf.api.TripleLike; +import org.apache.commons.rdf.rdf4j.impl.InternalRDF4JFactory; +import org.eclipse.rdf4j.model.BNode; +import org.eclipse.rdf4j.model.Model; +import org.eclipse.rdf4j.model.Resource; +import org.eclipse.rdf4j.model.Statement; +import org.eclipse.rdf4j.model.Value; +import org.eclipse.rdf4j.model.ValueFactory; +import org.eclipse.rdf4j.model.impl.LinkedHashModel; +import org.eclipse.rdf4j.model.impl.SimpleValueFactory; +import org.eclipse.rdf4j.repository.Repository; +import org.eclipse.rdf4j.repository.RepositoryConnection; +import org.eclipse.rdf4j.repository.sail.SailRepository; +import org.eclipse.rdf4j.sail.Sail; +import org.eclipse.rdf4j.sail.memory.MemoryStore; + +/** + * RDF4J implementation of RDFTermFactory. + * <p> + * The {@link #RDF4JFactory()} 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 #RDF4JFactory(ValueFactory)}. + * <p> + * {@link #asRDFTerm(Value)} can be used to convert any RDF4J {@link Value} to + * an RDFTerm. Note that adapted {@link BNode}s are considered equal if they are + * converted with the same {@link RDF4JFactory} instance and have the same + * {@link BNode#getID()}. + * <p> + * {@link #createGraph()} creates a new Graph backed by {@link LinkedHashModel}. + * To use other models, see {@link #asRDFTermGraph(Model)}. + * <p> + * To adapt a RDF4J {@link Repository} as a {@link Dataset} or {@link Graph}, + * use {@link #asRDFTermDataset(Repository, Option...)} + * or + * {@link #asRDFTermGraph(Repository, Option...)}. + * <p> + * {@link #asTriple(Statement)} can be used to convert a RDF4J {@link Statement} + * to a Commons RDF {@link Triple}, and equivalent {@link #asQuad(Statement)} to + * convert a {@link Quad}. + * <p> + * To convert any {@link Triple} or {@link Quad} to to RDF4J {@link Statement}, + * use {@link #asStatement(TripleLike)}. This recognises previously converted + * {@link RDF4JTriple}s and {@link RDF4JQuad}s without re-converting their + * {@link RDF4JTripleLike#asStatement()}. + * <p> + * Likewise, {@link #asValue(RDFTerm)} can be used to convert any Commons RDF + * {@link RDFTerm} to a corresponding RDF4J {@link Value}. This recognises + * previously converted {@link RDF4JTerm}s without re-converting their + * {@link RDF4JTerm#asValue()}. + * <p> + * For the purpose of {@link BlankNode} equivalence, this factory contains an + * internal {@link UUID} salt that is used by adapter methods like + * {@link #asQuad(Statement)}, {@link #asTriple(Statement)}, + * {@link #asRDFTerm(Value)} as well as {@link #createBlankNode(String)}. As + * RDF4J {@link BNode} instances from multiple repositories or models may have + * 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 #asRDFTermDataset(Repository, Option...)} + * and + * {@link #asRDFTermGraph(Repository, Option...)} + * therefore uses a unique {@link RDF4JFactory} internally. + * + */ +public final class RDF4JFactory implements RDFTermFactory { + + /** + * 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 RDF4JFactory}. + * + */ + public RDF4JFactory() { + this(SimpleValueFactory.getInstance(), UUID.randomUUID()); + } + + /** + * Construct an {@link RDF4JFactory}. + * <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 RDF4JFactory(ValueFactory valueFactory) { + this(valueFactory, UUID.randomUUID()); + } + + /** + * Construct an {@link RDF4JFactory}. + * <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 RDF4JFactory(UUID salt) { + this(SimpleValueFactory.getInstance(), salt); + } + /** + * Construct an {@link RDF4JFactory}. + * <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 RDF4JFactory(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 RDF4JFactory}. + * <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 RDF4JFactory} 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 RDF4JFactory}. + * <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 RDF4JFactory} 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 asRDFTermDataset(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 asRDFTermGraph(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 asRDFTermGraph(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 asRDFTermGraphUnion(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 asRDFTermGraph(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 RDF4JFactory}. + * <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 RDF4JFactory} 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 asRDFTermGraph(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/d043b075/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 a83a9ab..b7ef9a2 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 @@ -33,10 +33,10 @@ import org.eclipse.rdf4j.repository.Repository; /** * Marker interface for RDF4J implementations of Graph. * - * @see RDF4JTermFactory#createGraph() - * @see RDF4JTermFactory#asRDFTermGraph(Model) - * @see RDF4JTermFactory#asRDFTermGraph(Repository, org.apache.commons.rdf.rdf4j.RDF4JTermFactory.Option...) - * @see RDF4JTermFactory#asRDFTermGraphUnion(Repository, org.apache.commons.rdf.rdf4j.RDF4JTermFactory.Option...) + * @see RDF4JFactory#createGraph() + * @see RDF4JFactory#asRDFTermGraph(Model) + * @see RDF4JFactory#asRDFTermGraph(Repository, org.apache.commons.rdf.rdf4j.RDF4JFactory.Option...) + * @see RDF4JFactory#asRDFTermGraphUnion(Repository, org.apache.commons.rdf.rdf4j.RDF4JFactory.Option...) * @see RDF4JDataset#getGraph() * @see RDF4JDataset#getGraph(BlankNodeOrIRI) */ @@ -64,7 +64,7 @@ public interface RDF4JGraph extends Graph, RDF4JGraphLike<Triple> { * 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 RDF4JTermFactory#asRDFTermGraph(Repository, Set, org.apache.commons.rdf.rdf4j.RDF4JTermFactory.Option...)} + * {@link RDF4JFactory#asRDFTermGraph(Repository, Set, org.apache.commons.rdf.rdf4j.RDF4JFactory.Option...)} * * @return The context mask as a set of {@link BlankNodeOrIRI} graph names, which * may contain the value <code>null</code>. http://git-wip-us.apache.org/repos/asf/incubator-commonsrdf/blob/d043b075/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 37efa0a..270567b 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 @@ -24,7 +24,7 @@ package org.apache.commons.rdf.rdf4j; * The underlying RDF4J {@link org.eclipse.rdf4j.model.IRI} * instance can be retrieved with {@link #asValue()}. * - * @see RDF4JTermFactory#createIRI(String) + * @see RDF4JFactory#createIRI(String) */ public interface RDF4JIRI extends RDF4JBlankNodeOrIRI, org.apache.commons.rdf.api.IRI { http://git-wip-us.apache.org/repos/asf/incubator-commonsrdf/blob/d043b075/rdf4j/src/main/java/org/apache/commons/rdf/rdf4j/RDF4JLiteral.java ---------------------------------------------------------------------- diff --git a/rdf4j/src/main/java/org/apache/commons/rdf/rdf4j/RDF4JLiteral.java b/rdf4j/src/main/java/org/apache/commons/rdf/rdf4j/RDF4JLiteral.java index 114d3f9..f6b0349 100644 --- a/rdf4j/src/main/java/org/apache/commons/rdf/rdf4j/RDF4JLiteral.java +++ b/rdf4j/src/main/java/org/apache/commons/rdf/rdf4j/RDF4JLiteral.java @@ -24,7 +24,7 @@ package org.apache.commons.rdf.rdf4j; * The underlying RDF4J {@link org.eclipse.rdf4j.model.Literal} instance can be * retrieved with {@link #asValue()}. * - * @see RDF4JTermFactory#createLiteral(String) + * @see RDF4JFactory#createLiteral(String) */ public interface RDF4JLiteral extends RDF4JTerm, org.apache.commons.rdf.api.Literal { } http://git-wip-us.apache.org/repos/asf/incubator-commonsrdf/blob/d043b075/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 2d5b68f..d3fbcf0 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,7 +22,7 @@ import org.apache.commons.rdf.api.Quad; /** * Marker interface for RDF4J implementations of Quad. * - * @see RDF4JTermFactory#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 RDF4JFactory#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/d043b075/rdf4j/src/main/java/org/apache/commons/rdf/rdf4j/RDF4JTermFactory.java ---------------------------------------------------------------------- diff --git a/rdf4j/src/main/java/org/apache/commons/rdf/rdf4j/RDF4JTermFactory.java b/rdf4j/src/main/java/org/apache/commons/rdf/rdf4j/RDF4JTermFactory.java deleted file mode 100644 index c503077..0000000 --- a/rdf4j/src/main/java/org/apache/commons/rdf/rdf4j/RDF4JTermFactory.java +++ /dev/null @@ -1,601 +0,0 @@ -/** - * Licensed to the Apache Software Foundation (ASF) under one - * or more contributor license agreements. See the NOTICE file - * distributed with this work for additional information - * regarding copyright ownership. The ASF licenses this file - * to you under the Apache License, Version 2.0 (the - * "License"); you may not use this file except in compliance - * with the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ -package org.apache.commons.rdf.rdf4j; - -import java.util.Arrays; -import java.util.EnumSet; -import java.util.Objects; -import java.util.Set; -import java.util.UUID; - -// To avoid confusion, avoid importing -// classes that are in both -// commons.rdf and openrdf.model (e.g. IRI, Literal) -import org.apache.commons.rdf.api.BlankNode; -import org.apache.commons.rdf.api.BlankNodeOrIRI; -import org.apache.commons.rdf.api.Dataset; -import org.apache.commons.rdf.api.Graph; -import org.apache.commons.rdf.api.Quad; -import org.apache.commons.rdf.api.RDFTerm; -import org.apache.commons.rdf.api.RDFTermFactory; -import org.apache.commons.rdf.api.Triple; -import org.apache.commons.rdf.api.TripleLike; -import org.apache.commons.rdf.rdf4j.impl.InternalRDF4JFactory; -import org.eclipse.rdf4j.model.BNode; -import org.eclipse.rdf4j.model.Model; -import org.eclipse.rdf4j.model.Resource; -import org.eclipse.rdf4j.model.Statement; -import org.eclipse.rdf4j.model.Value; -import org.eclipse.rdf4j.model.ValueFactory; -import org.eclipse.rdf4j.model.impl.LinkedHashModel; -import org.eclipse.rdf4j.model.impl.SimpleValueFactory; -import org.eclipse.rdf4j.repository.Repository; -import org.eclipse.rdf4j.repository.RepositoryConnection; -import org.eclipse.rdf4j.repository.sail.SailRepository; -import org.eclipse.rdf4j.sail.Sail; -import org.eclipse.rdf4j.sail.memory.MemoryStore; - -/** - * RDF4J implementation of RDFTermFactory. - * <p> - * The {@link #RDF4JTermFactory()} 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 #RDF4JTermFactory(ValueFactory)}. - * <p> - * {@link #asRDFTerm(Value)} can be used to convert any RDF4J {@link Value} to - * an RDFTerm. Note that adapted {@link BNode}s are considered equal if they are - * converted with the same {@link RDF4JTermFactory} instance and have the same - * {@link BNode#getID()}. - * <p> - * {@link #createGraph()} creates a new Graph backed by {@link LinkedHashModel}. - * To use other models, see {@link #asRDFTermGraph(Model)}. - * <p> - * To adapt a RDF4J {@link Repository} as a {@link Dataset} or {@link Graph}, - * use {@link #asRDFTermDataset(Repository, Option...)} - * or - * {@link #asRDFTermGraph(Repository, Option...)}. - * <p> - * {@link #asTriple(Statement)} can be used to convert a RDF4J {@link Statement} - * to a Commons RDF {@link Triple}, and equivalent {@link #asQuad(Statement)} to - * convert a {@link Quad}. - * <p> - * To convert any {@link Triple} or {@link Quad} to to RDF4J {@link Statement}, - * use {@link #asStatement(TripleLike)}. This recognises previously converted - * {@link RDF4JTriple}s and {@link RDF4JQuad}s without re-converting their - * {@link RDF4JTripleLike#asStatement()}. - * <p> - * Likewise, {@link #asValue(RDFTerm)} can be used to convert any Commons RDF - * {@link RDFTerm} to a corresponding RDF4J {@link Value}. This recognises - * previously converted {@link RDF4JTerm}s without re-converting their - * {@link RDF4JTerm#asValue()}. - * <p> - * For the purpose of {@link BlankNode} equivalence, this factory contains an - * internal {@link UUID} salt that is used by adapter methods like - * {@link #asQuad(Statement)}, {@link #asTriple(Statement)}, - * {@link #asRDFTerm(Value)} as well as {@link #createBlankNode(String)}. As - * RDF4J {@link BNode} instances from multiple repositories or models may have - * 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 #asRDFTermDataset(Repository, Option...)} - * and - * {@link #asRDFTermGraph(Repository, Option...)} - * therefore uses a unique {@link RDF4JTermFactory} internally. - * - */ -public final class RDF4JTermFactory implements RDFTermFactory { - - /** - * 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 RDF4JTermFactory}. - * - */ - public RDF4JTermFactory() { - this(SimpleValueFactory.getInstance(), UUID.randomUUID()); - } - - /** - * Construct an {@link RDF4JTermFactory}. - * <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 RDF4JTermFactory(ValueFactory valueFactory) { - this(valueFactory, UUID.randomUUID()); - } - - /** - * Construct an {@link RDF4JTermFactory}. - * <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 RDF4JTermFactory(UUID salt) { - this(SimpleValueFactory.getInstance(), salt); - } - /** - * Construct an {@link RDF4JTermFactory}. - * <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 RDF4JTermFactory(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 RDF4JTermFactory}. - * <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 RDF4JTermFactory} 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 RDF4JTermFactory}. - * <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 RDF4JTermFactory} 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 asRDFTermDataset(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 asRDFTermGraph(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 asRDFTermGraph(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 asRDFTermGraphUnion(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 asRDFTermGraph(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 RDF4JTermFactory}. - * <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 RDF4JTermFactory} 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 asRDFTermGraph(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/d043b075/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 7308f8f..e475a08 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,7 +22,7 @@ import org.apache.commons.rdf.api.Triple; /** * Marker interface for RDF4J implementations of Triple. * - * @see RDF4JTermFactory#createTriple(org.apache.commons.rdf.api.BlankNodeOrIRI, org.apache.commons.rdf.api.IRI, org.apache.commons.rdf.api.RDFTerm) + * @see RDF4JFactory#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/d043b075/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 17aecf9..f9a1e74 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 @@ -34,7 +34,7 @@ import org.apache.commons.rdf.experimental.RDFParser; import org.apache.commons.rdf.rdf4j.RDF4JBlankNodeOrIRI; import org.apache.commons.rdf.rdf4j.RDF4JDataset; import org.apache.commons.rdf.rdf4j.RDF4JGraph; -import org.apache.commons.rdf.rdf4j.RDF4JTermFactory; +import org.apache.commons.rdf.rdf4j.RDF4JFactory; import org.apache.commons.rdf.simple.experimental.AbstractRDFParser; import org.eclipse.rdf4j.model.Model; import org.eclipse.rdf4j.model.Resource; @@ -101,20 +101,20 @@ public class RDF4JParser extends AbstractRDFParser<RDF4JParser> implements RDFPa } } - private RDF4JTermFactory rdf4jTermFactory; + private RDF4JFactory rdf4jTermFactory; private ParserConfig parserConfig = new ParserConfig(); @Override - protected RDF4JTermFactory createRDFTermFactory() { - return new RDF4JTermFactory(); + protected RDF4JFactory createRDFTermFactory() { + return new RDF4JFactory(); } @Override protected RDF4JParser prepareForParsing() throws IOException, IllegalStateException { RDF4JParser c = prepareForParsing(); - // Ensure we have an RDF4JTermFactory for conversion. + // Ensure we have an RDF4JFactory for conversion. // We'll make a new one if user has provided a non-RDF4J factory - c.rdf4jTermFactory = (RDF4JTermFactory) getRdfTermFactory().filter(RDF4JTermFactory.class::isInstance) + c.rdf4jTermFactory = (RDF4JFactory) getRdfTermFactory().filter(RDF4JFactory.class::isInstance) .orElseGet(c::createRDFTermFactory); return c; } http://git-wip-us.apache.org/repos/asf/incubator-commonsrdf/blob/d043b075/rdf4j/src/main/java/org/apache/commons/rdf/rdf4j/impl/AbstractRepositoryGraphLike.java ---------------------------------------------------------------------- diff --git a/rdf4j/src/main/java/org/apache/commons/rdf/rdf4j/impl/AbstractRepositoryGraphLike.java b/rdf4j/src/main/java/org/apache/commons/rdf/rdf4j/impl/AbstractRepositoryGraphLike.java index 00388b9..1948a32 100644 --- a/rdf4j/src/main/java/org/apache/commons/rdf/rdf4j/impl/AbstractRepositoryGraphLike.java +++ b/rdf4j/src/main/java/org/apache/commons/rdf/rdf4j/impl/AbstractRepositoryGraphLike.java @@ -22,7 +22,7 @@ import java.util.UUID; import org.apache.commons.rdf.api.TripleLike; import org.apache.commons.rdf.rdf4j.RDF4JGraphLike; -import org.apache.commons.rdf.rdf4j.RDF4JTermFactory; +import org.apache.commons.rdf.rdf4j.RDF4JFactory; import org.eclipse.rdf4j.model.Model; import org.eclipse.rdf4j.model.Statement; import org.eclipse.rdf4j.repository.Repository; @@ -34,7 +34,7 @@ abstract class AbstractRepositoryGraphLike<T extends TripleLike> protected final Repository repository; protected final boolean includeInferred; protected final boolean handleInitAndShutdown; - protected final RDF4JTermFactory rdf4jTermFactory; + protected final RDF4JFactory rdf4jTermFactory; protected final UUID salt; AbstractRepositoryGraphLike(Repository repository, UUID salt, boolean handleInitAndShutdown, boolean includeInferred) { @@ -45,7 +45,7 @@ abstract class AbstractRepositoryGraphLike<T extends TripleLike> if (handleInitAndShutdown && !repository.isInitialized()) { repository.initialize(); } - rdf4jTermFactory = new RDF4JTermFactory(repository.getValueFactory(), salt); + rdf4jTermFactory = new RDF4JFactory(repository.getValueFactory(), salt); } @Override http://git-wip-us.apache.org/repos/asf/incubator-commonsrdf/blob/d043b075/rdf4j/src/main/java/org/apache/commons/rdf/rdf4j/impl/InternalRDF4JFactory.java ---------------------------------------------------------------------- diff --git a/rdf4j/src/main/java/org/apache/commons/rdf/rdf4j/impl/InternalRDF4JFactory.java b/rdf4j/src/main/java/org/apache/commons/rdf/rdf4j/impl/InternalRDF4JFactory.java index fa4344f..7744e01 100644 --- a/rdf4j/src/main/java/org/apache/commons/rdf/rdf4j/impl/InternalRDF4JFactory.java +++ b/rdf4j/src/main/java/org/apache/commons/rdf/rdf4j/impl/InternalRDF4JFactory.java @@ -27,7 +27,7 @@ import org.apache.commons.rdf.rdf4j.RDF4JIRI; import org.apache.commons.rdf.rdf4j.RDF4JLiteral; import org.apache.commons.rdf.rdf4j.RDF4JQuad; import org.apache.commons.rdf.rdf4j.RDF4JTerm; -import org.apache.commons.rdf.rdf4j.RDF4JTermFactory; +import org.apache.commons.rdf.rdf4j.RDF4JFactory; import org.apache.commons.rdf.rdf4j.RDF4JTriple; import org.eclipse.rdf4j.model.BNode; import org.eclipse.rdf4j.model.IRI; @@ -42,17 +42,17 @@ import org.eclipse.rdf4j.repository.Repository; * <p> * <strong>Internal class:</strong> This "abstract" class is intended for * internal use by Commons RDF and may change in any minor update. Use instead - * {@link RDF4JTermFactory} methods like - * {@link RDF4JTermFactory#createBlankNode()}, - * {@link RDF4JTermFactory#asRDFTerm(org.eclipse.rdf4j.model.Value)} and - * {@link RDF4JTermFactory#asRDFTermGraph(Repository, org.apache.commons.rdf.rdf4j.RDF4JTermFactory.Option...)} + * {@link RDF4JFactory} methods like + * {@link RDF4JFactory#createBlankNode()}, + * {@link RDF4JFactory#asRDFTerm(org.eclipse.rdf4j.model.Value)} and + * {@link RDF4JFactory#asRDFTermGraph(Repository, org.apache.commons.rdf.rdf4j.RDF4JFactory.Option...)} * <p> * This class exists as a <code>public</code> bridge between the packages * {@link org.apache.commons.rdf.rdf4j} and * {@link org.apache.commons.rdf.rdf4j.impl} by exposing the package-public * constructors. * - * @see RDF4JTermFactory + * @see RDF4JFactory */ public abstract class InternalRDF4JFactory { @@ -103,7 +103,7 @@ public abstract class InternalRDF4JFactory { * factory to use for adapting graph triples * @return Adapted {@link RDF4JGraph} */ - public RDF4JGraph createModelGraphImpl(Model model, RDF4JTermFactory rdf4jTermFactory) { + public RDF4JGraph createModelGraphImpl(Model model, RDF4JFactory rdf4jTermFactory) { return new ModelGraphImpl(model, rdf4jTermFactory); } http://git-wip-us.apache.org/repos/asf/incubator-commonsrdf/blob/d043b075/rdf4j/src/main/java/org/apache/commons/rdf/rdf4j/impl/ModelGraphImpl.java ---------------------------------------------------------------------- diff --git a/rdf4j/src/main/java/org/apache/commons/rdf/rdf4j/impl/ModelGraphImpl.java b/rdf4j/src/main/java/org/apache/commons/rdf/rdf4j/impl/ModelGraphImpl.java index a2aaf4b..0d2695e 100644 --- a/rdf4j/src/main/java/org/apache/commons/rdf/rdf4j/impl/ModelGraphImpl.java +++ b/rdf4j/src/main/java/org/apache/commons/rdf/rdf4j/impl/ModelGraphImpl.java @@ -31,7 +31,7 @@ import org.apache.commons.rdf.api.Triple; import org.apache.commons.rdf.rdf4j.ClosableIterable; import org.apache.commons.rdf.rdf4j.RDF4JBlankNodeOrIRI; import org.apache.commons.rdf.rdf4j.RDF4JGraph; -import org.apache.commons.rdf.rdf4j.RDF4JTermFactory; +import org.apache.commons.rdf.rdf4j.RDF4JFactory; import org.apache.commons.rdf.rdf4j.RDF4JTriple; import org.eclipse.rdf4j.model.Model; import org.eclipse.rdf4j.model.Resource; @@ -40,9 +40,9 @@ import org.eclipse.rdf4j.repository.Repository; final class ModelGraphImpl implements RDF4JGraph { private Model model; - private RDF4JTermFactory rdf4jTermFactory; + private RDF4JFactory rdf4jTermFactory; - ModelGraphImpl(Model model, RDF4JTermFactory rdf4jTermFactory) { + ModelGraphImpl(Model model, RDF4JFactory rdf4jTermFactory) { this.model = model; this.rdf4jTermFactory = rdf4jTermFactory; } http://git-wip-us.apache.org/repos/asf/incubator-commonsrdf/blob/d043b075/rdf4j/src/main/java/org/apache/commons/rdf/rdf4j/impl/QuadImpl.java ---------------------------------------------------------------------- diff --git a/rdf4j/src/main/java/org/apache/commons/rdf/rdf4j/impl/QuadImpl.java b/rdf4j/src/main/java/org/apache/commons/rdf/rdf4j/impl/QuadImpl.java index 18a0c84..cf60883 100644 --- a/rdf4j/src/main/java/org/apache/commons/rdf/rdf4j/impl/QuadImpl.java +++ b/rdf4j/src/main/java/org/apache/commons/rdf/rdf4j/impl/QuadImpl.java @@ -26,7 +26,7 @@ import org.apache.commons.rdf.api.Quad; import org.apache.commons.rdf.api.RDFTerm; import org.apache.commons.rdf.api.Triple; import org.apache.commons.rdf.rdf4j.RDF4JQuad; -import org.apache.commons.rdf.rdf4j.RDF4JTermFactory; +import org.apache.commons.rdf.rdf4j.RDF4JFactory; import org.eclipse.rdf4j.model.Statement; final class QuadImpl implements Quad, RDF4JQuad { @@ -65,23 +65,23 @@ final class QuadImpl implements Quad, RDF4JQuad { if (statement.getContext() == null) { return Optional.empty(); } - BlankNodeOrIRI g = (BlankNodeOrIRI) RDF4JTermFactory.asRDFTerm(statement.getContext(), salt); + BlankNodeOrIRI g = (BlankNodeOrIRI) RDF4JFactory.asRDFTerm(statement.getContext(), salt); return Optional.of(g); } @Override public RDFTerm getObject() { - return RDF4JTermFactory.asRDFTerm(statement.getObject(), salt); + return RDF4JFactory.asRDFTerm(statement.getObject(), salt); } @Override public org.apache.commons.rdf.api.IRI getPredicate() { - return (org.apache.commons.rdf.api.IRI) RDF4JTermFactory.asRDFTerm(statement.getPredicate(), null); + return (org.apache.commons.rdf.api.IRI) RDF4JFactory.asRDFTerm(statement.getPredicate(), null); } @Override public BlankNodeOrIRI getSubject() { - return (BlankNodeOrIRI) RDF4JTermFactory.asRDFTerm(statement.getSubject(), salt); + return (BlankNodeOrIRI) RDF4JFactory.asRDFTerm(statement.getSubject(), salt); } @Override http://git-wip-us.apache.org/repos/asf/incubator-commonsrdf/blob/d043b075/rdf4j/src/main/java/org/apache/commons/rdf/rdf4j/impl/TripleImpl.java ---------------------------------------------------------------------- diff --git a/rdf4j/src/main/java/org/apache/commons/rdf/rdf4j/impl/TripleImpl.java b/rdf4j/src/main/java/org/apache/commons/rdf/rdf4j/impl/TripleImpl.java index e1dcb60..23041c4 100644 --- a/rdf4j/src/main/java/org/apache/commons/rdf/rdf4j/impl/TripleImpl.java +++ b/rdf4j/src/main/java/org/apache/commons/rdf/rdf4j/impl/TripleImpl.java @@ -23,7 +23,7 @@ import java.util.UUID; import org.apache.commons.rdf.api.BlankNodeOrIRI; import org.apache.commons.rdf.api.RDFTerm; import org.apache.commons.rdf.api.Triple; -import org.apache.commons.rdf.rdf4j.RDF4JTermFactory; +import org.apache.commons.rdf.rdf4j.RDF4JFactory; import org.apache.commons.rdf.rdf4j.RDF4JTriple; import org.eclipse.rdf4j.model.Statement; @@ -54,17 +54,17 @@ final class TripleImpl implements Triple, RDF4JTriple { @Override public RDFTerm getObject() { - return RDF4JTermFactory.asRDFTerm(statement.getObject(), salt); + return RDF4JFactory.asRDFTerm(statement.getObject(), salt); } @Override public org.apache.commons.rdf.api.IRI getPredicate() { - return (org.apache.commons.rdf.api.IRI) RDF4JTermFactory.asRDFTerm(statement.getPredicate(), null); + return (org.apache.commons.rdf.api.IRI) RDF4JFactory.asRDFTerm(statement.getPredicate(), null); } @Override public BlankNodeOrIRI getSubject() { - return (BlankNodeOrIRI) RDF4JTermFactory.asRDFTerm(statement.getSubject(), salt); + return (BlankNodeOrIRI) RDF4JFactory.asRDFTerm(statement.getSubject(), salt); } @Override http://git-wip-us.apache.org/repos/asf/incubator-commonsrdf/blob/d043b075/rdf4j/src/main/java/org/apache/commons/rdf/rdf4j/package-info.java ---------------------------------------------------------------------- diff --git a/rdf4j/src/main/java/org/apache/commons/rdf/rdf4j/package-info.java b/rdf4j/src/main/java/org/apache/commons/rdf/rdf4j/package-info.java index a3928f3..f17a499 100644 --- a/rdf4j/src/main/java/org/apache/commons/rdf/rdf4j/package-info.java +++ b/rdf4j/src/main/java/org/apache/commons/rdf/rdf4j/package-info.java @@ -18,9 +18,9 @@ /** * Commons RDF integration with <a href="http://rdf4j.org/";>RDF4J</a>. * <p> - * Use the {@link org.apache.commons.rdf.rdf4j.RDF4JTermFactory} to convert + * Use the {@link org.apache.commons.rdf.rdf4j.RDF4JFactory} to convert * between Commons RDF and RDF4J types, for instance - * {@link org.apache.commons.rdf.rdf4j.RDF4JTermFactory#asQuad(org.eclipse.rdf4j.model.Statement)} + * {@link org.apache.commons.rdf.rdf4j.RDF4JFactory#asQuad(org.eclipse.rdf4j.model.Statement)} * converts a RDF4J {@link org.eclipse.rdf4j.model.Statement} to a * {@link org.apache.commons.rdf.api.Quad}. Converted RDF terms implement the * {@link org.apache.commons.rdf.rdf4j.RDF4JTerm} interface, and converted @@ -32,9 +32,9 @@ * {@link org.eclipse.rdf4j.repository.Repository} instances can be adapted to * Commons RDF {@link org.apache.commons.rdf.api.Graph} and * {@link org.apache.commons.rdf.api.Dataset}, e.g. using - * {@link org.apache.commons.rdf.rdf4j.RDF4JTermFactory#asRDFTermGraph(org.eclipse.rdf4j.model.Model)} + * {@link org.apache.commons.rdf.rdf4j.RDF4JFactory#asRDFTermGraph(org.eclipse.rdf4j.model.Model)} * or - * {@link org.apache.commons.rdf.rdf4j.RDF4JTermFactory#asRDFTermDataset(org.eclipse.rdf4j.repository.Repository, org.apache.commons.rdf.rdf4j.RDF4JTermFactory.Option...)} + * {@link org.apache.commons.rdf.rdf4j.RDF4JFactory#asRDFTermDataset(org.eclipse.rdf4j.repository.Repository, org.apache.commons.rdf.rdf4j.RDF4JFactory.Option...)} * The returned adapted graph/dataset is directly mapped, so changes are * propagated both ways. For convenience, the marker interface * {@link org.apache.commons.rdf.rdf4j.RDF4JGraph} and http://git-wip-us.apache.org/repos/asf/incubator-commonsrdf/blob/d043b075/rdf4j/src/test/java/org/apache/commons/rdf/rdf4j/BlankNodeTest.java ---------------------------------------------------------------------- diff --git a/rdf4j/src/test/java/org/apache/commons/rdf/rdf4j/BlankNodeTest.java b/rdf4j/src/test/java/org/apache/commons/rdf/rdf4j/BlankNodeTest.java index 09ae666..1da3c11 100644 --- a/rdf4j/src/test/java/org/apache/commons/rdf/rdf4j/BlankNodeTest.java +++ b/rdf4j/src/test/java/org/apache/commons/rdf/rdf4j/BlankNodeTest.java @@ -22,7 +22,7 @@ import org.apache.commons.rdf.api.BlankNode; public class BlankNodeTest extends AbstractBlankNodeTest { - RDF4JTermFactory factory = new RDF4JTermFactory(); + RDF4JFactory factory = new RDF4JFactory(); @Override protected BlankNode getBlankNode() { http://git-wip-us.apache.org/repos/asf/incubator-commonsrdf/blob/d043b075/rdf4j/src/test/java/org/apache/commons/rdf/rdf4j/GraphTest.java ---------------------------------------------------------------------- diff --git a/rdf4j/src/test/java/org/apache/commons/rdf/rdf4j/GraphTest.java b/rdf4j/src/test/java/org/apache/commons/rdf/rdf4j/GraphTest.java index 09ad421..07b60c2 100644 --- a/rdf4j/src/test/java/org/apache/commons/rdf/rdf4j/GraphTest.java +++ b/rdf4j/src/test/java/org/apache/commons/rdf/rdf4j/GraphTest.java @@ -24,7 +24,7 @@ public class GraphTest extends AbstractGraphTest{ @Override public RDFTermFactory createFactory() { - return new RDF4JTermFactory(); + return new RDF4JFactory(); } } http://git-wip-us.apache.org/repos/asf/incubator-commonsrdf/blob/d043b075/rdf4j/src/test/java/org/apache/commons/rdf/rdf4j/MemoryGraphTest.java ---------------------------------------------------------------------- diff --git a/rdf4j/src/test/java/org/apache/commons/rdf/rdf4j/MemoryGraphTest.java b/rdf4j/src/test/java/org/apache/commons/rdf/rdf4j/MemoryGraphTest.java index 3d99968..c275e67 100644 --- a/rdf4j/src/test/java/org/apache/commons/rdf/rdf4j/MemoryGraphTest.java +++ b/rdf4j/src/test/java/org/apache/commons/rdf/rdf4j/MemoryGraphTest.java @@ -35,7 +35,7 @@ public class MemoryGraphTest extends AbstractGraphTest { public static final class MemoryStoreFactory implements RDFTermFactory { - RDF4JTermFactory rdf4jFactory = new RDF4JTermFactory(new MemValueFactory()); + RDF4JFactory rdf4jFactory = new RDF4JFactory(new MemValueFactory()); public RDF4JBlankNode createBlankNode() { return rdf4jFactory.createBlankNode(); http://git-wip-us.apache.org/repos/asf/incubator-commonsrdf/blob/d043b075/rdf4j/src/test/java/org/apache/commons/rdf/rdf4j/NativeStoreGraphTest.java ---------------------------------------------------------------------- diff --git a/rdf4j/src/test/java/org/apache/commons/rdf/rdf4j/NativeStoreGraphTest.java b/rdf4j/src/test/java/org/apache/commons/rdf/rdf4j/NativeStoreGraphTest.java index 4d47e0c..77ee128 100644 --- a/rdf4j/src/test/java/org/apache/commons/rdf/rdf4j/NativeStoreGraphTest.java +++ b/rdf4j/src/test/java/org/apache/commons/rdf/rdf4j/NativeStoreGraphTest.java @@ -51,7 +51,7 @@ public class NativeStoreGraphTest extends AbstractGraphTest { public final class NativeStoreFactory implements RDFTermFactory { - RDF4JTermFactory rdf4jFactory = new RDF4JTermFactory(getRepository().getValueFactory()); + RDF4JFactory rdf4jFactory = new RDF4JFactory(getRepository().getValueFactory()); @Override public RDF4JGraph createGraph() { http://git-wip-us.apache.org/repos/asf/incubator-commonsrdf/blob/d043b075/rdf4j/src/test/java/org/apache/commons/rdf/rdf4j/Rdf4JRDFTermFactoryTest.java ---------------------------------------------------------------------- diff --git a/rdf4j/src/test/java/org/apache/commons/rdf/rdf4j/Rdf4JRDFTermFactoryTest.java b/rdf4j/src/test/java/org/apache/commons/rdf/rdf4j/Rdf4JRDFTermFactoryTest.java index bc06c62..9dbbf4b 100644 --- a/rdf4j/src/test/java/org/apache/commons/rdf/rdf4j/Rdf4JRDFTermFactoryTest.java +++ b/rdf4j/src/test/java/org/apache/commons/rdf/rdf4j/Rdf4JRDFTermFactoryTest.java @@ -25,7 +25,7 @@ public class Rdf4JRDFTermFactoryTest extends AbstractRDFTermFactoryTest { @Override public RDFTermFactory createFactory() { - return new RDF4JTermFactory(); + return new RDF4JFactory(); } @Override http://git-wip-us.apache.org/repos/asf/incubator-commonsrdf/blob/d043b075/src/site/markdown/implementations.md ---------------------------------------------------------------------- diff --git a/src/site/markdown/implementations.md b/src/site/markdown/implementations.md index 30235e1..0e4ab9b 100644 --- a/src/site/markdown/implementations.md +++ b/src/site/markdown/implementations.md @@ -131,20 +131,20 @@ The generalized triples/quads can be accessed as [org.apache.jena.graph.Triple]( ```java import org.apache.commons.rdf.api.Graph; import org.apache.commons.rdf.api.RDFTermFactory; -import org.apache.commons.rdf.rdf4j.RDF4JTermFactory; +import org.apache.commons.rdf.rdf4j.RDF4JFactory; -RDFTermFactory rdfTermFactory = new RDF4JTermFactory(); +RDFTermFactory rdfTermFactory = new RDF4JFactory(); Graph graph = rdfTermFactory.createGraph(); ``` -Objects created with [RDF4JTermFactory](apidocs/org/apache/commons/rdf/rdf4j/RDF4JTermFactory.html) implement interfaces like [RDF4JTerm](apidocs/org/apache/commons/rdf/rdf4j/RDF4JTerm.html) and [RDF4JGraph](apidocs/org/apache/commons/rdf/rdf4j/RDF4JGraph.html) which give access to the underlying Jena objects through methods like [asValue()](apidocs/org/apache/commons/rdf/rdf4j/RDF4JTerm.html#asValue--) and [asRepository()](apidocs/org/apache/commons/rdf/rdf4j/RDF4JGraphLike.html#asRepository--). +Objects created with [RDF4JFactory](apidocs/org/apache/commons/rdf/rdf4j/RDF4JFactory.html) implement interfaces like [RDF4JTerm](apidocs/org/apache/commons/rdf/rdf4j/RDF4JTerm.html) and [RDF4JGraph](apidocs/org/apache/commons/rdf/rdf4j/RDF4JGraph.html) which give access to the underlying Jena objects through methods like [asValue()](apidocs/org/apache/commons/rdf/rdf4j/RDF4JTerm.html#asValue--) and [asRepository()](apidocs/org/apache/commons/rdf/rdf4j/RDF4JGraphLike.html#asRepository--). -`RDF4JTermFactory` includes additional methods for converting from/to RDF4J and Commons RDF, like [asTriple(Statement)](apidocs/org/apache/commons/rdf/rdf4j/RDF4JTermFactory.html#asTriple-org.eclipse.rdf4j.model.Statement-) and -[asRDFTerm(Value)](apidocs/org/apache/commons/rdf/rdf4j/RDF4JTermFactory.html#asRDFTerm-org.eclipse.rdf4j.model.Value-). +`RDF4JFactory` includes additional methods for converting from/to RDF4J and Commons RDF, like [asTriple(Statement)](apidocs/org/apache/commons/rdf/rdf4j/RDF4JFactory.html#asTriple-org.eclipse.rdf4j.model.Statement-) and +[asRDFTerm(Value)](apidocs/org/apache/commons/rdf/rdf4j/RDF4JFactory.html#asRDFTerm-org.eclipse.rdf4j.model.Value-). #### Closing RDF4J resources -When using `RDF4JTermFactory` with an RDF4J `Repository`, e.g. from [asRDFTermGraph(Repository)](apidocs/org/apache/commons/rdf/rdf4j/RDF4JTermFactory.html#asRDFTermGraph-org.eclipse.rdf4j.repository.Repository-org.apache.commons.rdf.rdf4j.RDF4JTermFactory.Option...-), care must be taken to close underlying resources when using the methods [stream()](apidocs/org/apache/commons/rdf/rdf4j/RDF4JGraph.html#stream--) and [iterate()](apidocs/org/apache/commons/rdf/rdf4j/RDF4JGraph.html#iterate--) for both `Graph`s and `Dataset`s. +When using `RDF4JFactory` with an RDF4J `Repository`, e.g. from [asRDFTermGraph(Repository)](apidocs/org/apache/commons/rdf/rdf4j/RDF4JFactory.html#asRDFTermGraph-org.eclipse.rdf4j.repository.Repository-org.apache.commons.rdf.rdf4j.RDF4JFactory.Option...-), care must be taken to close underlying resources when using the methods [stream()](apidocs/org/apache/commons/rdf/rdf4j/RDF4JGraph.html#stream--) and [iterate()](apidocs/org/apache/commons/rdf/rdf4j/RDF4JGraph.html#iterate--) for both `Graph`s and `Dataset`s. This can generally achieved using a [try-with-resources](https://docs.oracle.com/javase/tutorial/essential/exceptions/tryResourceClose.html) block, e.g.:
