http://git-wip-us.apache.org/repos/asf/incubator-commonsrdf/blob/413dd09a/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 37487b4..2398194 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 @@ -28,49 +28,48 @@ import org.eclipse.rdf4j.model.Statement; import org.eclipse.rdf4j.repository.Repository; import org.eclipse.rdf4j.repository.RepositoryConnection; -abstract class AbstractRepositoryGraphLike<T extends TripleLike> - implements RDF4JGraphLike<T> { +abstract class AbstractRepositoryGraphLike<T extends TripleLike> implements RDF4JGraphLike<T> { - protected final Repository repository; - protected final boolean includeInferred; - protected final boolean handleInitAndShutdown; - protected final RDF4J rdf4jTermFactory; - protected final UUID salt; + protected final Repository repository; + protected final boolean includeInferred; + protected final boolean handleInitAndShutdown; + protected final RDF4J rdf4jTermFactory; + protected final UUID salt; - AbstractRepositoryGraphLike(Repository repository, UUID salt, boolean handleInitAndShutdown, boolean includeInferred) { - this.repository = repository; - this.salt = salt; - this.includeInferred = includeInferred; - this.handleInitAndShutdown = handleInitAndShutdown; - if (handleInitAndShutdown && !repository.isInitialized()) { - repository.initialize(); - } - rdf4jTermFactory = new RDF4J(repository.getValueFactory(), salt); - } - - @Override - public void close() throws Exception { - if (handleInitAndShutdown) { - repository.shutDown(); - } - // else: repository was initialized outside, so we should not shut it - // down - } + AbstractRepositoryGraphLike(Repository repository, UUID salt, boolean handleInitAndShutdown, + boolean includeInferred) { + this.repository = repository; + this.salt = salt; + this.includeInferred = includeInferred; + this.handleInitAndShutdown = handleInitAndShutdown; + if (handleInitAndShutdown && !repository.isInitialized()) { + repository.initialize(); + } + rdf4jTermFactory = new RDF4J(repository.getValueFactory(), salt); + } - - protected abstract T asTripleLike(Statement s); + @Override + public void close() throws Exception { + if (handleInitAndShutdown) { + repository.shutDown(); + } + // else: repository was initialized outside, so we should not shut it + // down + } - protected RepositoryConnection getRepositoryConnection() { - return repository.getConnection(); - } + protected abstract T asTripleLike(Statement s); - public Optional<Repository> asRepository() { - return Optional.of(repository); - } + protected RepositoryConnection getRepositoryConnection() { + return repository.getConnection(); + } - @Override - public Optional<Model> asModel() { - return Optional.empty(); - } + public Optional<Repository> asRepository() { + return Optional.of(repository); + } + + @Override + public Optional<Model> asModel() { + return Optional.empty(); + } }
http://git-wip-us.apache.org/repos/asf/incubator-commonsrdf/blob/413dd09a/rdf4j/src/main/java/org/apache/commons/rdf/rdf4j/impl/BlankNodeImpl.java ---------------------------------------------------------------------- diff --git a/rdf4j/src/main/java/org/apache/commons/rdf/rdf4j/impl/BlankNodeImpl.java b/rdf4j/src/main/java/org/apache/commons/rdf/rdf4j/impl/BlankNodeImpl.java index bdb82d1..8c5fc30 100644 --- a/rdf4j/src/main/java/org/apache/commons/rdf/rdf4j/impl/BlankNodeImpl.java +++ b/rdf4j/src/main/java/org/apache/commons/rdf/rdf4j/impl/BlankNodeImpl.java @@ -25,69 +25,68 @@ import org.apache.commons.rdf.rdf4j.RDF4JBlankNode; import org.eclipse.rdf4j.model.BNode; import org.eclipse.rdf4j.rio.turtle.TurtleUtil; -final class BlankNodeImpl extends AbstractRDFTerm<BNode> - implements RDF4JBlankNode { - - private transient int hashCode = 0; - private long saltUUIDleast; - private long saltUUIDmost; - - BlankNodeImpl(BNode bNode, UUID salt) { - super(bNode); - // Space-efficient storage of salt UUID - saltUUIDmost = salt.getMostSignificantBits(); - saltUUIDleast = salt.getLeastSignificantBits(); - } - - public boolean equals(Object obj) { - if (obj == this) { - return true; - } - // NOTE: Do NOT use Bnode.equals() as it has a more generous - // equality based only on the value.getID(); - if (obj instanceof BlankNode) { - BlankNode blankNode = (BlankNode) obj; - return uniqueReference().equals(blankNode.uniqueReference()); - } - return false; - } +final class BlankNodeImpl extends AbstractRDFTerm<BNode> implements RDF4JBlankNode { - @Override - public int hashCode() { - if (hashCode != 0) { - return hashCode; - } - return hashCode = uniqueReference().hashCode(); - } + private transient int hashCode = 0; + private long saltUUIDleast; + private long saltUUIDmost; - private boolean isValidBlankNodeLabel(String id) { - // FIXME: Replace with a regular expression? - if (id.isEmpty()) { - return false; - } - if (! TurtleUtil.isBLANK_NODE_LABEL_StartChar(id.codePointAt(0))) { - return false; - } - for (int i=1; i<id.length(); i++) { - if (! TurtleUtil.isBLANK_NODE_LABEL_Char(id.codePointAt(i))) { - return false; - } - } - return true; - } + BlankNodeImpl(BNode bNode, UUID salt) { + super(bNode); + // Space-efficient storage of salt UUID + saltUUIDmost = salt.getMostSignificantBits(); + saltUUIDleast = salt.getLeastSignificantBits(); + } - @Override - public String ntriplesString() { - if (isValidBlankNodeLabel(value.getID())) { - return "_:" + value.getID(); - } else { - return "_:" + UUID.nameUUIDFromBytes(value.getID().getBytes(StandardCharsets.UTF_8)); - } - } + public boolean equals(Object obj) { + if (obj == this) { + return true; + } + // NOTE: Do NOT use Bnode.equals() as it has a more generous + // equality based only on the value.getID(); + if (obj instanceof BlankNode) { + BlankNode blankNode = (BlankNode) obj; + return uniqueReference().equals(blankNode.uniqueReference()); + } + return false; + } - @Override - public String uniqueReference() { - UUID uuid = new UUID(saltUUIDmost, saltUUIDleast); - return "urn:uuid:" + uuid + "#" + value.getID(); - } + @Override + public int hashCode() { + if (hashCode != 0) { + return hashCode; + } + return hashCode = uniqueReference().hashCode(); + } + + private boolean isValidBlankNodeLabel(String id) { + // FIXME: Replace with a regular expression? + if (id.isEmpty()) { + return false; + } + if (!TurtleUtil.isBLANK_NODE_LABEL_StartChar(id.codePointAt(0))) { + return false; + } + for (int i = 1; i < id.length(); i++) { + if (!TurtleUtil.isBLANK_NODE_LABEL_Char(id.codePointAt(i))) { + return false; + } + } + return true; + } + + @Override + public String ntriplesString() { + if (isValidBlankNodeLabel(value.getID())) { + return "_:" + value.getID(); + } else { + return "_:" + UUID.nameUUIDFromBytes(value.getID().getBytes(StandardCharsets.UTF_8)); + } + } + + @Override + public String uniqueReference() { + UUID uuid = new UUID(saltUUIDmost, saltUUIDleast); + return "urn:uuid:" + uuid + "#" + value.getID(); + } } \ No newline at end of file http://git-wip-us.apache.org/repos/asf/incubator-commonsrdf/blob/413dd09a/rdf4j/src/main/java/org/apache/commons/rdf/rdf4j/impl/ConvertedStatements.java ---------------------------------------------------------------------- diff --git a/rdf4j/src/main/java/org/apache/commons/rdf/rdf4j/impl/ConvertedStatements.java b/rdf4j/src/main/java/org/apache/commons/rdf/rdf4j/impl/ConvertedStatements.java index 4c8478a..f199b8f 100644 --- a/rdf4j/src/main/java/org/apache/commons/rdf/rdf4j/impl/ConvertedStatements.java +++ b/rdf4j/src/main/java/org/apache/commons/rdf/rdf4j/impl/ConvertedStatements.java @@ -29,43 +29,43 @@ import org.eclipse.rdf4j.repository.RepositoryConnection; import org.eclipse.rdf4j.repository.RepositoryResult; final class ConvertedStatements<T> implements ClosableIterable<T> { - - private RepositoryConnection conn; - private RepositoryResult<Statement> results; - private Function<Statement, T> statementAdapter; - ConvertedStatements(Supplier<RepositoryConnection> repositoryConnector, Function<Statement, T> statementAdapter, - Resource subj, org.eclipse.rdf4j.model.IRI pred, Value obj, Resource... contexts) { - this.statementAdapter = statementAdapter; - this.conn = repositoryConnector.get(); - this.results = conn.getStatements(subj, pred, obj, contexts); - } + private RepositoryConnection conn; + private RepositoryResult<Statement> results; + private Function<Statement, T> statementAdapter; - @Override - public Iterator<T> iterator() { - return new ConvertedIterator(); - } + ConvertedStatements(Supplier<RepositoryConnection> repositoryConnector, Function<Statement, T> statementAdapter, + Resource subj, org.eclipse.rdf4j.model.IRI pred, Value obj, Resource... contexts) { + this.statementAdapter = statementAdapter; + this.conn = repositoryConnector.get(); + this.results = conn.getStatements(subj, pred, obj, contexts); + } - @Override - public void close() { - results.close(); - conn.close(); - } + @Override + public Iterator<T> iterator() { + return new ConvertedIterator(); + } - private final class ConvertedIterator implements Iterator<T> { - @Override - public boolean hasNext() { - boolean hasNext = results.hasNext(); - if (!hasNext) { - close(); - } - return hasNext; - } + @Override + public void close() { + results.close(); + conn.close(); + } - @Override - public T next() { - return statementAdapter.apply(results.next()); - } - } + private final class ConvertedIterator implements Iterator<T> { + @Override + public boolean hasNext() { + boolean hasNext = results.hasNext(); + if (!hasNext) { + close(); + } + return hasNext; + } + + @Override + public T next() { + return statementAdapter.apply(results.next()); + } + } } \ No newline at end of file http://git-wip-us.apache.org/repos/asf/incubator-commonsrdf/blob/413dd09a/rdf4j/src/main/java/org/apache/commons/rdf/rdf4j/impl/IRIImpl.java ---------------------------------------------------------------------- diff --git a/rdf4j/src/main/java/org/apache/commons/rdf/rdf4j/impl/IRIImpl.java b/rdf4j/src/main/java/org/apache/commons/rdf/rdf4j/impl/IRIImpl.java index e88ac27..f566c21 100644 --- a/rdf4j/src/main/java/org/apache/commons/rdf/rdf4j/impl/IRIImpl.java +++ b/rdf4j/src/main/java/org/apache/commons/rdf/rdf4j/impl/IRIImpl.java @@ -19,43 +19,46 @@ package org.apache.commons.rdf.rdf4j.impl; import org.apache.commons.rdf.rdf4j.RDF4JIRI; -final class IRIImpl extends AbstractRDFTerm<org.eclipse.rdf4j.model.IRI> - implements RDF4JIRI { - - IRIImpl(org.eclipse.rdf4j.model.IRI iri) { - super(iri); - } - @Override - public boolean equals(Object obj) { - if (obj == this) { return true; } - if (obj instanceof IRIImpl) { - IRIImpl impl = (IRIImpl) obj; - return asValue().equals(impl.asValue()); - } - if (obj instanceof org.apache.commons.rdf.api.IRI) { - org.apache.commons.rdf.api.IRI iri = (org.apache.commons.rdf.api.IRI) obj; - return value.toString().equals(iri.getIRIString()); - } - return false; - } - - @Override - public String getIRIString() { - return value.toString(); - } - - public int hashCode() { - // Same definition - return value.hashCode(); - } - - @Override - public String ntriplesString() { - return "<" + value.toString() + ">"; - } - @Override - public String toString() { - return value.toString(); - } - +final class IRIImpl extends AbstractRDFTerm<org.eclipse.rdf4j.model.IRI> implements RDF4JIRI { + + IRIImpl(org.eclipse.rdf4j.model.IRI iri) { + super(iri); + } + + @Override + public boolean equals(Object obj) { + if (obj == this) { + return true; + } + if (obj instanceof IRIImpl) { + IRIImpl impl = (IRIImpl) obj; + return asValue().equals(impl.asValue()); + } + if (obj instanceof org.apache.commons.rdf.api.IRI) { + org.apache.commons.rdf.api.IRI iri = (org.apache.commons.rdf.api.IRI) obj; + return value.toString().equals(iri.getIRIString()); + } + return false; + } + + @Override + public String getIRIString() { + return value.toString(); + } + + public int hashCode() { + // Same definition + return value.hashCode(); + } + + @Override + public String ntriplesString() { + return "<" + value.toString() + ">"; + } + + @Override + public String toString() { + return value.toString(); + } + } \ No newline at end of file http://git-wip-us.apache.org/repos/asf/incubator-commonsrdf/blob/413dd09a/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 b6d6b29..25a7620 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 @@ -43,8 +43,7 @@ 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 RDF4J} methods like - * {@link RDF4J#createBlankNode()}, + * {@link RDF4J} methods like {@link RDF4J#createBlankNode()}, * {@link RDF4J#asRDFTerm(org.eclipse.rdf4j.model.Value)} and * {@link RDF4J#asGraph(Repository, Option...)} * <p> @@ -57,128 +56,129 @@ import org.eclipse.rdf4j.repository.Repository; */ public abstract class InternalRDF4JFactory { - /** - * Construct a {@link RDF4JBlankNode} from a RDF4J {@link BNode}. - * - * @param bNode - * RDF4J {@link BNode} to adapt - * @param salt - * {@link UUID} to use for {@link BlankNode#uniqueReference()} in - * combination with {@link BNode#getID()} - * @return Adapted {@link RDF4JBlankNode} - */ - public RDF4JBlankNode createBlankNodeImpl(BNode bNode, UUID salt) { - return new BlankNodeImpl(bNode, salt); - } + /** + * Construct a {@link RDF4JBlankNode} from a RDF4J {@link BNode}. + * + * @param bNode + * RDF4J {@link BNode} to adapt + * @param salt + * {@link UUID} to use for {@link BlankNode#uniqueReference()} in + * combination with {@link BNode#getID()} + * @return Adapted {@link RDF4JBlankNode} + */ + public RDF4JBlankNode createBlankNodeImpl(BNode bNode, UUID salt) { + return new BlankNodeImpl(bNode, salt); + } - /** - * Construct a {@link RDF4JIRI} from a RDF4J {@link IRI}. - * - * @param iri - * RDF4J {@link IRI} to adapt - * @return Adapted {@link RDF4JIRI} - */ - public RDF4JIRI createIRIImpl(IRI iri) { - return new IRIImpl(iri); - } + /** + * Construct a {@link RDF4JIRI} from a RDF4J {@link IRI}. + * + * @param iri + * RDF4J {@link IRI} to adapt + * @return Adapted {@link RDF4JIRI} + */ + public RDF4JIRI createIRIImpl(IRI iri) { + return new IRIImpl(iri); + } - /** - * Construct a {@link RDF4JLiteral} from a RDF4J {@link Literal}. - * - * @param literal - * RDF4J {@link Literal} - * @return Adapted {@link RDF4JLiteral} - */ - public RDF4JLiteral createLiteralImpl(Literal literal) { - return new LiteralImpl(literal); - } + /** + * Construct a {@link RDF4JLiteral} from a RDF4J {@link Literal}. + * + * @param literal + * RDF4J {@link Literal} + * @return Adapted {@link RDF4JLiteral} + */ + public RDF4JLiteral createLiteralImpl(Literal literal) { + return new LiteralImpl(literal); + } - /** - * Construct a {@link RDF4JGraph} from a RDF4J {@link Model}. - * <p> - * Changes in the graph will be reflected in the model, and vice versa. - * - * @param model - * RDF4J {@link Model} to adapt - * @param rdf4jTermFactory - * factory to use for adapting graph triples - * @return Adapted {@link RDF4JGraph} - */ - public RDF4JGraph createModelGraphImpl(Model model, RDF4J rdf4jTermFactory) { - return new ModelGraphImpl(model, rdf4jTermFactory); - } + /** + * Construct a {@link RDF4JGraph} from a RDF4J {@link Model}. + * <p> + * Changes in the graph will be reflected in the model, and vice versa. + * + * @param model + * RDF4J {@link Model} to adapt + * @param rdf4jTermFactory + * factory to use for adapting graph triples + * @return Adapted {@link RDF4JGraph} + */ + public RDF4JGraph createModelGraphImpl(Model model, RDF4J rdf4jTermFactory) { + return new ModelGraphImpl(model, rdf4jTermFactory); + } - /** - * Construct a {@link RDF4JQuad} from a RDF4J {@link Statement}. - * - * @param statement - * RDF4J {@link Statement} to adapt - * @param salt - * {@link UUID} for adapting any {@link BNode}s - * @return Adapted {@link RDF4JQuad} - */ - public RDF4JQuad createQuadImpl(Statement statement, UUID salt) { - return new QuadImpl(statement, salt); - } + /** + * Construct a {@link RDF4JQuad} from a RDF4J {@link Statement}. + * + * @param statement + * RDF4J {@link Statement} to adapt + * @param salt + * {@link UUID} for adapting any {@link BNode}s + * @return Adapted {@link RDF4JQuad} + */ + public RDF4JQuad createQuadImpl(Statement statement, UUID salt) { + return new QuadImpl(statement, salt); + } - /** - * Construct a {@link RDF4JDataset} from a RDF4J {@link Repository}. - * <p> - * Changes in the dataset will be reflected in the repsitory, and vice - * versa. - * - * @param repository - * RDF4J {@link Repository} to adapt - * @param handleInitAndShutdown - * If <code>true</code>, the {@link RDF4JDataset} will initialize - * the repository (if needed), and shut it down on - * {@link RDF4JDataset#close()}. - * @param includeInferred - * If true, any inferred quads are included in the dataset - * - * @return Adapted {@link RDF4JDataset} - */ - public RDF4JDataset createRepositoryDatasetImpl(Repository repository, boolean handleInitAndShutdown, - boolean includeInferred) { - return new RepositoryDatasetImpl(repository, UUID.randomUUID(), handleInitAndShutdown, includeInferred); - } + /** + * Construct a {@link RDF4JDataset} from a RDF4J {@link Repository}. + * <p> + * Changes in the dataset will be reflected in the repsitory, and vice + * versa. + * + * @param repository + * RDF4J {@link Repository} to adapt + * @param handleInitAndShutdown + * If <code>true</code>, the {@link RDF4JDataset} will initialize + * the repository (if needed), and shut it down on + * {@link RDF4JDataset#close()}. + * @param includeInferred + * If true, any inferred quads are included in the dataset + * + * @return Adapted {@link RDF4JDataset} + */ + public RDF4JDataset createRepositoryDatasetImpl(Repository repository, boolean handleInitAndShutdown, + boolean includeInferred) { + return new RepositoryDatasetImpl(repository, UUID.randomUUID(), handleInitAndShutdown, includeInferred); + } - /** - * Construct a {@link RDF4JGraph} from a RDF4J {@link Model}. - * <p> - * Changes in the graph will be reflected in the model, and vice versa. - * - * @param repository - * RDF4J {@link Repository} to adapt - * @param handleInitAndShutdown - * If <code>true</code>, the {@link RDF4JGraph} will initialize - * the repository (if needed), and shut it down on - * {@link RDF4JGraph#close()}. - * @param includeInferred - * If true, any inferred quads are included in the dataset - * @param contextMask - * Zero or more {@link Resource}s contexts. The array may contain - * the value <code>null</code> for the default graph - however - * care must be taken to not provide a null-array - * <code>(Resource[]) null</code>. - * @return Adapted {@link RDF4JGraph} - */ - public RDF4JGraph createRepositoryGraphImpl(Repository repository, boolean handleInitAndShutdown, - boolean includeInferred, Resource... contextMask) { - return new RepositoryGraphImpl(repository, UUID.randomUUID(), handleInitAndShutdown, includeInferred, contextMask); - } + /** + * Construct a {@link RDF4JGraph} from a RDF4J {@link Model}. + * <p> + * Changes in the graph will be reflected in the model, and vice versa. + * + * @param repository + * RDF4J {@link Repository} to adapt + * @param handleInitAndShutdown + * If <code>true</code>, the {@link RDF4JGraph} will initialize + * the repository (if needed), and shut it down on + * {@link RDF4JGraph#close()}. + * @param includeInferred + * If true, any inferred quads are included in the dataset + * @param contextMask + * Zero or more {@link Resource}s contexts. The array may contain + * the value <code>null</code> for the default graph - however + * care must be taken to not provide a null-array + * <code>(Resource[]) null</code>. + * @return Adapted {@link RDF4JGraph} + */ + public RDF4JGraph createRepositoryGraphImpl(Repository repository, boolean handleInitAndShutdown, + boolean includeInferred, Resource... contextMask) { + return new RepositoryGraphImpl(repository, UUID.randomUUID(), handleInitAndShutdown, includeInferred, + contextMask); + } - /** - * Construct a {@link RDF4JTriple} from a RDF4J {@link Statement}. - * - * @param statement - * RDF4J {@link Statement} to adapt - * @param salt - * {@link UUID} for adapting any {@link BNode}s - * @return Adapted {@link RDF4JTriple} - */ - public RDF4JTriple createTripleImpl(Statement statement, UUID salt) { - return new TripleImpl(statement, salt); - } + /** + * Construct a {@link RDF4JTriple} from a RDF4J {@link Statement}. + * + * @param statement + * RDF4J {@link Statement} to adapt + * @param salt + * {@link UUID} for adapting any {@link BNode}s + * @return Adapted {@link RDF4JTriple} + */ + public RDF4JTriple createTripleImpl(Statement statement, UUID salt) { + return new TripleImpl(statement, salt); + } } http://git-wip-us.apache.org/repos/asf/incubator-commonsrdf/blob/413dd09a/rdf4j/src/main/java/org/apache/commons/rdf/rdf4j/impl/LiteralImpl.java ---------------------------------------------------------------------- diff --git a/rdf4j/src/main/java/org/apache/commons/rdf/rdf4j/impl/LiteralImpl.java b/rdf4j/src/main/java/org/apache/commons/rdf/rdf4j/impl/LiteralImpl.java index aef298d..9fa93b1 100644 --- a/rdf4j/src/main/java/org/apache/commons/rdf/rdf4j/impl/LiteralImpl.java +++ b/rdf4j/src/main/java/org/apache/commons/rdf/rdf4j/impl/LiteralImpl.java @@ -24,62 +24,62 @@ import org.apache.commons.rdf.rdf4j.RDF4JLiteral; import org.eclipse.rdf4j.model.vocabulary.XMLSchema; import org.eclipse.rdf4j.rio.turtle.TurtleUtil; -final class LiteralImpl - extends AbstractRDFTerm<org.eclipse.rdf4j.model.Literal> - implements RDF4JLiteral { +final class LiteralImpl extends AbstractRDFTerm<org.eclipse.rdf4j.model.Literal> implements RDF4JLiteral { - private static final String QUOTE = "\""; - - LiteralImpl(org.eclipse.rdf4j.model.Literal literal) { - super(literal); - } - @Override - public boolean equals(Object obj) { - if (obj == this) { return true; } - if (obj instanceof org.apache.commons.rdf.api.Literal) { - org.apache.commons.rdf.api.Literal other = (org.apache.commons.rdf.api.Literal) obj; - return getLexicalForm().equals(other.getLexicalForm()) && - getDatatype().equals(other.getDatatype()) && - getLanguageTag().equals(other.getLanguageTag()); - - } - return false; - } + private static final String QUOTE = "\""; - @Override - public org.apache.commons.rdf.api.IRI getDatatype() { - return new IRIImpl(value.getDatatype()); - } + LiteralImpl(org.eclipse.rdf4j.model.Literal literal) { + super(literal); + } - @Override - public Optional<String> getLanguageTag() { - return value.getLanguage(); - } + @Override + public boolean equals(Object obj) { + if (obj == this) { + return true; + } + if (obj instanceof org.apache.commons.rdf.api.Literal) { + org.apache.commons.rdf.api.Literal other = (org.apache.commons.rdf.api.Literal) obj; + return getLexicalForm().equals(other.getLexicalForm()) && getDatatype().equals(other.getDatatype()) + && getLanguageTag().equals(other.getLanguageTag()); - @Override - public String getLexicalForm() { - return value.getLabel(); - } + } + return false; + } - public int hashCode() { - return Objects.hash(value.getLabel(), value.getDatatype(), value.getLanguage()); - } + @Override + public org.apache.commons.rdf.api.IRI getDatatype() { + return new IRIImpl(value.getDatatype()); + } - @Override - public String ntriplesString() { - // TODO: Use a more efficient StringBuffer - String escaped = QUOTE + TurtleUtil.encodeString(value.getLabel()) + QUOTE; - if (value.getLanguage().isPresent()) { - return escaped + "@" + value.getLanguage().get(); - } - if (value.getDatatype().equals(XMLSchema.STRING)) { - return escaped; - } - return escaped + "^^<" + TurtleUtil.encodeURIString(value.getDatatype().toString()) + ">"; - } + @Override + public Optional<String> getLanguageTag() { + return value.getLanguage(); + } - @Override - public String toString() { - return ntriplesString(); - } + @Override + public String getLexicalForm() { + return value.getLabel(); + } + + public int hashCode() { + return Objects.hash(value.getLabel(), value.getDatatype(), value.getLanguage()); + } + + @Override + public String ntriplesString() { + // TODO: Use a more efficient StringBuffer + String escaped = QUOTE + TurtleUtil.encodeString(value.getLabel()) + QUOTE; + if (value.getLanguage().isPresent()) { + return escaped + "@" + value.getLanguage().get(); + } + if (value.getDatatype().equals(XMLSchema.STRING)) { + return escaped; + } + return escaped + "^^<" + TurtleUtil.encodeURIString(value.getDatatype().toString()) + ">"; + } + + @Override + public String toString() { + return ntriplesString(); + } } \ No newline at end of file http://git-wip-us.apache.org/repos/asf/incubator-commonsrdf/blob/413dd09a/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 ced9c99..7debacc 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 @@ -38,121 +38,115 @@ import org.eclipse.rdf4j.model.Resource; import org.eclipse.rdf4j.repository.Repository; final class ModelGraphImpl implements RDF4JGraph { - - private Model model; - private RDF4J rdf4jTermFactory; - - ModelGraphImpl(Model model, RDF4J rdf4jTermFactory) { - this.model = model; - this.rdf4jTermFactory = rdf4jTermFactory; - } - - @Override - public void add(BlankNodeOrIRI subject, org.apache.commons.rdf.api.IRI predicate, RDFTerm object) { - model.add( - (Resource)rdf4jTermFactory.asValue(subject), - (org.eclipse.rdf4j.model.IRI)rdf4jTermFactory.asValue(predicate), - rdf4jTermFactory.asValue(object)); - } - - @Override - public void add(Triple triple) { - model.add(rdf4jTermFactory.asStatement(triple)); - } - - public Optional<Model> asModel() { - return Optional.of(model); - } - - @Override - public Optional<Repository> asRepository() { - return Optional.empty(); - } - - @Override - public void clear() { - model.clear(); - } - - @Override - public boolean contains(BlankNodeOrIRI subject, org.apache.commons.rdf.api.IRI predicate, RDFTerm object) { - return model.contains( - (Resource)rdf4jTermFactory.asValue(subject), - (org.eclipse.rdf4j.model.IRI)rdf4jTermFactory.asValue(predicate), - rdf4jTermFactory.asValue(object)); - } - - @Override - public boolean contains(Triple triple) { - return model.contains(rdf4jTermFactory.asStatement(triple)); - } - - @Override - public void remove(BlankNodeOrIRI subject, org.apache.commons.rdf.api.IRI predicate, RDFTerm object) { - model.remove( - (Resource)rdf4jTermFactory.asValue(subject), - (org.eclipse.rdf4j.model.IRI)rdf4jTermFactory.asValue(predicate), - rdf4jTermFactory.asValue(object)); - } - - @Override - public void remove(Triple triple) { - model.remove(rdf4jTermFactory.asStatement(triple)); - } - - @Override - public long size() { - int size = model.size(); - if (size < Integer.MAX_VALUE) { - return size; - } else { - // TODO: Check if this can really happen with RDF4J models - // Collection.size() can't help us, we'll have to count - return model.parallelStream().count(); - } - } - - @Override - public Stream<RDF4JTriple> stream() { - return model.parallelStream().map(rdf4jTermFactory::asTriple); - } - - @Override - public Stream<RDF4JTriple> stream(BlankNodeOrIRI subject, org.apache.commons.rdf.api.IRI predicate, RDFTerm object) { - return model.filter( - (Resource)rdf4jTermFactory.asValue(subject), - (org.eclipse.rdf4j.model.IRI)rdf4jTermFactory.asValue(predicate), - rdf4jTermFactory.asValue(object)).parallelStream() - .map(rdf4jTermFactory::asTriple); - } - - @Override - public Set<RDF4JBlankNodeOrIRI> getContextMask() { - // ModelGraph always do the unionGraph - return Collections.emptySet(); - // TODO: Should we support contextMask like in RepositoryGraphImpl? - } - - @Override - public ClosableIterable<Triple> iterate(BlankNodeOrIRI subject, IRI predicate, RDFTerm object) { - return new ClosableIterable<Triple>() { - @SuppressWarnings("unchecked") - @Override - public Iterator<Triple> iterator() { - // double-cast to fight Java generics.. - Stream<? extends Triple> s = stream(subject, predicate, object); - return (Iterator<Triple>) s.iterator(); - } - @Override - public void close() throws Exception { - // no-op as Model don't have transaction - } - }; - } - - @Override - public ClosableIterable<Triple> iterate() throws ConcurrentModificationException, IllegalStateException { - return iterate(null, null, null); - } - + + private Model model; + private RDF4J rdf4jTermFactory; + + ModelGraphImpl(Model model, RDF4J rdf4jTermFactory) { + this.model = model; + this.rdf4jTermFactory = rdf4jTermFactory; + } + + @Override + public void add(BlankNodeOrIRI subject, org.apache.commons.rdf.api.IRI predicate, RDFTerm object) { + model.add((Resource) rdf4jTermFactory.asValue(subject), + (org.eclipse.rdf4j.model.IRI) rdf4jTermFactory.asValue(predicate), rdf4jTermFactory.asValue(object)); + } + + @Override + public void add(Triple triple) { + model.add(rdf4jTermFactory.asStatement(triple)); + } + + public Optional<Model> asModel() { + return Optional.of(model); + } + + @Override + public Optional<Repository> asRepository() { + return Optional.empty(); + } + + @Override + public void clear() { + model.clear(); + } + + @Override + public boolean contains(BlankNodeOrIRI subject, org.apache.commons.rdf.api.IRI predicate, RDFTerm object) { + return model.contains((Resource) rdf4jTermFactory.asValue(subject), + (org.eclipse.rdf4j.model.IRI) rdf4jTermFactory.asValue(predicate), rdf4jTermFactory.asValue(object)); + } + + @Override + public boolean contains(Triple triple) { + return model.contains(rdf4jTermFactory.asStatement(triple)); + } + + @Override + public void remove(BlankNodeOrIRI subject, org.apache.commons.rdf.api.IRI predicate, RDFTerm object) { + model.remove((Resource) rdf4jTermFactory.asValue(subject), + (org.eclipse.rdf4j.model.IRI) rdf4jTermFactory.asValue(predicate), rdf4jTermFactory.asValue(object)); + } + + @Override + public void remove(Triple triple) { + model.remove(rdf4jTermFactory.asStatement(triple)); + } + + @Override + public long size() { + int size = model.size(); + if (size < Integer.MAX_VALUE) { + return size; + } else { + // TODO: Check if this can really happen with RDF4J models + // Collection.size() can't help us, we'll have to count + return model.parallelStream().count(); + } + } + + @Override + public Stream<RDF4JTriple> stream() { + return model.parallelStream().map(rdf4jTermFactory::asTriple); + } + + @Override + public Stream<RDF4JTriple> stream(BlankNodeOrIRI subject, org.apache.commons.rdf.api.IRI predicate, + RDFTerm object) { + return model.filter((Resource) rdf4jTermFactory.asValue(subject), + (org.eclipse.rdf4j.model.IRI) rdf4jTermFactory.asValue(predicate), rdf4jTermFactory.asValue(object)) + .parallelStream().map(rdf4jTermFactory::asTriple); + } + + @Override + public Set<RDF4JBlankNodeOrIRI> getContextMask() { + // ModelGraph always do the unionGraph + return Collections.emptySet(); + // TODO: Should we support contextMask like in RepositoryGraphImpl? + } + + @Override + public ClosableIterable<Triple> iterate(BlankNodeOrIRI subject, IRI predicate, RDFTerm object) { + return new ClosableIterable<Triple>() { + @SuppressWarnings("unchecked") + @Override + public Iterator<Triple> iterator() { + // double-cast to fight Java generics.. + Stream<? extends Triple> s = stream(subject, predicate, object); + return (Iterator<Triple>) s.iterator(); + } + + @Override + public void close() throws Exception { + // no-op as Model don't have transaction + } + }; + } + + @Override + public ClosableIterable<Triple> iterate() throws ConcurrentModificationException, IllegalStateException { + return iterate(null, null, null); + } + } \ No newline at end of file http://git-wip-us.apache.org/repos/asf/incubator-commonsrdf/blob/413dd09a/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 8da29b6..6962803 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 @@ -30,70 +30,69 @@ import org.apache.commons.rdf.rdf4j.RDF4J; import org.eclipse.rdf4j.model.Statement; final class QuadImpl implements Quad, RDF4JQuad { - private transient int hashCode = 0; - private UUID salt; - private final Statement statement; - - QuadImpl(Statement statement, UUID salt) { - this.statement = statement; - this.salt = salt; - } - - @Override - public Statement asStatement() { - return statement; - } - - @Override - public Triple asTriple() { - return new TripleImpl(statement, salt); - } - - @Override - public boolean equals(Object obj) { - if (obj instanceof Triple) { - Triple triple = (Triple) obj; - return getSubject().equals(triple.getSubject()) && - getPredicate().equals(triple.getPredicate()) && - getObject().equals(triple.getObject()); - } - return false; - } - - @Override - public Optional<BlankNodeOrIRI> getGraphName() { - if (statement.getContext() == null) { - return Optional.empty(); - } - BlankNodeOrIRI g = (BlankNodeOrIRI) RDF4J.asRDFTerm(statement.getContext(), salt); - return Optional.of(g); - } - - @Override - public RDFTerm getObject() { - return RDF4J.asRDFTerm(statement.getObject(), salt); - } - - @Override - public org.apache.commons.rdf.api.IRI getPredicate() { - return (org.apache.commons.rdf.api.IRI) RDF4J.asRDFTerm(statement.getPredicate(), null); - } - - @Override - public BlankNodeOrIRI getSubject() { - return (BlankNodeOrIRI) RDF4J.asRDFTerm(statement.getSubject(), salt); - } + private transient int hashCode = 0; + private UUID salt; + private final Statement statement; - @Override - public int hashCode() { - if (hashCode != 0) { - return hashCode; - } - return hashCode = Objects.hash(getSubject(), getPredicate(), getObject(), getGraphName()); - } - - @Override - public String toString() { - return statement.toString(); - } + QuadImpl(Statement statement, UUID salt) { + this.statement = statement; + this.salt = salt; + } + + @Override + public Statement asStatement() { + return statement; + } + + @Override + public Triple asTriple() { + return new TripleImpl(statement, salt); + } + + @Override + public boolean equals(Object obj) { + if (obj instanceof Triple) { + Triple triple = (Triple) obj; + return getSubject().equals(triple.getSubject()) && getPredicate().equals(triple.getPredicate()) + && getObject().equals(triple.getObject()); + } + return false; + } + + @Override + public Optional<BlankNodeOrIRI> getGraphName() { + if (statement.getContext() == null) { + return Optional.empty(); + } + BlankNodeOrIRI g = (BlankNodeOrIRI) RDF4J.asRDFTerm(statement.getContext(), salt); + return Optional.of(g); + } + + @Override + public RDFTerm getObject() { + return RDF4J.asRDFTerm(statement.getObject(), salt); + } + + @Override + public org.apache.commons.rdf.api.IRI getPredicate() { + return (org.apache.commons.rdf.api.IRI) RDF4J.asRDFTerm(statement.getPredicate(), null); + } + + @Override + public BlankNodeOrIRI getSubject() { + return (BlankNodeOrIRI) RDF4J.asRDFTerm(statement.getSubject(), salt); + } + + @Override + public int hashCode() { + if (hashCode != 0) { + return hashCode; + } + return hashCode = Objects.hash(getSubject(), getPredicate(), getObject(), getGraphName()); + } + + @Override + public String toString() { + return statement.toString(); + } } \ No newline at end of file http://git-wip-us.apache.org/repos/asf/incubator-commonsrdf/blob/413dd09a/rdf4j/src/main/java/org/apache/commons/rdf/rdf4j/impl/RepositoryDatasetImpl.java ---------------------------------------------------------------------- diff --git a/rdf4j/src/main/java/org/apache/commons/rdf/rdf4j/impl/RepositoryDatasetImpl.java b/rdf4j/src/main/java/org/apache/commons/rdf/rdf4j/impl/RepositoryDatasetImpl.java index 64f3bbd..8c266a9 100644 --- a/rdf4j/src/main/java/org/apache/commons/rdf/rdf4j/impl/RepositoryDatasetImpl.java +++ b/rdf4j/src/main/java/org/apache/commons/rdf/rdf4j/impl/RepositoryDatasetImpl.java @@ -41,183 +41,188 @@ import org.eclipse.rdf4j.repository.RepositoryResult; class RepositoryDatasetImpl extends AbstractRepositoryGraphLike<Quad> implements RDF4JDataset, Dataset { - RepositoryDatasetImpl(Repository repository, UUID salt, boolean handleInitAndShutdown, boolean includeInferred) { - super(repository, salt, handleInitAndShutdown, includeInferred); - } - - @Override - public void add(Quad tripleLike) { - Statement statement = rdf4jTermFactory.asStatement(tripleLike); - try (RepositoryConnection conn = getRepositoryConnection()) { - conn.add(statement); - conn.commit(); - } - } - - - @Override - public boolean contains(Quad tripleLike) { - Statement statement = rdf4jTermFactory.asStatement(tripleLike); - try (RepositoryConnection conn = getRepositoryConnection()) { - return conn.hasStatement(statement, includeInferred); - } - } - - @Override - public void remove(Quad tripleLike) { - Statement statement = rdf4jTermFactory.asStatement(tripleLike); - try (RepositoryConnection conn = getRepositoryConnection()) { - conn.remove(statement); - conn.commit(); - } - } - - @Override - public void clear() { - try (RepositoryConnection conn = getRepositoryConnection()) { - conn.clear(); - conn.commit(); - } - } - - @Override - public long size() { - if (includeInferred) { - // We'll need to count them all - return stream().count(); - } - // else: Ask directly - try (RepositoryConnection conn = getRepositoryConnection()) { - return conn.size(); - } - } - - @Override - public void add(BlankNodeOrIRI graphName, BlankNodeOrIRI subject, IRI predicate, RDFTerm object) { - Resource context = (Resource) rdf4jTermFactory.asValue(graphName); - Resource subj = (Resource) rdf4jTermFactory.asValue(subject); - org.eclipse.rdf4j.model.IRI pred = (org.eclipse.rdf4j.model.IRI) rdf4jTermFactory.asValue(predicate); - Value obj = rdf4jTermFactory.asValue(object); - try (RepositoryConnection conn = getRepositoryConnection()) { - conn.add(subj, pred, obj, context); - conn.commit(); - } - } - - @Override - public boolean contains(Optional<BlankNodeOrIRI> graphName, BlankNodeOrIRI subject, IRI predicate, RDFTerm object) { - Resource subj = (Resource) rdf4jTermFactory.asValue(subject); - org.eclipse.rdf4j.model.IRI pred = (org.eclipse.rdf4j.model.IRI) rdf4jTermFactory.asValue(predicate); - Value obj = rdf4jTermFactory.asValue(object); - Resource[] contexts = asContexts(graphName); - try (RepositoryConnection conn = getRepositoryConnection()) { - return conn.hasStatement(subj, pred, obj, includeInferred, contexts); - } - } - - private Resource[] asContexts(Optional<BlankNodeOrIRI> graphName) { - Resource[] contexts; - if (graphName == null) { - // no contexts == any contexts - contexts = new Resource[0]; - } else { - BlankNodeOrIRI g = graphName.orElse(null); - Resource context = (Resource) rdf4jTermFactory.asValue(g); - contexts = new Resource[] { context }; - } - return contexts; - } - - @Override - public void remove(Optional<BlankNodeOrIRI> graphName, BlankNodeOrIRI subject, IRI predicate, RDFTerm object) { - Resource subj = (Resource) rdf4jTermFactory.asValue(subject); - org.eclipse.rdf4j.model.IRI pred = (org.eclipse.rdf4j.model.IRI) rdf4jTermFactory.asValue(predicate); - Value obj = rdf4jTermFactory.asValue(object); - Resource[] contexts = asContexts(graphName); - - try (RepositoryConnection conn = getRepositoryConnection()) { - conn.remove(subj, pred, obj, contexts); - conn.commit(); - } - } - - @Override - public Stream<RDF4JQuad> stream() { - return stream(null, null, null, null); - } - - @Override - public Stream<RDF4JQuad> stream(Optional<BlankNodeOrIRI> graphName, BlankNodeOrIRI subject, IRI predicate, RDFTerm object) { - Resource subj = (Resource) rdf4jTermFactory.asValue(subject); - org.eclipse.rdf4j.model.IRI pred = (org.eclipse.rdf4j.model.IRI) rdf4jTermFactory.asValue(predicate); - Value obj = rdf4jTermFactory.asValue(object); - Resource[] contexts = asContexts(graphName); - - // NOTE: We can't do the usual try..with closing of the - // RepositoryConnection here as it will have to be closed outside - // by the user of the returned stream - RepositoryConnection conn = getRepositoryConnection(); - Stream<RDF4JQuad> stream = null; - try { - RepositoryResult<Statement> statements = conn.getStatements(subj, pred, obj, includeInferred, contexts); - // NOTE: Iterations.stream should close RepositoryResult as long as our caller closes the stream - stream = Iterations.stream(statements).map(rdf4jTermFactory::asQuad); - } finally { - if (stream == null) { - // Some exception before we made the stream, close connection here - conn.close(); - } - } - // Make sure the RepositoryConnection is closed - return stream.onClose(conn::close); - - } - - - @Override - public ClosableIterable<Quad> iterate() throws ConcurrentModificationException, IllegalStateException { - return iterate(null, null, null, null); - } - - @Override - public ClosableIterable<Quad> iterate(Optional<BlankNodeOrIRI> graphName, BlankNodeOrIRI subject, IRI predicate, RDFTerm object) - throws ConcurrentModificationException, IllegalStateException { - Resource[] contexts = asContexts(graphName); - Resource subj = (Resource) rdf4jTermFactory.asValue(subject); - org.eclipse.rdf4j.model.IRI pred = (org.eclipse.rdf4j.model.IRI) rdf4jTermFactory.asValue(predicate); - Value obj = rdf4jTermFactory.asValue(object); - return new ConvertedStatements<Quad>(this::getRepositoryConnection, - rdf4jTermFactory::asQuad, subj, pred, obj, contexts); - } - - @Override - protected RDF4JQuad asTripleLike(Statement s) { - return rdf4jTermFactory.asQuad(s); - } - - @Override - public Graph getGraph() { - // default context only - // NOTE: We carry over the 'salt' as the graph's BlankNode should be equal to our BlankNodes - return new RepositoryGraphImpl(repository, salt, false, includeInferred, (Resource)null); - } - - @Override - public Optional<Graph> getGraph(BlankNodeOrIRI graphName) { - // NOTE: May be null to indicate default context - Resource context = (Resource) rdf4jTermFactory.asValue(graphName); - // NOTE: We carry over the 'salt' as the graph's BlankNode should be equal to our BlankNodes - return Optional.of(new RepositoryGraphImpl(repository, salt, false, includeInferred, context)); - } - - @Override - public Stream<BlankNodeOrIRI> getGraphNames() { - // FIXME: Will the below close the connection before the stream has been consumed outside? - try (RepositoryConnection conn = getRepositoryConnection()) { - RepositoryResult<Resource> contexts = conn.getContextIDs(); - // NOTE: connection will be closed outside by the Iterations.stream() - return Iterations.stream(contexts).map(g -> (BlankNodeOrIRI) rdf4jTermFactory.asRDFTerm(g)); - } - } + RepositoryDatasetImpl(Repository repository, UUID salt, boolean handleInitAndShutdown, boolean includeInferred) { + super(repository, salt, handleInitAndShutdown, includeInferred); + } + + @Override + public void add(Quad tripleLike) { + Statement statement = rdf4jTermFactory.asStatement(tripleLike); + try (RepositoryConnection conn = getRepositoryConnection()) { + conn.add(statement); + conn.commit(); + } + } + + @Override + public boolean contains(Quad tripleLike) { + Statement statement = rdf4jTermFactory.asStatement(tripleLike); + try (RepositoryConnection conn = getRepositoryConnection()) { + return conn.hasStatement(statement, includeInferred); + } + } + + @Override + public void remove(Quad tripleLike) { + Statement statement = rdf4jTermFactory.asStatement(tripleLike); + try (RepositoryConnection conn = getRepositoryConnection()) { + conn.remove(statement); + conn.commit(); + } + } + + @Override + public void clear() { + try (RepositoryConnection conn = getRepositoryConnection()) { + conn.clear(); + conn.commit(); + } + } + + @Override + public long size() { + if (includeInferred) { + // We'll need to count them all + return stream().count(); + } + // else: Ask directly + try (RepositoryConnection conn = getRepositoryConnection()) { + return conn.size(); + } + } + + @Override + public void add(BlankNodeOrIRI graphName, BlankNodeOrIRI subject, IRI predicate, RDFTerm object) { + Resource context = (Resource) rdf4jTermFactory.asValue(graphName); + Resource subj = (Resource) rdf4jTermFactory.asValue(subject); + org.eclipse.rdf4j.model.IRI pred = (org.eclipse.rdf4j.model.IRI) rdf4jTermFactory.asValue(predicate); + Value obj = rdf4jTermFactory.asValue(object); + try (RepositoryConnection conn = getRepositoryConnection()) { + conn.add(subj, pred, obj, context); + conn.commit(); + } + } + + @Override + public boolean contains(Optional<BlankNodeOrIRI> graphName, BlankNodeOrIRI subject, IRI predicate, RDFTerm object) { + Resource subj = (Resource) rdf4jTermFactory.asValue(subject); + org.eclipse.rdf4j.model.IRI pred = (org.eclipse.rdf4j.model.IRI) rdf4jTermFactory.asValue(predicate); + Value obj = rdf4jTermFactory.asValue(object); + Resource[] contexts = asContexts(graphName); + try (RepositoryConnection conn = getRepositoryConnection()) { + return conn.hasStatement(subj, pred, obj, includeInferred, contexts); + } + } + + private Resource[] asContexts(Optional<BlankNodeOrIRI> graphName) { + Resource[] contexts; + if (graphName == null) { + // no contexts == any contexts + contexts = new Resource[0]; + } else { + BlankNodeOrIRI g = graphName.orElse(null); + Resource context = (Resource) rdf4jTermFactory.asValue(g); + contexts = new Resource[] { context }; + } + return contexts; + } + + @Override + public void remove(Optional<BlankNodeOrIRI> graphName, BlankNodeOrIRI subject, IRI predicate, RDFTerm object) { + Resource subj = (Resource) rdf4jTermFactory.asValue(subject); + org.eclipse.rdf4j.model.IRI pred = (org.eclipse.rdf4j.model.IRI) rdf4jTermFactory.asValue(predicate); + Value obj = rdf4jTermFactory.asValue(object); + Resource[] contexts = asContexts(graphName); + + try (RepositoryConnection conn = getRepositoryConnection()) { + conn.remove(subj, pred, obj, contexts); + conn.commit(); + } + } + + @Override + public Stream<RDF4JQuad> stream() { + return stream(null, null, null, null); + } + + @Override + public Stream<RDF4JQuad> stream(Optional<BlankNodeOrIRI> graphName, BlankNodeOrIRI subject, IRI predicate, + RDFTerm object) { + Resource subj = (Resource) rdf4jTermFactory.asValue(subject); + org.eclipse.rdf4j.model.IRI pred = (org.eclipse.rdf4j.model.IRI) rdf4jTermFactory.asValue(predicate); + Value obj = rdf4jTermFactory.asValue(object); + Resource[] contexts = asContexts(graphName); + + // NOTE: We can't do the usual try..with closing of the + // RepositoryConnection here as it will have to be closed outside + // by the user of the returned stream + RepositoryConnection conn = getRepositoryConnection(); + Stream<RDF4JQuad> stream = null; + try { + RepositoryResult<Statement> statements = conn.getStatements(subj, pred, obj, includeInferred, contexts); + // NOTE: Iterations.stream should close RepositoryResult as long as + // our caller closes the stream + stream = Iterations.stream(statements).map(rdf4jTermFactory::asQuad); + } finally { + if (stream == null) { + // Some exception before we made the stream, close connection + // here + conn.close(); + } + } + // Make sure the RepositoryConnection is closed + return stream.onClose(conn::close); + + } + + @Override + public ClosableIterable<Quad> iterate() throws ConcurrentModificationException, IllegalStateException { + return iterate(null, null, null, null); + } + + @Override + public ClosableIterable<Quad> iterate(Optional<BlankNodeOrIRI> graphName, BlankNodeOrIRI subject, IRI predicate, + RDFTerm object) throws ConcurrentModificationException, IllegalStateException { + Resource[] contexts = asContexts(graphName); + Resource subj = (Resource) rdf4jTermFactory.asValue(subject); + org.eclipse.rdf4j.model.IRI pred = (org.eclipse.rdf4j.model.IRI) rdf4jTermFactory.asValue(predicate); + Value obj = rdf4jTermFactory.asValue(object); + return new ConvertedStatements<Quad>(this::getRepositoryConnection, rdf4jTermFactory::asQuad, subj, pred, obj, + contexts); + } + + @Override + protected RDF4JQuad asTripleLike(Statement s) { + return rdf4jTermFactory.asQuad(s); + } + + @Override + public Graph getGraph() { + // default context only + // NOTE: We carry over the 'salt' as the graph's BlankNode should be + // equal to our BlankNodes + return new RepositoryGraphImpl(repository, salt, false, includeInferred, (Resource) null); + } + + @Override + public Optional<Graph> getGraph(BlankNodeOrIRI graphName) { + // NOTE: May be null to indicate default context + Resource context = (Resource) rdf4jTermFactory.asValue(graphName); + // NOTE: We carry over the 'salt' as the graph's BlankNode should be + // equal to our BlankNodes + return Optional.of(new RepositoryGraphImpl(repository, salt, false, includeInferred, context)); + } + + @Override + public Stream<BlankNodeOrIRI> getGraphNames() { + // FIXME: Will the below close the connection before the stream has been + // consumed outside? + try (RepositoryConnection conn = getRepositoryConnection()) { + RepositoryResult<Resource> contexts = conn.getContextIDs(); + // NOTE: connection will be closed outside by the + // Iterations.stream() + return Iterations.stream(contexts).map(g -> (BlankNodeOrIRI) rdf4jTermFactory.asRDFTerm(g)); + } + } } http://git-wip-us.apache.org/repos/asf/incubator-commonsrdf/blob/413dd09a/rdf4j/src/main/java/org/apache/commons/rdf/rdf4j/impl/RepositoryGraphImpl.java ---------------------------------------------------------------------- diff --git a/rdf4j/src/main/java/org/apache/commons/rdf/rdf4j/impl/RepositoryGraphImpl.java b/rdf4j/src/main/java/org/apache/commons/rdf/rdf4j/impl/RepositoryGraphImpl.java index 55b909e..ca07f9e 100644 --- a/rdf4j/src/main/java/org/apache/commons/rdf/rdf4j/impl/RepositoryGraphImpl.java +++ b/rdf4j/src/main/java/org/apache/commons/rdf/rdf4j/impl/RepositoryGraphImpl.java @@ -43,152 +43,153 @@ import org.eclipse.rdf4j.repository.RepositoryConnection; import org.eclipse.rdf4j.repository.RepositoryResult; class RepositoryGraphImpl extends AbstractRepositoryGraphLike<Triple> implements Graph, RDF4JGraph { - - private final Resource[] contextMask; - - RepositoryGraphImpl(Repository repository, UUID salt, boolean handleInitAndShutdown, boolean includeInferred, Resource... contextMask) { - super(repository, salt, handleInitAndShutdown, includeInferred); - this.contextMask = Objects.requireNonNull(contextMask); - } - - - @Override - public void add(Triple tripleLike) { - Statement statement = rdf4jTermFactory.asStatement(tripleLike); - try (RepositoryConnection conn = getRepositoryConnection()) { - conn.add(statement, contextMask); - conn.commit(); - } - } - - - @Override - public boolean contains(Triple tripleLike) { - Statement statement = rdf4jTermFactory.asStatement(tripleLike); - try (RepositoryConnection conn = getRepositoryConnection()) { - return conn.hasStatement(statement, includeInferred, contextMask); - } - } - - @Override - public void remove(Triple tripleLike) { - Statement statement = rdf4jTermFactory.asStatement(tripleLike); - try (RepositoryConnection conn = getRepositoryConnection()) { - conn.remove(statement, contextMask); - conn.commit(); - } - } - - @Override - public void clear() { - try (RepositoryConnection conn = getRepositoryConnection()) { - conn.clear(contextMask); - conn.commit(); - } - } - - @Override - public long size() { - if (!includeInferred && contextMask.length == 0) { - try (RepositoryConnection conn = getRepositoryConnection()) { - return conn.size(); - } - } else { - try (Stream<RDF4JTriple> stream = stream()) { - return stream.count(); - } - } - } - - @Override - public void add(BlankNodeOrIRI subject, IRI predicate, RDFTerm object) { - Resource subj = (Resource) rdf4jTermFactory.asValue(subject); - org.eclipse.rdf4j.model.IRI pred = (org.eclipse.rdf4j.model.IRI) rdf4jTermFactory.asValue(predicate); - Value obj = rdf4jTermFactory.asValue(object); - try (RepositoryConnection conn = getRepositoryConnection()) { - conn.add(subj, pred, obj, contextMask); - conn.commit(); - } - } - - @Override - public boolean contains(BlankNodeOrIRI subject, IRI predicate, RDFTerm object) { - Resource subj = (Resource) rdf4jTermFactory.asValue(subject); - org.eclipse.rdf4j.model.IRI pred = (org.eclipse.rdf4j.model.IRI) rdf4jTermFactory.asValue(predicate); - Value obj = rdf4jTermFactory.asValue(object); - try (RepositoryConnection conn = getRepositoryConnection()) { - return conn.hasStatement(subj, pred, obj, includeInferred, contextMask); - } - } - - @Override - public void remove(BlankNodeOrIRI subject, IRI predicate, RDFTerm object) { - Resource subj = (Resource) rdf4jTermFactory.asValue(subject); - org.eclipse.rdf4j.model.IRI pred = (org.eclipse.rdf4j.model.IRI) rdf4jTermFactory.asValue(predicate); - Value obj = rdf4jTermFactory.asValue(object); - try (RepositoryConnection conn = getRepositoryConnection()) { - conn.remove(subj, pred, obj, contextMask); - conn.commit(); - } - } - - @Override - public ClosableIterable<Triple> iterate() throws ConcurrentModificationException, IllegalStateException { - return iterate(null, null, null); - } - - @Override - public ClosableIterable<Triple> iterate(BlankNodeOrIRI subject, IRI predicate, RDFTerm object) - throws ConcurrentModificationException, IllegalStateException { - Resource subj = (Resource) rdf4jTermFactory.asValue(subject); - org.eclipse.rdf4j.model.IRI pred = (org.eclipse.rdf4j.model.IRI) rdf4jTermFactory.asValue(predicate); - Value obj = rdf4jTermFactory.asValue(object); - return new ConvertedStatements<Triple>(this::getRepositoryConnection, rdf4jTermFactory::asTriple, - subj, pred, obj, contextMask); - } - - @Override - public Stream<RDF4JTriple> stream() { - return stream(null, null, null); - } - - @Override - public Stream<RDF4JTriple> stream(BlankNodeOrIRI subject, IRI predicate, RDFTerm object) { - Resource subj = (Resource) rdf4jTermFactory.asValue(subject); - org.eclipse.rdf4j.model.IRI pred = (org.eclipse.rdf4j.model.IRI) rdf4jTermFactory.asValue(predicate); - Value obj = rdf4jTermFactory.asValue(object); - - // NOTE: We can't do the usual try..with closing of the - // RepositoryConnection here as it will have to be closed outside - // by the user of the returned stream - RepositoryConnection conn = getRepositoryConnection(); - Stream<RDF4JTriple> stream = null; - try { - RepositoryResult<Statement> statements = conn.getStatements(subj, pred, obj, includeInferred, contextMask); - // NOTE: Iterations.stream should close RepositoryResult as long as our caller closes the stream - stream = Iterations.stream(statements).map(this::asTripleLike); - } finally { - if (stream == null) { - // Some exception before we made the stream, close connection here - conn.close(); - } - } - // Make sure the RepositoryConnection is closed - return stream.onClose(conn::close); - } - - @Override - protected RDF4JTriple asTripleLike(Statement statement) { - return rdf4jTermFactory.asTriple(statement); - } - - @Override - public Set<RDF4JBlankNodeOrIRI> getContextMask() { - Set<RDF4JBlankNodeOrIRI> mask = new HashSet<>(); - for (Resource s : contextMask) { - mask.add((RDF4JBlankNodeOrIRI) rdf4jTermFactory.asRDFTerm(s)); - } - return Collections.unmodifiableSet(mask); - } - + + private final Resource[] contextMask; + + RepositoryGraphImpl(Repository repository, UUID salt, boolean handleInitAndShutdown, boolean includeInferred, + Resource... contextMask) { + super(repository, salt, handleInitAndShutdown, includeInferred); + this.contextMask = Objects.requireNonNull(contextMask); + } + + @Override + public void add(Triple tripleLike) { + Statement statement = rdf4jTermFactory.asStatement(tripleLike); + try (RepositoryConnection conn = getRepositoryConnection()) { + conn.add(statement, contextMask); + conn.commit(); + } + } + + @Override + public boolean contains(Triple tripleLike) { + Statement statement = rdf4jTermFactory.asStatement(tripleLike); + try (RepositoryConnection conn = getRepositoryConnection()) { + return conn.hasStatement(statement, includeInferred, contextMask); + } + } + + @Override + public void remove(Triple tripleLike) { + Statement statement = rdf4jTermFactory.asStatement(tripleLike); + try (RepositoryConnection conn = getRepositoryConnection()) { + conn.remove(statement, contextMask); + conn.commit(); + } + } + + @Override + public void clear() { + try (RepositoryConnection conn = getRepositoryConnection()) { + conn.clear(contextMask); + conn.commit(); + } + } + + @Override + public long size() { + if (!includeInferred && contextMask.length == 0) { + try (RepositoryConnection conn = getRepositoryConnection()) { + return conn.size(); + } + } else { + try (Stream<RDF4JTriple> stream = stream()) { + return stream.count(); + } + } + } + + @Override + public void add(BlankNodeOrIRI subject, IRI predicate, RDFTerm object) { + Resource subj = (Resource) rdf4jTermFactory.asValue(subject); + org.eclipse.rdf4j.model.IRI pred = (org.eclipse.rdf4j.model.IRI) rdf4jTermFactory.asValue(predicate); + Value obj = rdf4jTermFactory.asValue(object); + try (RepositoryConnection conn = getRepositoryConnection()) { + conn.add(subj, pred, obj, contextMask); + conn.commit(); + } + } + + @Override + public boolean contains(BlankNodeOrIRI subject, IRI predicate, RDFTerm object) { + Resource subj = (Resource) rdf4jTermFactory.asValue(subject); + org.eclipse.rdf4j.model.IRI pred = (org.eclipse.rdf4j.model.IRI) rdf4jTermFactory.asValue(predicate); + Value obj = rdf4jTermFactory.asValue(object); + try (RepositoryConnection conn = getRepositoryConnection()) { + return conn.hasStatement(subj, pred, obj, includeInferred, contextMask); + } + } + + @Override + public void remove(BlankNodeOrIRI subject, IRI predicate, RDFTerm object) { + Resource subj = (Resource) rdf4jTermFactory.asValue(subject); + org.eclipse.rdf4j.model.IRI pred = (org.eclipse.rdf4j.model.IRI) rdf4jTermFactory.asValue(predicate); + Value obj = rdf4jTermFactory.asValue(object); + try (RepositoryConnection conn = getRepositoryConnection()) { + conn.remove(subj, pred, obj, contextMask); + conn.commit(); + } + } + + @Override + public ClosableIterable<Triple> iterate() throws ConcurrentModificationException, IllegalStateException { + return iterate(null, null, null); + } + + @Override + public ClosableIterable<Triple> iterate(BlankNodeOrIRI subject, IRI predicate, RDFTerm object) + throws ConcurrentModificationException, IllegalStateException { + Resource subj = (Resource) rdf4jTermFactory.asValue(subject); + org.eclipse.rdf4j.model.IRI pred = (org.eclipse.rdf4j.model.IRI) rdf4jTermFactory.asValue(predicate); + Value obj = rdf4jTermFactory.asValue(object); + return new ConvertedStatements<Triple>(this::getRepositoryConnection, rdf4jTermFactory::asTriple, subj, pred, + obj, contextMask); + } + + @Override + public Stream<RDF4JTriple> stream() { + return stream(null, null, null); + } + + @Override + public Stream<RDF4JTriple> stream(BlankNodeOrIRI subject, IRI predicate, RDFTerm object) { + Resource subj = (Resource) rdf4jTermFactory.asValue(subject); + org.eclipse.rdf4j.model.IRI pred = (org.eclipse.rdf4j.model.IRI) rdf4jTermFactory.asValue(predicate); + Value obj = rdf4jTermFactory.asValue(object); + + // NOTE: We can't do the usual try..with closing of the + // RepositoryConnection here as it will have to be closed outside + // by the user of the returned stream + RepositoryConnection conn = getRepositoryConnection(); + Stream<RDF4JTriple> stream = null; + try { + RepositoryResult<Statement> statements = conn.getStatements(subj, pred, obj, includeInferred, contextMask); + // NOTE: Iterations.stream should close RepositoryResult as long as + // our caller closes the stream + stream = Iterations.stream(statements).map(this::asTripleLike); + } finally { + if (stream == null) { + // Some exception before we made the stream, close connection + // here + conn.close(); + } + } + // Make sure the RepositoryConnection is closed + return stream.onClose(conn::close); + } + + @Override + protected RDF4JTriple asTripleLike(Statement statement) { + return rdf4jTermFactory.asTriple(statement); + } + + @Override + public Set<RDF4JBlankNodeOrIRI> getContextMask() { + Set<RDF4JBlankNodeOrIRI> mask = new HashSet<>(); + for (Resource s : contextMask) { + mask.add((RDF4JBlankNodeOrIRI) rdf4jTermFactory.asRDFTerm(s)); + } + return Collections.unmodifiableSet(mask); + } + } http://git-wip-us.apache.org/repos/asf/incubator-commonsrdf/blob/413dd09a/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 0526c77..4ed3946 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 @@ -28,52 +28,51 @@ import org.apache.commons.rdf.rdf4j.RDF4JTriple; import org.eclipse.rdf4j.model.Statement; final class TripleImpl implements Triple, RDF4JTriple { - private UUID salt; - private final Statement statement; - - TripleImpl(Statement statement, UUID salt) { - this.statement = statement; - this.salt = salt; - } - - @Override - public Statement asStatement() { - return statement; - } - - @Override - public boolean equals(Object obj) { - if (obj instanceof Triple) { - Triple triple = (Triple) obj; - return getSubject().equals(triple.getSubject()) && - getPredicate().equals(triple.getPredicate()) && - getObject().equals(triple.getObject()); - } - return false; - } - - @Override - public RDFTerm getObject() { - return RDF4J.asRDFTerm(statement.getObject(), salt); - } - - @Override - public org.apache.commons.rdf.api.IRI getPredicate() { - return (org.apache.commons.rdf.api.IRI) RDF4J.asRDFTerm(statement.getPredicate(), null); - } - - @Override - public BlankNodeOrIRI getSubject() { - return (BlankNodeOrIRI) RDF4J.asRDFTerm(statement.getSubject(), salt); - } - - @Override - public int hashCode() { - return Objects.hash(getSubject(), getPredicate(), getObject()); - } - - @Override - public String toString() { - return statement.toString(); - } + private UUID salt; + private final Statement statement; + + TripleImpl(Statement statement, UUID salt) { + this.statement = statement; + this.salt = salt; + } + + @Override + public Statement asStatement() { + return statement; + } + + @Override + public boolean equals(Object obj) { + if (obj instanceof Triple) { + Triple triple = (Triple) obj; + return getSubject().equals(triple.getSubject()) && getPredicate().equals(triple.getPredicate()) + && getObject().equals(triple.getObject()); + } + return false; + } + + @Override + public RDFTerm getObject() { + return RDF4J.asRDFTerm(statement.getObject(), salt); + } + + @Override + public org.apache.commons.rdf.api.IRI getPredicate() { + return (org.apache.commons.rdf.api.IRI) RDF4J.asRDFTerm(statement.getPredicate(), null); + } + + @Override + public BlankNodeOrIRI getSubject() { + return (BlankNodeOrIRI) RDF4J.asRDFTerm(statement.getSubject(), salt); + } + + @Override + public int hashCode() { + return Objects.hash(getSubject(), getPredicate(), getObject()); + } + + @Override + public String toString() { + return statement.toString(); + } } \ No newline at end of file http://git-wip-us.apache.org/repos/asf/incubator-commonsrdf/blob/413dd09a/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 f4bfb7a..e40e985 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,39 +18,33 @@ /** * Commons RDF integration with <a href="http://rdf4j.org/";>RDF4J</a>. * <p> - * Use the {@link RDF4J} to convert - * between Commons RDF and RDF4J types, for instance - * {@link RDF4J#asQuad(org.eclipse.rdf4j.model.Statement)} - * converts a RDF4J {@link org.eclipse.rdf4j.model.Statement} to a + * Use the {@link RDF4J} to convert between Commons RDF and RDF4J types, for + * instance {@link RDF4J#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 RDF4JTerm} interface, and converted - * statements the {@link RDF4JTripleLike} - * interface, which provide convenience access to the underlying RDF4J - * implementations. + * {@link RDF4JTerm} interface, and converted statements the + * {@link RDF4JTripleLike} interface, which provide convenience access to the + * underlying RDF4J implementations. * <p> * RDF4J {@link org.eclipse.rdf4j.model.Model}s and * {@link org.eclipse.rdf4j.repository.Repository} instances can be adapted to - * Commons RDF {@link Graph} and - * {@link Dataset}, e.g. using - * {@link RDF4J#asGraph(org.eclipse.rdf4j.model.Model)} - * or + * Commons RDF {@link Graph} and {@link Dataset}, e.g. using + * {@link RDF4J#asGraph(org.eclipse.rdf4j.model.Model)} or * {@link RDF4J#asDataset(org.eclipse.rdf4j.repository.Repository, RDF4J.Option...)} * The returned adapted graph/dataset is directly mapped, so changes are * propagated both ways. For convenience, the marker interface - * {@link RDF4JGraph} and - * {@link RDF4JDataset} provide access to the - * underlying RDF4J implementations. + * {@link RDF4JGraph} and {@link RDF4JDataset} provide access to the underlying + * RDF4J implementations. * <p> - * The {@link RDF4JParser} can be used to - * parse RDF files using RDF4j. It should be most efficient if used with - * {@link RDF4JParser#target(Dataset)} - * and an adapted {@link RDF4JDataset}, or - * {@link RDF4JParser#target(Graph)} - * and a an adapted {@link RDF4JGraph} + * The {@link RDF4JParser} can be used to parse RDF files using RDF4j. It should + * be most efficient if used with {@link RDF4JParser#target(Dataset)} and an + * adapted {@link RDF4JDataset}, or {@link RDF4JParser#target(Graph)} and a an + * adapted {@link RDF4JGraph} * * */ package org.apache.commons.rdf.rdf4j; + // Imports for Javadoc, do not remove import org.apache.commons.rdf.api.Dataset; import org.apache.commons.rdf.api.Graph; http://git-wip-us.apache.org/repos/asf/incubator-commonsrdf/blob/413dd09a/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 d31c24d..f068040 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,16 +22,16 @@ import org.apache.commons.rdf.api.BlankNode; public class BlankNodeTest extends AbstractBlankNodeTest { - RDF4J factory = new RDF4J(); - - @Override - protected BlankNode getBlankNode() { - return factory.createBlankNode(); - } + RDF4J factory = new RDF4J(); - @Override - protected BlankNode getBlankNode(String identifier) { - return factory.createBlankNode(identifier); - } + @Override + protected BlankNode getBlankNode() { + return factory.createBlankNode(); + } + + @Override + protected BlankNode getBlankNode(String identifier) { + return factory.createBlankNode(identifier); + } } http://git-wip-us.apache.org/repos/asf/incubator-commonsrdf/blob/413dd09a/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 4ad8969..81c77da 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 @@ -20,11 +20,11 @@ package org.apache.commons.rdf.rdf4j; import org.apache.commons.rdf.api.AbstractGraphTest; import org.apache.commons.rdf.api.RDF; -public class GraphTest extends AbstractGraphTest{ +public class GraphTest extends AbstractGraphTest { - @Override - public RDF createFactory() { - return new RDF4J(); - } + @Override + public RDF createFactory() { + return new RDF4J(); + } } http://git-wip-us.apache.org/repos/asf/incubator-commonsrdf/blob/413dd09a/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 ab7a459..9d9c802 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 @@ -33,57 +33,57 @@ import org.eclipse.rdf4j.sail.memory.model.MemValueFactory; public class MemoryGraphTest extends AbstractGraphTest { - public static final class MemoryStoreRDF implements RDF { - - RDF4J rdf4jFactory = new RDF4J(new MemValueFactory()); - - public RDF4JBlankNode createBlankNode() { - return rdf4jFactory.createBlankNode(); - } - - public RDF4JBlankNode createBlankNode(String name) { - return rdf4jFactory.createBlankNode(name); - } - - public Dataset createDataset() { - return rdf4jFactory.createDataset(); - } - - public RDF4JIRI createIRI(String iri) throws IllegalArgumentException, UnsupportedOperationException { - return rdf4jFactory.createIRI(iri); - } - - public RDF4JLiteral createLiteral(String lexicalForm) { - return rdf4jFactory.createLiteral(lexicalForm); - } - - public Literal createLiteral(String lexicalForm, IRI dataType) { - return rdf4jFactory.createLiteral(lexicalForm, dataType); - } - - public Literal createLiteral(String lexicalForm, String languageTag) { - return rdf4jFactory.createLiteral(lexicalForm, languageTag); - } - - public RDF4JTriple createTriple(BlankNodeOrIRI subject, IRI predicate, RDFTerm object) { - return rdf4jFactory.createTriple(subject, predicate, object); - } - - public Quad createQuad(BlankNodeOrIRI graphName, BlankNodeOrIRI subject, IRI predicate, RDFTerm object) { - return rdf4jFactory.createQuad(graphName, subject, predicate, object); - } - - public RDF4JGraph createGraph() { - Sail sail = new MemoryStore(); - Repository repository = new SailRepository(sail); - repository.initialize(); - return rdf4jFactory.asGraph(repository); - } - } - - @Override - public RDF createFactory() { - return new MemoryStoreRDF(); - } + public static final class MemoryStoreRDF implements RDF { + + RDF4J rdf4jFactory = new RDF4J(new MemValueFactory()); + + public RDF4JBlankNode createBlankNode() { + return rdf4jFactory.createBlankNode(); + } + + public RDF4JBlankNode createBlankNode(String name) { + return rdf4jFactory.createBlankNode(name); + } + + public Dataset createDataset() { + return rdf4jFactory.createDataset(); + } + + public RDF4JIRI createIRI(String iri) throws IllegalArgumentException, UnsupportedOperationException { + return rdf4jFactory.createIRI(iri); + } + + public RDF4JLiteral createLiteral(String lexicalForm) { + return rdf4jFactory.createLiteral(lexicalForm); + } + + public Literal createLiteral(String lexicalForm, IRI dataType) { + return rdf4jFactory.createLiteral(lexicalForm, dataType); + } + + public Literal createLiteral(String lexicalForm, String languageTag) { + return rdf4jFactory.createLiteral(lexicalForm, languageTag); + } + + public RDF4JTriple createTriple(BlankNodeOrIRI subject, IRI predicate, RDFTerm object) { + return rdf4jFactory.createTriple(subject, predicate, object); + } + + public Quad createQuad(BlankNodeOrIRI graphName, BlankNodeOrIRI subject, IRI predicate, RDFTerm object) { + return rdf4jFactory.createQuad(graphName, subject, predicate, object); + } + + public RDF4JGraph createGraph() { + Sail sail = new MemoryStore(); + Repository repository = new SailRepository(sail); + repository.initialize(); + return rdf4jFactory.asGraph(repository); + } + } + + @Override + public RDF createFactory() { + return new MemoryStoreRDF(); + } } http://git-wip-us.apache.org/repos/asf/incubator-commonsrdf/blob/413dd09a/rdf4j/src/test/java/org/apache/commons/rdf/rdf4j/MemoryStoreRDFTest.java ---------------------------------------------------------------------- diff --git a/rdf4j/src/test/java/org/apache/commons/rdf/rdf4j/MemoryStoreRDFTest.java b/rdf4j/src/test/java/org/apache/commons/rdf/rdf4j/MemoryStoreRDFTest.java index fd4efcb..5954d13 100644 --- a/rdf4j/src/test/java/org/apache/commons/rdf/rdf4j/MemoryStoreRDFTest.java +++ b/rdf4j/src/test/java/org/apache/commons/rdf/rdf4j/MemoryStoreRDFTest.java @@ -23,15 +23,15 @@ import org.junit.Assume; public class MemoryStoreRDFTest extends AbstractRDFTest { - @Override - public RDF createFactory() { - return new MemoryGraphTest.MemoryStoreRDF(); - } - - @Override - public void testInvalidLiteralLang() throws Exception { - Assume.assumeTrue("RDF4J doesn't check Lang strings",false); - super.testInvalidLiteralLang(); - } - + @Override + public RDF createFactory() { + return new MemoryGraphTest.MemoryStoreRDF(); + } + + @Override + public void testInvalidLiteralLang() throws Exception { + Assume.assumeTrue("RDF4J doesn't check Lang strings", false); + super.testInvalidLiteralLang(); + } + }
