Return-Path: X-Original-To: archive-asf-public-internal@cust-asf2.ponee.io Delivered-To: archive-asf-public-internal@cust-asf2.ponee.io Received: from cust-asf.ponee.io (cust-asf.ponee.io [163.172.22.183]) by cust-asf2.ponee.io (Postfix) with ESMTP id 08E13200BC5 for ; Tue, 22 Nov 2016 08:56:14 +0100 (CET) Received: by cust-asf.ponee.io (Postfix) id 07A14160B21; Tue, 22 Nov 2016 07:56:14 +0000 (UTC) Delivered-To: archive-asf-public@cust-asf.ponee.io Received: from mail.apache.org (hermes.apache.org [140.211.11.3]) by cust-asf.ponee.io (Postfix) with SMTP id 32447160B0A for ; Tue, 22 Nov 2016 08:56:12 +0100 (CET) Received: (qmail 7452 invoked by uid 500); 22 Nov 2016 07:56:11 -0000 Mailing-List: contact commits-help@commonsrdf.incubator.apache.org; run by ezmlm Precedence: bulk List-Help: List-Unsubscribe: List-Post: List-Id: Reply-To: dev@commonsrdf.incubator.apache.org Delivered-To: mailing list commits@commonsrdf.incubator.apache.org Received: (qmail 7436 invoked by uid 99); 22 Nov 2016 07:56:11 -0000 Received: from pnap-us-west-generic-nat.apache.org (HELO spamd4-us-west.apache.org) (209.188.14.142) by apache.org (qpsmtpd/0.29) with ESMTP; Tue, 22 Nov 2016 07:56:11 +0000 Received: from localhost (localhost [127.0.0.1]) by spamd4-us-west.apache.org (ASF Mail Server at spamd4-us-west.apache.org) with ESMTP id 9BA5BC036D for ; Tue, 22 Nov 2016 07:56:10 +0000 (UTC) X-Virus-Scanned: Debian amavisd-new at spamd4-us-west.apache.org X-Spam-Flag: NO X-Spam-Score: -1.999 X-Spam-Level: X-Spam-Status: No, score=-1.999 tagged_above=-999 required=6.31 tests=[KAM_LAZY_DOMAIN_SECURITY=1, RP_MATCHES_RCVD=-2.999] autolearn=disabled Received: from mx1-lw-us.apache.org ([10.40.0.8]) by localhost (spamd4-us-west.apache.org [10.40.0.11]) (amavisd-new, port 10024) with ESMTP id a79t7wL3QOlS for ; Tue, 22 Nov 2016 07:55:49 +0000 (UTC) Received: from mailrelay1-us-west.apache.org (mailrelay1-us-west.apache.org [209.188.14.139]) by mx1-lw-us.apache.org (ASF Mail Server at mx1-lw-us.apache.org) with ESMTP id 543C660DFF for ; Tue, 22 Nov 2016 07:55:49 +0000 (UTC) Received: from svn01-us-west.apache.org (svn.apache.org [10.41.0.6]) by mailrelay1-us-west.apache.org (ASF Mail Server at mailrelay1-us-west.apache.org) with ESMTP id 9B5D1E8EB6 for ; Tue, 22 Nov 2016 07:55:45 +0000 (UTC) Received: from svn01-us-west.apache.org (localhost [127.0.0.1]) by svn01-us-west.apache.org (ASF Mail Server at svn01-us-west.apache.org) with ESMTP id 704E13A2B98 for ; Tue, 22 Nov 2016 07:55:45 +0000 (UTC) Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit Subject: svn commit: r1001470 [33/36] - in /websites/production/commonsrdf/content: ./ apidocs/ apidocs/org/apache/commons/rdf/api/ apidocs/org/apache/commons/rdf/api/class-use/ apidocs/org/apache/commons/rdf/experimental/ apidocs/org/apache/commons/rdf/experim... Date: Tue, 22 Nov 2016 07:55:40 -0000 To: commits@commonsrdf.incubator.apache.org From: wikier@apache.org X-Mailer: svnmailer-1.0.9 Message-Id: <20161122075545.704E13A2B98@svn01-us-west.apache.org> archived-at: Tue, 22 Nov 2016 07:56:14 -0000 Modified: websites/production/commonsrdf/content/xref/org/apache/commons/rdf/rdf4j/impl/RepositoryDatasetImpl.html ============================================================================== --- websites/production/commonsrdf/content/xref/org/apache/commons/rdf/rdf4j/impl/RepositoryDatasetImpl.html (original) +++ websites/production/commonsrdf/content/xref/org/apache/commons/rdf/rdf4j/impl/RepositoryDatasetImpl.html Tue Nov 22 07:55:35 2016 @@ -31,205 +31,204 @@ 23 import java.util.stream.Stream; 24 25 import org.apache.commons.rdf.api.BlankNodeOrIRI; -26 import org.apache.commons.rdf.api.Dataset; -27 import org.apache.commons.rdf.api.Graph; -28 import org.apache.commons.rdf.api.IRI; -29 import org.apache.commons.rdf.api.Quad; -30 import org.apache.commons.rdf.api.RDFTerm; -31 import org.apache.commons.rdf.rdf4j.ClosableIterable; -32 import org.apache.commons.rdf.rdf4j.RDF4JDataset; -33 import org.apache.commons.rdf.rdf4j.RDF4JQuad; -34 import org.eclipse.rdf4j.common.iteration.Iterations; -35 import org.eclipse.rdf4j.model.Resource; -36 import org.eclipse.rdf4j.model.Statement; -37 import org.eclipse.rdf4j.model.Value; -38 import org.eclipse.rdf4j.repository.Repository; -39 import org.eclipse.rdf4j.repository.RepositoryConnection; -40 import org.eclipse.rdf4j.repository.RepositoryResult; -41 -42 class RepositoryDatasetImpl extends AbstractRepositoryGraphLike<Quad> implements RDF4JDataset, Dataset { -43 -44 RepositoryDatasetImpl(Repository repository, UUID salt, boolean handleInitAndShutdown, boolean includeInferred) { -45 super(repository, salt, handleInitAndShutdown, includeInferred); -46 } -47 -48 @Override -49 public void add(Quad tripleLike) { -50 Statement statement = rdf4jTermFactory.asStatement(tripleLike); -51 try (RepositoryConnection conn = getRepositoryConnection()) { -52 conn.add(statement); -53 conn.commit(); -54 } -55 } -56 -57 @Override -58 public boolean contains(Quad tripleLike) { -59 Statement statement = rdf4jTermFactory.asStatement(tripleLike); -60 try (RepositoryConnection conn = getRepositoryConnection()) { -61 return conn.hasStatement(statement, includeInferred); -62 } -63 } -64 -65 @Override -66 public void remove(Quad tripleLike) { -67 Statement statement = rdf4jTermFactory.asStatement(tripleLike); -68 try (RepositoryConnection conn = getRepositoryConnection()) { -69 conn.remove(statement); -70 conn.commit(); -71 } -72 } -73 -74 @Override -75 public void clear() { -76 try (RepositoryConnection conn = getRepositoryConnection()) { -77 conn.clear(); -78 conn.commit(); -79 } -80 } -81 -82 @Override -83 public long size() { -84 if (includeInferred) { -85 // We'll need to count them all -86 return stream().count(); -87 } -88 // else: Ask directly -89 try (RepositoryConnection conn = getRepositoryConnection()) { -90 return conn.size(); -91 } -92 } -93 -94 @Override -95 public void add(BlankNodeOrIRI graphName, BlankNodeOrIRI subject, IRI predicate, RDFTerm object) { -96 Resource context = (Resource) rdf4jTermFactory.asValue(graphName); -97 Resource subj = (Resource) rdf4jTermFactory.asValue(subject); -98 org.eclipse.rdf4j.model.IRI pred = (org.eclipse.rdf4j.model.IRI) rdf4jTermFactory.asValue(predicate); -99 Value obj = rdf4jTermFactory.asValue(object); -100 try (RepositoryConnection conn = getRepositoryConnection()) { -101 conn.add(subj, pred, obj, context); -102 conn.commit(); -103 } -104 } -105 -106 @Override -107 public boolean contains(Optional<BlankNodeOrIRI> graphName, BlankNodeOrIRI subject, IRI predicate, RDFTerm object) { -108 Resource subj = (Resource) rdf4jTermFactory.asValue(subject); -109 org.eclipse.rdf4j.model.IRI pred = (org.eclipse.rdf4j.model.IRI) rdf4jTermFactory.asValue(predicate); -110 Value obj = rdf4jTermFactory.asValue(object); -111 Resource[] contexts = asContexts(graphName); -112 try (RepositoryConnection conn = getRepositoryConnection()) { -113 return conn.hasStatement(subj, pred, obj, includeInferred, contexts); -114 } -115 } -116 -117 private Resource[] asContexts(Optional<BlankNodeOrIRI> graphName) { -118 Resource[] contexts; -119 if (graphName == null) { -120 // no contexts == any contexts -121 contexts = new Resource[0]; -122 } else { -123 BlankNodeOrIRI g = graphName.orElse(null); -124 Resource context = (Resource) rdf4jTermFactory.asValue(g); -125 contexts = new Resource[] { context }; -126 } -127 return contexts; -128 } -129 -130 @Override -131 public void remove(Optional<BlankNodeOrIRI> graphName, BlankNodeOrIRI subject, IRI predicate, RDFTerm object) { -132 Resource subj = (Resource) rdf4jTermFactory.asValue(subject); -133 org.eclipse.rdf4j.model.IRI pred = (org.eclipse.rdf4j.model.IRI) rdf4jTermFactory.asValue(predicate); -134 Value obj = rdf4jTermFactory.asValue(object); -135 Resource[] contexts = asContexts(graphName); -136 -137 try (RepositoryConnection conn = getRepositoryConnection()) { -138 conn.remove(subj, pred, obj, contexts); -139 conn.commit(); -140 } -141 } -142 -143 @Override -144 public Stream<RDF4JQuad> stream() { -145 return stream(null, null, null, null); -146 } -147 -148 @Override -149 public Stream<RDF4JQuad> stream(Optional<BlankNodeOrIRI> graphName, BlankNodeOrIRI subject, IRI predicate, -150 RDFTerm object) { -151 Resource subj = (Resource) rdf4jTermFactory.asValue(subject); -152 org.eclipse.rdf4j.model.IRI pred = (org.eclipse.rdf4j.model.IRI) rdf4jTermFactory.asValue(predicate); -153 Value obj = rdf4jTermFactory.asValue(object); -154 Resource[] contexts = asContexts(graphName); -155 -156 // NOTE: We can't do the usual try..with closing of the -157 // RepositoryConnection here as it will have to be closed outside -158 // by the user of the returned stream -159 RepositoryConnection conn = getRepositoryConnection(); -160 Stream<RDF4JQuad> stream = null; -161 try { -162 RepositoryResult<Statement> statements = conn.getStatements(subj, pred, obj, includeInferred, contexts); -163 // NOTE: Iterations.stream should close RepositoryResult as long as -164 // our caller closes the stream -165 stream = Iterations.stream(statements).map(rdf4jTermFactory::asQuad); -166 } finally { -167 if (stream == null) { -168 // Some exception before we made the stream, close connection -169 // here -170 conn.close(); -171 } -172 } -173 // Make sure the RepositoryConnection is closed -174 return stream.onClose(conn::close); -175 -176 } -177 -178 @Override -179 public ClosableIterable<Quad> iterate() throws ConcurrentModificationException, IllegalStateException { -180 return iterate(null, null, null, null); -181 } -182 -183 @Override -184 public ClosableIterable<Quad> iterate(Optional<BlankNodeOrIRI> graphName, BlankNodeOrIRI subject, IRI predicate, -185 RDFTerm object) throws ConcurrentModificationException, IllegalStateException { -186 Resource[] contexts = asContexts(graphName); -187 Resource subj = (Resource) rdf4jTermFactory.asValue(subject); -188 org.eclipse.rdf4j.model.IRI pred = (org.eclipse.rdf4j.model.IRI) rdf4jTermFactory.asValue(predicate); -189 Value obj = rdf4jTermFactory.asValue(object); -190 return new ConvertedStatements<Quad>(this::getRepositoryConnection, rdf4jTermFactory::asQuad, subj, pred, obj, -191 contexts); -192 } -193 -194 @Override -195 protected RDF4JQuad asTripleLike(Statement s) { -196 return rdf4jTermFactory.asQuad(s); -197 } -198 -199 @Override -200 public Graph getGraph() { -201 // default context only -202 // NOTE: We carry over the 'salt' as the graph's BlankNode should be -203 // equal to our BlankNodes -204 return new RepositoryGraphImpl(repository, salt, false, includeInferred, (Resource) null); -205 } -206 -207 @Override -208 public Optional<Graph> getGraph(BlankNodeOrIRI graphName) { -209 // NOTE: May be null to indicate default context -210 Resource context = (Resource) rdf4jTermFactory.asValue(graphName); -211 // NOTE: We carry over the 'salt' as the graph's BlankNode should be -212 // equal to our BlankNodes -213 return Optional.of(new RepositoryGraphImpl(repository, salt, false, includeInferred, context)); -214 } -215 -216 @Override -217 public Stream<BlankNodeOrIRI> getGraphNames() { -218 RepositoryConnection conn = getRepositoryConnection(); -219 RepositoryResult<Resource> contexts = conn.getContextIDs(); -220 return Iterations.stream(contexts).map(g -> (BlankNodeOrIRI) rdf4jTermFactory.asRDFTerm(g)) -221 .onClose(conn::close); -222 } -223 -224 } +26 import org.apache.commons.rdf.api.Graph; +27 import org.apache.commons.rdf.api.IRI; +28 import org.apache.commons.rdf.api.Quad; +29 import org.apache.commons.rdf.api.RDFTerm; +30 import org.apache.commons.rdf.rdf4j.ClosableIterable; +31 import org.apache.commons.rdf.rdf4j.RDF4JDataset; +32 import org.apache.commons.rdf.rdf4j.RDF4JQuad; +33 import org.eclipse.rdf4j.common.iteration.Iterations; +34 import org.eclipse.rdf4j.model.Resource; +35 import org.eclipse.rdf4j.model.Statement; +36 import org.eclipse.rdf4j.model.Value; +37 import org.eclipse.rdf4j.repository.Repository; +38 import org.eclipse.rdf4j.repository.RepositoryConnection; +39 import org.eclipse.rdf4j.repository.RepositoryResult; +40 +41 class RepositoryDatasetImpl extends AbstractRepositoryGraphLike<Quad> implements RDF4JDataset { +42 +43 RepositoryDatasetImpl(final Repository repository, final UUID salt, final boolean handleInitAndShutdown, final boolean includeInferred) { +44 super(repository, salt, handleInitAndShutdown, includeInferred); +45 } +46 +47 @Override +48 public void add(final Quad tripleLike) { +49 final Statement statement = rdf4jTermFactory.asStatement(tripleLike); +50 try (RepositoryConnection conn = getRepositoryConnection()) { +51 conn.add(statement); +52 conn.commit(); +53 } +54 } +55 +56 @Override +57 public boolean contains(final Quad tripleLike) { +58 final Statement statement = rdf4jTermFactory.asStatement(tripleLike); +59 try (RepositoryConnection conn = getRepositoryConnection()) { +60 return conn.hasStatement(statement, includeInferred); +61 } +62 } +63 +64 @Override +65 public void remove(final Quad tripleLike) { +66 final Statement statement = rdf4jTermFactory.asStatement(tripleLike); +67 try (RepositoryConnection conn = getRepositoryConnection()) { +68 conn.remove(statement); +69 conn.commit(); +70 } +71 } +72 +73 @Override +74 public void clear() { +75 try (RepositoryConnection conn = getRepositoryConnection()) { +76 conn.clear(); +77 conn.commit(); +78 } +79 } +80 +81 @Override +82 public long size() { +83 if (includeInferred) { +84 // We'll need to count them all +85 return stream().count(); +86 } +87 // else: Ask directly +88 try (RepositoryConnection conn = getRepositoryConnection()) { +89 return conn.size(); +90 } +91 } +92 +93 @Override +94 public void add(final BlankNodeOrIRI graphName, final BlankNodeOrIRI subject, final IRI predicate, final RDFTerm object) { +95 final Resource context = (Resource) rdf4jTermFactory.asValue(graphName); +96 final Resource subj = (Resource) rdf4jTermFactory.asValue(subject); +97 final org.eclipse.rdf4j.model.IRI pred = (org.eclipse.rdf4j.model.IRI) rdf4jTermFactory.asValue(predicate); +98 final Value obj = rdf4jTermFactory.asValue(object); +99 try (RepositoryConnection conn = getRepositoryConnection()) { +100 conn.add(subj, pred, obj, context); +101 conn.commit(); +102 } +103 } +104 +105 @Override +106 public boolean contains(final Optional<BlankNodeOrIRI> graphName, final BlankNodeOrIRI subject, final IRI predicate, final RDFTerm object) { +107 final Resource subj = (Resource) rdf4jTermFactory.asValue(subject); +108 final org.eclipse.rdf4j.model.IRI pred = (org.eclipse.rdf4j.model.IRI) rdf4jTermFactory.asValue(predicate); +109 final Value obj = rdf4jTermFactory.asValue(object); +110 final Resource[] contexts = asContexts(graphName); +111 try (RepositoryConnection conn = getRepositoryConnection()) { +112 return conn.hasStatement(subj, pred, obj, includeInferred, contexts); +113 } +114 } +115 +116 private Resource[] asContexts(final Optional<BlankNodeOrIRI> graphName) { +117 Resource[] contexts; +118 if (graphName == null) { +119 // no contexts == any contexts +120 contexts = new Resource[0]; +121 } else { +122 final BlankNodeOrIRI g = graphName.orElse(null); +123 final Resource context = (Resource) rdf4jTermFactory.asValue(g); +124 contexts = new Resource[] { context }; +125 } +126 return contexts; +127 } +128 +129 @Override +130 public void remove(final Optional<BlankNodeOrIRI> graphName, final BlankNodeOrIRI subject, final IRI predicate, final RDFTerm object) { +131 final Resource subj = (Resource) rdf4jTermFactory.asValue(subject); +132 final org.eclipse.rdf4j.model.IRI pred = (org.eclipse.rdf4j.model.IRI) rdf4jTermFactory.asValue(predicate); +133 final Value obj = rdf4jTermFactory.asValue(object); +134 final Resource[] contexts = asContexts(graphName); +135 +136 try (RepositoryConnection conn = getRepositoryConnection()) { +137 conn.remove(subj, pred, obj, contexts); +138 conn.commit(); +139 } +140 } +141 +142 @Override +143 public Stream<RDF4JQuad> stream() { +144 return stream(null, null, null, null); +145 } +146 +147 @Override +148 public Stream<RDF4JQuad> stream(final Optional<BlankNodeOrIRI> graphName, final BlankNodeOrIRI subject, final IRI predicate, +149 final RDFTerm object) { +150 final Resource subj = (Resource) rdf4jTermFactory.asValue(subject); +151 final org.eclipse.rdf4j.model.IRI pred = (org.eclipse.rdf4j.model.IRI) rdf4jTermFactory.asValue(predicate); +152 final Value obj = rdf4jTermFactory.asValue(object); +153 final Resource[] contexts = asContexts(graphName); +154 +155 // NOTE: We can't do the usual try..with closing of the +156 // RepositoryConnection here as it will have to be closed outside +157 // by the user of the returned stream +158 final RepositoryConnection conn = getRepositoryConnection(); +159 Stream<RDF4JQuad> stream = null; +160 try { +161 final RepositoryResult<Statement> statements = conn.getStatements(subj, pred, obj, includeInferred, contexts); +162 // NOTE: Iterations.stream should close RepositoryResult as long as +163 // our caller closes the stream +164 stream = Iterations.stream(statements).map(rdf4jTermFactory::asQuad); +165 } finally { +166 if (stream == null) { +167 // Some exception before we made the stream, close connection +168 // here +169 conn.close(); +170 } +171 } +172 // Make sure the RepositoryConnection is closed +173 return stream.onClose(conn::close); +174 +175 } +176 +177 @Override +178 public ClosableIterable<Quad> iterate() throws ConcurrentModificationException, IllegalStateException { +179 return iterate(null, null, null, null); +180 } +181 +182 @Override +183 public ClosableIterable<Quad> iterate(final Optional<BlankNodeOrIRI> graphName, final BlankNodeOrIRI subject, final IRI predicate, +184 final RDFTerm object) throws ConcurrentModificationException, IllegalStateException { +185 final Resource[] contexts = asContexts(graphName); +186 final Resource subj = (Resource) rdf4jTermFactory.asValue(subject); +187 final org.eclipse.rdf4j.model.IRI pred = (org.eclipse.rdf4j.model.IRI) rdf4jTermFactory.asValue(predicate); +188 final Value obj = rdf4jTermFactory.asValue(object); +189 return new ConvertedStatements<>(this::getRepositoryConnection, rdf4jTermFactory::asQuad, subj, pred, obj, +190 contexts); +191 } +192 +193 @Override +194 protected RDF4JQuad asTripleLike(final Statement s) { +195 return rdf4jTermFactory.asQuad(s); +196 } +197 +198 @Override +199 public Graph getGraph() { +200 // default context only +201 // NOTE: We carry over the 'salt' as the graph's BlankNode should be +202 // equal to our BlankNodes +203 return new RepositoryGraphImpl(repository, salt, false, includeInferred, (Resource) null); +204 } +205 +206 @Override +207 public Optional<Graph> getGraph(final BlankNodeOrIRI graphName) { +208 // NOTE: May be null to indicate default context +209 final Resource context = (Resource) rdf4jTermFactory.asValue(graphName); +210 // NOTE: We carry over the 'salt' as the graph's BlankNode should be +211 // equal to our BlankNodes +212 return Optional.of(new RepositoryGraphImpl(repository, salt, false, includeInferred, context)); +213 } +214 +215 @Override +216 public Stream<BlankNodeOrIRI> getGraphNames() { +217 final RepositoryConnection conn = getRepositoryConnection(); +218 final RepositoryResult<Resource> contexts = conn.getContextIDs(); +219 return Iterations.stream(contexts).map(g -> (BlankNodeOrIRI) rdf4jTermFactory.asRDFTerm(g)) +220 .onClose(conn::close); +221 } +222 +223 }