Merge branch 'master' into a
Project: http://git-wip-us.apache.org/repos/asf/incubator-commonsrdf/repo Commit: http://git-wip-us.apache.org/repos/asf/incubator-commonsrdf/commit/44b4b680 Tree: http://git-wip-us.apache.org/repos/asf/incubator-commonsrdf/tree/44b4b680 Diff: http://git-wip-us.apache.org/repos/asf/incubator-commonsrdf/diff/44b4b680 Branch: refs/heads/COMMONSRDF-46 Commit: 44b4b6808d19715006adcc075f749fd57345b965 Parents: 9c191fc 351c296 Author: Stian Soiland-Reyes <st...@apache.org> Authored: Sun Oct 23 03:16:39 2016 +0100 Committer: Stian Soiland-Reyes <st...@apache.org> Committed: Sun Oct 23 03:16:39 2016 +0100 ---------------------------------------------------------------------- .../org/apache/commons/rdf/rdf4j/RDF4J.java | 22 ++++++++++---------- .../apache/commons/rdf/rdf4j/RDF4JDataset.java | 2 +- .../apache/commons/rdf/rdf4j/RDF4JGraph.java | 8 +++---- .../rdf/rdf4j/impl/InternalRDF4JFactory.java | 2 +- .../apache/commons/rdf/rdf4j/package-info.java | 4 ++-- .../commons/rdf/rdf4j/MemoryGraphTest.java | 2 +- .../commons/rdf/rdf4j/NativeStoreGraphTest.java | 2 +- 7 files changed, 21 insertions(+), 21 deletions(-) ---------------------------------------------------------------------- http://git-wip-us.apache.org/repos/asf/incubator-commonsrdf/blob/44b4b680/rdf4j/src/main/java/org/apache/commons/rdf/rdf4j/RDF4J.java ---------------------------------------------------------------------- diff --cc rdf4j/src/main/java/org/apache/commons/rdf/rdf4j/RDF4J.java index fb5743b,0000000..7f70c75 mode 100644,000000..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 @@@ -1,603 -1,0 +1,603 @@@ +/** + * 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.RDF; +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 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 + * {@link #RDF4J(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 RDF4J} 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)}. ++ * To use other models, see {@link #asGraph(Model)}. + * <p> + * To adapt a RDF4J {@link Repository} as a {@link Dataset} or {@link Graph}, - * use {@link #asRDFTermDataset(Repository, Option...)} ++ * use {@link #asDataset(Repository, Option...)} + * or - * {@link #asRDFTermGraph(Repository, Option...)}. ++ * {@link #asGraph(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...)} ++ * {@link #asDataset(Repository, Option...)} + * and - * {@link #asRDFTermGraph(Repository, Option...)} ++ * {@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 asRDFTermDataset(Repository repository, Option... options) { ++ 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 asRDFTermGraph(Model model) { ++ 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 asRDFTermGraph(Repository repository, Option... options) { ++ 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 asRDFTermGraphUnion(Repository repository, Option... options) { ++ 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 asRDFTermGraph(Repository repository, Set<? extends BlankNodeOrIRI> contexts, ++ 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 asRDFTermGraph(new LinkedHashModel()); ++ 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/44b4b680/rdf4j/src/main/java/org/apache/commons/rdf/rdf4j/RDF4JDataset.java ---------------------------------------------------------------------- diff --cc rdf4j/src/main/java/org/apache/commons/rdf/rdf4j/RDF4JDataset.java index 28c2659,87803fa..fb54a09 --- 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 +30,8 @@@ import org.apache.commons.rdf.api.RDFTe /** * Marker interface for RDF4J implementations of Dataset. * - * @see RDF4JFactory#createDataset() - * @see RDF4JFactory#asDataset(org.eclipse.rdf4j.repository.Repository, org.apache.commons.rdf.rdf4j.RDF4JFactory.Option...) + * @see RDF4J#createDataset() - * @see RDF4J#asRDFTermDataset(org.eclipse.rdf4j.repository.Repository, org.apache.commons.rdf.rdf4j.RDF4J.Option...) ++ * @see RDF4J#asDataset(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/44b4b680/rdf4j/src/main/java/org/apache/commons/rdf/rdf4j/RDF4JGraph.java ---------------------------------------------------------------------- diff --cc rdf4j/src/main/java/org/apache/commons/rdf/rdf4j/RDF4JGraph.java index 68978ce,70edd3f..d1ab485 --- 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 +33,10 @@@ import org.eclipse.rdf4j.repository.Rep /** * Marker interface for RDF4J implementations of Graph. * - * @see RDF4JFactory#createGraph() - * @see RDF4JFactory#asGraph(Model) - * @see RDF4JFactory#asGraph(Repository, org.apache.commons.rdf.rdf4j.RDF4JFactory.Option...) - * @see RDF4JFactory#asGraphUnion(Repository, org.apache.commons.rdf.rdf4j.RDF4JFactory.Option...) + * @see RDF4J#createGraph() - * @see RDF4J#asRDFTermGraph(Model) - * @see RDF4J#asRDFTermGraph(Repository, org.apache.commons.rdf.rdf4j.RDF4J.Option...) - * @see RDF4J#asRDFTermGraphUnion(Repository, org.apache.commons.rdf.rdf4j.RDF4J.Option...) ++ * @see RDF4J#asGraph(Model) ++ * @see RDF4J#asGraph(Repository, org.apache.commons.rdf.rdf4j.RDF4JFactory.Option...) ++ * @see RDF4J#asGraphUnion(Repository, org.apache.commons.rdf.rdf4j.RDF4JFactory.Option...) * @see RDF4JDataset#getGraph() * @see RDF4JDataset#getGraph(BlankNodeOrIRI) */ @@@ -64,7 -64,7 +64,7 @@@ public interface RDF4JGraph extends Gra * 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#asRDFTermGraph(Repository, Set, org.apache.commons.rdf.rdf4j.RDF4J.Option...)} - * {@link RDF4JFactory#asGraph(Repository, Set, org.apache.commons.rdf.rdf4j.RDF4JFactory.Option...)} ++ * {@link RDF4J#asGraph(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/44b4b680/rdf4j/src/main/java/org/apache/commons/rdf/rdf4j/impl/InternalRDF4JFactory.java ---------------------------------------------------------------------- diff --cc rdf4j/src/main/java/org/apache/commons/rdf/rdf4j/impl/InternalRDF4JFactory.java index b1cd419,b43c15f..ca97472 --- 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 @@@ -42,10 -42,10 +42,10 @@@ import org.eclipse.rdf4j.repository.Rep * <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 RDF4JFactory} methods like - * {@link RDF4JFactory#createBlankNode()}, - * {@link RDF4JFactory#asRDFTerm(org.eclipse.rdf4j.model.Value)} and - * {@link RDF4JFactory#asGraph(Repository, org.apache.commons.rdf.rdf4j.RDF4JFactory.Option...)} + * {@link RDF4J} methods like + * {@link RDF4J#createBlankNode()}, + * {@link RDF4J#asRDFTerm(org.eclipse.rdf4j.model.Value)} and - * {@link RDF4J#asRDFTermGraph(Repository, org.apache.commons.rdf.rdf4j.RDF4J.Option...)} ++ * {@link RDF4J#asGraph(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 http://git-wip-us.apache.org/repos/asf/incubator-commonsrdf/blob/44b4b680/rdf4j/src/main/java/org/apache/commons/rdf/rdf4j/package-info.java ---------------------------------------------------------------------- diff --cc rdf4j/src/main/java/org/apache/commons/rdf/rdf4j/package-info.java index 51556bc,1d5e677..dbccdb3 --- 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 @@@ -32,9 -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.RDF4J#asRDFTermGraph(org.eclipse.rdf4j.model.Model)} - * {@link org.apache.commons.rdf.rdf4j.RDF4JFactory#asGraph(org.eclipse.rdf4j.model.Model)} ++ * {@link org.apache.commons.rdf.rdf4j.RDF4J#asGraph(org.eclipse.rdf4j.model.Model)} * or - * {@link org.apache.commons.rdf.rdf4j.RDF4J#asRDFTermDataset(org.eclipse.rdf4j.repository.Repository, org.apache.commons.rdf.rdf4j.RDF4J.Option...)} - * {@link org.apache.commons.rdf.rdf4j.RDF4JFactory#asDataset(org.eclipse.rdf4j.repository.Repository, org.apache.commons.rdf.rdf4j.RDF4JFactory.Option...)} ++ * {@link org.apache.commons.rdf.rdf4j.RDF4J#asDataset(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/44b4b680/rdf4j/src/test/java/org/apache/commons/rdf/rdf4j/MemoryGraphTest.java ---------------------------------------------------------------------- http://git-wip-us.apache.org/repos/asf/incubator-commonsrdf/blob/44b4b680/rdf4j/src/test/java/org/apache/commons/rdf/rdf4j/NativeStoreGraphTest.java ---------------------------------------------------------------------- diff --cc rdf4j/src/test/java/org/apache/commons/rdf/rdf4j/NativeStoreGraphTest.java index 3697069,ccabf72..7e43068 --- a/rdf4j/src/test/java/org/apache/commons/rdf/rdf4j/NativeStoreGraphTest.java +++ b/rdf4j/src/test/java/org/apache/commons/rdf/rdf4j/NativeStoreGraphTest.java @@@ -59,15 -57,9 +59,15 @@@ public class NativeStoreGraphTest exten public RDF4JGraph createGraph() { // We re-use the repository connection, but use a different context every time Set<RDF4JBlankNode> context = Collections.singleton(rdf4jFactory.createBlankNode()); - return rdf4jFactory.asRDFTermGraph(getRepository(), context); + return rdf4jFactory.asGraph(getRepository(), context); } - + @Override + public Dataset createDataset() { + throw new UnsupportedOperationException("Can't create more than one Dataset in this test"); + // ...as the below would re-use the same repository: + //return rdf4jFactory.asRDFTermDataset(getRepository()); + } + // Delegate methods public RDF4JBlankNode createBlankNode() { return rdf4jFactory.createBlankNode();
