This is an automated email from the ASF dual-hosted git repository. andy pushed a commit to branch main in repository https://gitbox.apache.org/repos/asf/jena.git
commit c713d25f29f747f018c4dc8fe346ab28cf71bf1f Author: Andy Seaborne <[email protected]> AuthorDate: Mon Nov 10 08:26:17 2025 +0000 GH-3580: Remove Graph Capabilities and Graph.dependsOn --- .../main/java/org/apache/jena/rdfs/GraphRDFS.java | 7 - .../org/apache/jena/sparql/graph/GraphFactory.java | 18 +- .../org/apache/jena/sparql/graph/GraphWrapper.java | 6 - .../java/org/apache/jena/graph/Capabilities.java | 48 -- .../src/main/java/org/apache/jena/graph/Graph.java | 22 - .../java/org/apache/jena/graph/compose/Delta.java | 12 +- .../java/org/apache/jena/graph/compose/Dyadic.java | 9 - .../org/apache/jena/graph/compose/Polyadic.java | 16 - .../apache/jena/graph/impl/AllCapabilities.java | 45 -- .../apache/jena/graph/impl/BaseCapabilities.java | 35 -- .../java/org/apache/jena/graph/impl/GraphBase.java | 523 ++++++++++----------- .../org/apache/jena/graph/impl/GraphPlain.java | 9 +- .../jena/graph/impl/WrappedCapabilities.java | 51 -- .../org/apache/jena/graph/impl/WrappedGraph.java | 10 - .../main/java/org/apache/jena/mem/GraphMem.java | 6 - .../org/apache/jena/reasoner/BaseInfGraph.java | 55 --- .../java/org/apache/jena/reasoner/Reasoner.java | 9 - .../reasoner/rulesys/BasicForwardRuleReasoner.java | 11 - .../jena/reasoner/rulesys/FBRuleReasoner.java | 10 - .../reasoner/rulesys/LPBackwardRuleReasoner.java | 10 - .../jena/reasoner/rulesys/OWLMicroReasoner.java | 22 +- .../jena/reasoner/rulesys/OWLMiniReasoner.java | 12 - .../jena/reasoner/rulesys/RDFSFBRuleReasoner.java | 15 +- .../reasoner/rulesys/RDFSForwardRuleReasoner.java | 15 +- .../jena/reasoner/rulesys/RDFSRuleReasoner.java | 11 - .../transitiveReasoner/TransitiveReasoner.java | 18 +- .../apache/jena/graph/test/AbstractTestGraph.java | 9 - .../org/apache/jena/graph/test/TestGraphPlain.java | 4 +- .../java/org/apache/jena/mem2/GraphMem2Test.java | 15 - .../rulesys/test/FRuleEngineIFactoryTest.java | 4 - .../apache/jena/ontapi/impl/UnionGraphImpl.java | 13 - .../java/org/apache/jena/ontapi/utils/Graphs.java | 12 - .../org/apache/jena/ontapi/UnionGraphTest.java | 61 +-- 33 files changed, 293 insertions(+), 830 deletions(-) diff --git a/jena-arq/src/main/java/org/apache/jena/rdfs/GraphRDFS.java b/jena-arq/src/main/java/org/apache/jena/rdfs/GraphRDFS.java index 10f736fbd5..0fdece6ad2 100644 --- a/jena-arq/src/main/java/org/apache/jena/rdfs/GraphRDFS.java +++ b/jena-arq/src/main/java/org/apache/jena/rdfs/GraphRDFS.java @@ -80,11 +80,4 @@ public class GraphRDFS extends GraphWrapper { // Even better, don't ask. return super.size(); } - - @Override - public boolean dependsOn(Graph other) { - if ( other == super.get() ) - return true; - return super.dependsOn(other); - } } diff --git a/jena-arq/src/main/java/org/apache/jena/sparql/graph/GraphFactory.java b/jena-arq/src/main/java/org/apache/jena/sparql/graph/GraphFactory.java index 953d9e44af..ee0d6e7006 100644 --- a/jena-arq/src/main/java/org/apache/jena/sparql/graph/GraphFactory.java +++ b/jena-arq/src/main/java/org/apache/jena/sparql/graph/GraphFactory.java @@ -18,9 +18,8 @@ package org.apache.jena.sparql.graph; -import org.apache.jena.graph.GraphMemFactory; import org.apache.jena.graph.Graph; -import org.apache.jena.graph.impl.GraphPlain; +import org.apache.jena.graph.GraphMemFactory; import org.apache.jena.rdf.model.Model; import org.apache.jena.rdf.model.ModelFactory; import org.apache.jena.sys.JenaSystem; @@ -91,16 +90,6 @@ public class GraphFactory { return GraphMemFactory.createDefaultGraph(); } - /** - * Graph that uses same-term for find() and contains(). - * - * @deprecated From Jena5, graphs are all "same term" except for {@link org.apache.jena.mem.GraphMem}. - */ - @Deprecated - public static Graph createPlainGraph() { - return GraphPlain.plain(); - } - public static Graph sinkGraph() { return new GraphSink(); } @@ -114,9 +103,4 @@ public class GraphFactory { public static Model makeDefaultModel() { return ModelFactory.createModelForGraph(createDefaultGraph()); } - - /** Create a model over a plain graph (small-scale use only) */ - public static Model makePlainModel() { - return ModelFactory.createModelForGraph(createPlainGraph()); - } } diff --git a/jena-arq/src/main/java/org/apache/jena/sparql/graph/GraphWrapper.java b/jena-arq/src/main/java/org/apache/jena/sparql/graph/GraphWrapper.java index f44d5dff4a..07ea41d6df 100644 --- a/jena-arq/src/main/java/org/apache/jena/sparql/graph/GraphWrapper.java +++ b/jena-arq/src/main/java/org/apache/jena/sparql/graph/GraphWrapper.java @@ -40,12 +40,6 @@ public class GraphWrapper implements Graph get().add(t); } - @SuppressWarnings("removal") - @Override - public boolean dependsOn(Graph other) { - return get().dependsOn(other); - } - @Override public TransactionHandler getTransactionHandler() { return get().getTransactionHandler(); diff --git a/jena-core/src/main/java/org/apache/jena/graph/Capabilities.java b/jena-core/src/main/java/org/apache/jena/graph/Capabilities.java deleted file mode 100644 index 31938d9ab4..0000000000 --- a/jena-core/src/main/java/org/apache/jena/graph/Capabilities.java +++ /dev/null @@ -1,48 +0,0 @@ -/* - * Licensed to the Apache Software Foundation (ASF) under one - * or more contributor license agreements. See the NOTICE file - * distributed with this work for additional information - * regarding copyright ownership. The ASF licenses this file - * to you under the Apache License, Version 2.0 (the - * "License"); you may not use this file except in compliance - * with the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package org.apache.jena.graph; - -/** - * Interface for expressing capabilities. - */ -@Deprecated(forRemoval = true) -public interface Capabilities { - /** - * Answer true iff Graph::size() is accurate. - */ - boolean sizeAccurate(); - - /** - * Answer true iff {@link Graph#add} can be used to add at least some triples to - * the graph. - */ - boolean addAllowed(); - - /** - * Answer true iff {@link Graph#delete} can be used to remove at least some - * triples from the graph. - */ - boolean deleteAllowed(); - - /** - * Answer true iff this graph compares literals for equality by value in find() - * operations, rather than applying RDFTerm equality. - */ - boolean handlesLiteralTyping(); -} diff --git a/jena-core/src/main/java/org/apache/jena/graph/Graph.java b/jena-core/src/main/java/org/apache/jena/graph/Graph.java index 72424da11f..48d2a9cd77 100644 --- a/jena-core/src/main/java/org/apache/jena/graph/Graph.java +++ b/jena-core/src/main/java/org/apache/jena/graph/Graph.java @@ -22,7 +22,6 @@ import java.util.Objects; import java.util.stream.Stream; import org.apache.jena.atlas.iterator.Iter; -import org.apache.jena.graph.impl.AllCapabilities; import org.apache.jena.graph.impl.GraphBase ; import org.apache.jena.shared.AddDeniedException ; import org.apache.jena.shared.DeleteDeniedException ; @@ -59,30 +58,9 @@ public interface Graph { } }; - /** - true if this graph's content depends on the other graph. May be - pessimistic (i.e. return true if it's not sure). Typically true when a - graph is a composition of other graphs, eg union. - - @param other the graph this graph may depend on - @return false if this does not depend on other - @deprecated To be removed. - */ - @Deprecated(forRemoval = true) - boolean dependsOn( Graph other ); - /** returns this Graph's transaction handler */ TransactionHandler getTransactionHandler(); - /** - * returns this Graph's capabilities - * @deprecated To be removed. - */ - @Deprecated(forRemoval = true) - default Capabilities getCapabilities() { - return AllCapabilities.updateAllowed; - } - /** Answer this Graph's event manager. */ diff --git a/jena-core/src/main/java/org/apache/jena/graph/compose/Delta.java b/jena-core/src/main/java/org/apache/jena/graph/compose/Delta.java index eeea73cee5..fe9dbf2481 100644 --- a/jena-core/src/main/java/org/apache/jena/graph/compose/Delta.java +++ b/jena-core/src/main/java/org/apache/jena/graph/compose/Delta.java @@ -32,9 +32,9 @@ import org.apache.jena.util.iterator.ExtendedIterator; */ public class Delta extends CompositionBase implements Graph { - private Graph base; - private Graph additions; - private Graph deletions; + private final Graph base; + private final Graph additions; + private final Graph deletions; @SuppressWarnings("deprecation") public Delta(Graph base) { @@ -44,12 +44,6 @@ public class Delta extends CompositionBase implements Graph { this.deletions = GraphPlain.plain(); } -// @Override -// public Capabilities getCapabilities() { -// // Not strictly accurate. -// return base.getCapabilities(); -// } - /** * Answer the graph of all triples added. */ diff --git a/jena-core/src/main/java/org/apache/jena/graph/compose/Dyadic.java b/jena-core/src/main/java/org/apache/jena/graph/compose/Dyadic.java index e7208a41dd..2412d0e760 100644 --- a/jena-core/src/main/java/org/apache/jena/graph/compose/Dyadic.java +++ b/jena-core/src/main/java/org/apache/jena/graph/compose/Dyadic.java @@ -63,15 +63,6 @@ public abstract class Dyadic extends CompositionBase { this.closed = true; } - /** - * Generic dependsOn, true iff it depends on either of the subgraphs. - */ - @SuppressWarnings("removal") - @Override - public boolean dependsOn(Graph other) { - return other == this || L.dependsOn(other) || R.dependsOn(other); - } - public Union union(Graph X) { return new Union(this, X); } diff --git a/jena-core/src/main/java/org/apache/jena/graph/compose/Polyadic.java b/jena-core/src/main/java/org/apache/jena/graph/compose/Polyadic.java index 8c531dcdc1..a1a4abe9ce 100755 --- a/jena-core/src/main/java/org/apache/jena/graph/compose/Polyadic.java +++ b/jena-core/src/main/java/org/apache/jena/graph/compose/Polyadic.java @@ -133,22 +133,6 @@ public abstract class Polyadic extends CompositionBase super.close(); } - - /** - * <p> - * Answer true if this graph contains the given graph as a sub-component. - * </p> - * - * @param graph A graph to test - * @return True if the graph is this graph, or is a sub-graph of this one. - * @see org.apache.jena.graph.Graph#dependsOn(Graph) - */ - @Override - public boolean dependsOn( Graph graph ) { - return (graph == this) || m_subGraphs.contains( graph ); - } - - /** * <p> * Add the given graph to this composition. diff --git a/jena-core/src/main/java/org/apache/jena/graph/impl/AllCapabilities.java b/jena-core/src/main/java/org/apache/jena/graph/impl/AllCapabilities.java deleted file mode 100644 index 818ee51092..0000000000 --- a/jena-core/src/main/java/org/apache/jena/graph/impl/AllCapabilities.java +++ /dev/null @@ -1,45 +0,0 @@ -/* - * Licensed to the Apache Software Foundation (ASF) under one - * or more contributor license agreements. See the NOTICE file - * distributed with this work for additional information - * regarding copyright ownership. The ASF licenses this file - * to you under the Apache License, Version 2.0 (the - * "License"); you may not use this file except in compliance - * with the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package org.apache.jena.graph.impl; - -import org.apache.jena.graph.Capabilities ; - -@SuppressWarnings("removal") -public class AllCapabilities { - - public static Capabilities updateAllowed = create(true, true, true, false); - - public static Capabilities updateNotAllowed = create(true, false, false, false); - - public static Capabilities updateAllowedWithValues = create(true, true, true, true); - - public static Capabilities create(boolean sizeAccurate, - boolean addAllowed, - boolean deleteAllowed, - boolean handlesLiteralTyping - ) { - return new Capabilities() { - @Override public boolean sizeAccurate() { return sizeAccurate; } - @Override public boolean addAllowed() { return addAllowed; } - @Override public boolean deleteAllowed() { return deleteAllowed; } - @Override public boolean handlesLiteralTyping() { return handlesLiteralTyping; } - }; - - } -} diff --git a/jena-core/src/main/java/org/apache/jena/graph/impl/BaseCapabilities.java b/jena-core/src/main/java/org/apache/jena/graph/impl/BaseCapabilities.java deleted file mode 100644 index 2ffc186f97..0000000000 --- a/jena-core/src/main/java/org/apache/jena/graph/impl/BaseCapabilities.java +++ /dev/null @@ -1,35 +0,0 @@ -/* - * Licensed to the Apache Software Foundation (ASF) under one - * or more contributor license agreements. See the NOTICE file - * distributed with this work for additional information - * regarding copyright ownership. The ASF licenses this file - * to you under the Apache License, Version 2.0 (the - * "License"); you may not use this file except in compliance - * with the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package org.apache.jena.graph.impl; - -import org.apache.jena.graph.Capabilities; - -/** - * Support the old style "subclass" way to choose capabilities. - * <p> - * The settings are the - * general default: allow update, size is accurate, and term value semantics. - */ -@SuppressWarnings("removal") -public class BaseCapabilities implements Capabilities { - @Override public boolean sizeAccurate() { return true; } - @Override public boolean addAllowed() { return true; } - @Override public boolean deleteAllowed() { return true; } - @Override public boolean handlesLiteralTyping() { return false; } -} diff --git a/jena-core/src/main/java/org/apache/jena/graph/impl/GraphBase.java b/jena-core/src/main/java/org/apache/jena/graph/impl/GraphBase.java index 668b495bf3..9c03627dff 100644 --- a/jena-core/src/main/java/org/apache/jena/graph/impl/GraphBase.java +++ b/jena-core/src/main/java/org/apache/jena/graph/impl/GraphBase.java @@ -19,348 +19,345 @@ package org.apache.jena.graph.impl; import org.apache.jena.atlas.iterator.Iter; -import org.apache.jena.graph.* ; -import org.apache.jena.shared.AddDeniedException ; -import org.apache.jena.shared.ClosedException ; -import org.apache.jena.shared.DeleteDeniedException ; -import org.apache.jena.shared.PrefixMapping ; -import org.apache.jena.shared.impl.PrefixMappingImpl ; -import org.apache.jena.util.iterator.ClosableIterator ; -import org.apache.jena.util.iterator.ExtendedIterator ; +import org.apache.jena.graph.*; +import org.apache.jena.shared.AddDeniedException; +import org.apache.jena.shared.ClosedException; +import org.apache.jena.shared.DeleteDeniedException; +import org.apache.jena.shared.PrefixMapping; +import org.apache.jena.shared.impl.PrefixMappingImpl; +import org.apache.jena.util.iterator.ClosableIterator; +import org.apache.jena.util.iterator.ExtendedIterator; /** - GraphBase is an implementation of Graph that provides some convenient - base functionality for Graph implementations. -<p> - Subtypes of GraphBase must provide performAdd(Triple), performDelete(Triple), - graphBaseFind(TripleMatch,TripleAction), and graphBaseSize(). GraphBase - provides default implementations of the other methods, including the other finds - (on top of that one), a simple-minded prepare, and contains. GraphBase also - handles the event-listening and registration interfaces. -<p> - When a GraphBase is closed, future operations on it may throw an exception. - -*/ - -public abstract class GraphBase implements GraphWithPerform - { + * GraphBase is an implementation of Graph that provides some convenient base + * functionality for Graph implementations. + * <p> + * Subtypes of GraphBase must provide performAdd(Triple), performDelete(Triple), + * graphBaseFind(TripleMatch,TripleAction), and graphBaseSize(). GraphBase provides + * default implementations of the other methods, including the other finds (on top of + * that one), a simple-minded prepare, and contains. GraphBase also handles the + * event-listening and registration interfaces. + * <p> + * When a GraphBase is closed, future operations on it may throw an exception. + */ + +public abstract class GraphBase implements GraphWithPerform { /** - Whether or not this graph has been closed - used to report ClosedExceptions - when an operation is attempted on a closed graph. - */ + * Whether or not this graph has been closed - used to report ClosedExceptions + * when an operation is attempted on a closed graph. + */ protected boolean closed = false; /** - Initialise this graph. - */ - public GraphBase() {} + * Initialise this graph. + */ + public GraphBase() {} /** - Initialise this graph with the given reification style (which will be supplied to - the reifier when it is created). - */ + * Initialise this graph with the given reification style (which will be supplied + * to the reifier when it is created). + */ /** - Utility method: throw a ClosedException if this graph has been closed. - */ - protected void checkOpen() - { if (closed) throw new ClosedException( "already closed", this ); } + * Utility method: throw a ClosedException if this graph has been closed. + */ + protected void checkOpen() { + if ( closed ) + throw new ClosedException("already closed", this); + } /** - Close this graph. Subgraphs may extend to discard resources. - */ + * Close this graph. Subgraphs may extend to discard resources. + */ @Override - public void close() - { - closed = true ; + public void close() { + closed = true; } @Override - public boolean isClosed() - { return closed; } - - /** - Default implementation answers <code>true</code> iff this graph is the - same graph as the argument graph. - */ - @SuppressWarnings("removal") - @Override - public boolean dependsOn( Graph other ) - { return this == other; } + public boolean isClosed() { + return closed; + } /** - Answer the event manager for this graph; allocate a new one if required. - Subclasses may override if they have a more specialised event handler. - The default is a SimpleEventManager. - */ + * Answer the event manager for this graph; allocate a new one if required. + * Subclasses may override if they have a more specialised event handler. The + * default is a SimpleEventManager. + */ @Override - public GraphEventManager getEventManager() - { - if (gem == null) gem = new SimpleEventManager( ); + public GraphEventManager getEventManager() { + if ( gem == null ) + gem = new SimpleEventManager(); return gem; - } + } /** - The event manager that this Graph uses to, well, manage events; allocated on - demand. - */ + * The event manager that this Graph uses to, well, manage events; allocated on + * demand. + */ protected GraphEventManager gem; - /** - Tell the event manager that the triple <code>t</code> has been added to the graph. - */ - public void notifyAdd( Triple t ) - { getEventManager().notifyAddTriple( this, t ); } + * Tell the event manager that the triple <code>t</code> has been added to the + * graph. + */ + public void notifyAdd(Triple t) { + getEventManager().notifyAddTriple(this, t); + } /** - Tell the event manager that the triple <code>t</code> has been deleted from the - graph. - */ - public void notifyDelete( Triple t ) - { getEventManager().notifyDeleteTriple( this, t ); } + * Tell the event manager that the triple <code>t</code> has been deleted from + * the graph. + */ + public void notifyDelete(Triple t) { + getEventManager().notifyDeleteTriple(this, t); + } /** - Answer a transaction handler bound to this graph. The default is - SimpleTransactionHandler, which handles <i>no</i> transactions. - */ + * Answer a transaction handler bound to this graph. The default is + * SimpleTransactionHandler, which handles <i>no</i> transactions. + */ @Override - public TransactionHandler getTransactionHandler() - { return new SimpleTransactionHandler(); } + public TransactionHandler getTransactionHandler() { + return new SimpleTransactionHandler(); + } /** - Answer the PrefixMapping object for this graph, the same one each time. + * Answer the PrefixMapping object for this graph, the same one each time. */ @Override - public PrefixMapping getPrefixMapping() - { + public PrefixMapping getPrefixMapping() { if ( pm == null ) - pm = createPrefixMapping() ; + pm = createPrefixMapping(); return pm; } - protected PrefixMapping pm = null ; - protected PrefixMapping createPrefixMapping() { return new PrefixMappingImpl() ; } - - /** - Add a triple, and notify the event manager. Subclasses should not need to - override this - we might make it final. The triple is added using performAdd, - and notification done by notifyAdd. - */ - @Override - public void add( Triple t ) - { + protected PrefixMapping pm = null; + protected PrefixMapping createPrefixMapping() { + return new PrefixMappingImpl(); + } + + /** + * Add a triple, and notify the event manager. Subclasses should not need to + * override this - we might make it final. The triple is added using performAdd, + * and notification done by notifyAdd. + */ + @Override + public void add(Triple t) { checkOpen(); - performAdd( t ); - notifyAdd( t ); - } + performAdd(t); + notifyAdd(t); + } /** - Add a triple to the triple store. The default implementation throws an - AddDeniedException; subclasses must override if they want to be able to - add triples. - */ + * Add a triple to the triple store. The default implementation throws an + * AddDeniedException; subclasses must override if they want to be able to add + * triples. + */ @Override - public void performAdd( Triple t ) - { throw new AddDeniedException( "GraphBase::performAdd" ); } + public void performAdd(Triple t) { + throw new AddDeniedException("GraphBase::performAdd"); + } - /** - Delete a triple, and notify the event manager. Subclasses should not need to - override this - we might make it final. The triple is added using performDelete, - and notification done by notifyDelete. - */ + /** + * Delete a triple, and notify the event manager. Subclasses should not need to + * override this - we might make it final. The triple is added using + * performDelete, and notification done by notifyDelete. + */ @Override - public final void delete( Triple t ) - { + public final void delete(Triple t) { checkOpen(); - performDelete( t ); - notifyDelete( t ); - } + performDelete(t); + notifyDelete(t); + } /** - Remove a triple from the triple store. The default implementation throws - a DeleteDeniedException; subclasses must override if they want to be able - to remove triples. - */ - @Override - public void performDelete( Triple t ) - { throw new DeleteDeniedException( "GraphBase::delete" ); } + * Remove a triple from the triple store. The default implementation throws a + * DeleteDeniedException; subclasses must override if they want to be able to + * remove triples. + */ + @Override + public void performDelete(Triple t) { + throw new DeleteDeniedException("GraphBase::delete"); + } /** - Remove all the statements from this graph. + * Remove all the statements from this graph. */ - @Override - public void clear() - { - GraphUtil.remove(this, Node.ANY, Node.ANY, Node.ANY) ; - getEventManager().notifyEvent(this, GraphEvents.removeAll ) ; - } - - /** - Remove all triples that match by find(s, p, o) - */ - @Override - public void remove( Node s, Node p, Node o ) - { - GraphUtil.remove(this, s, p, o) ; - getEventManager().notifyEvent(this, GraphEvents.remove(s, p, o) ) ; - } + @Override + public void clear() { + GraphUtil.remove(this, Node.ANY, Node.ANY, Node.ANY); + getEventManager().notifyEvent(this, GraphEvents.removeAll); + } + /** + * Remove all triples that match by find(s, p, o) + */ @Override - public final ExtendedIterator<Triple> find(Triple m) - { - checkOpen() ; - return graphBaseFind(m) ; + public void remove(Node s, Node p, Node o) { + GraphUtil.remove(this, s, p, o); + getEventManager().notifyEvent(this, GraphEvents.remove(s, p, o)); } - protected abstract ExtendedIterator<Triple> graphBaseFind( Triple triplePattern ); + @Override + public final ExtendedIterator<Triple> find(Triple m) { + checkOpen(); + return graphBaseFind(m); + } - public ExtendedIterator<Triple> forTestingOnly_graphBaseFind( Triple t ) - { return graphBaseFind( t ); } + protected abstract ExtendedIterator<Triple> graphBaseFind(Triple triplePattern); + + public ExtendedIterator<Triple> forTestingOnly_graphBaseFind(Triple t) { + return graphBaseFind(t); + } @Override - public final ExtendedIterator<Triple> find( Node s, Node p, Node o ) - { checkOpen(); - return graphBaseFind( s, p, o ); } + public final ExtendedIterator<Triple> find(Node s, Node p, Node o) { + checkOpen(); + return graphBaseFind(s, p, o); + } - protected ExtendedIterator<Triple> graphBaseFind( Node s, Node p, Node o ) - { return find( Triple.createMatch( s, p, o ) ); } + protected ExtendedIterator<Triple> graphBaseFind(Node s, Node p, Node o) { + return find(Triple.createMatch(s, p, o)); + } + + /** + * Answer <code>true</code> iff <code>t</code> is in the graph as revealed by + * <code>find(t)</code> being non-empty. <code>t</code> may contain ANY + * wildcards. Sub-classes may over-ride graphBaseContains for efficiency. + */ + @Override + public final boolean contains(Triple t) { + checkOpen(); + return graphBaseContains(t); + } /** - Answer <code>true</code> iff <code>t</code> is in the graph as revealed by - <code>find(t)</code> being non-empty. <code>t</code> may contain ANY - wildcards. Sub-classes may over-ride graphBaseContains - for efficiency. - */ - @Override - public final boolean contains( Triple t ) - { checkOpen(); - return graphBaseContains( t ); } - - /** - Answer true if the graph contains any triple matching <code>t</code>. - The default implementation uses <code>find</code> and checks to see - if the iterator is non-empty. - */ - protected boolean graphBaseContains( Triple t ) - { return containsByFind( t ); } + * Answer true if the graph contains any triple matching <code>t</code>. The + * default implementation uses <code>find</code> and checks to see if the + * iterator is non-empty. + */ + protected boolean graphBaseContains(Triple t) { + return containsByFind(t); + } /** - Answer <code>true</code> if this graph contains <code>(s, p, o)</code>; - this canonical implementation cannot be over-ridden. - */ - @Override - public final boolean contains( Node s, Node p, Node o ) { + * Answer <code>true</code> if this graph contains <code>(s, p, o)</code>; this + * canonical implementation cannot be over-ridden. + */ + @Override + public final boolean contains(Node s, Node p, Node o) { checkOpen(); - return contains( Triple.createMatch( s, p, o ) ); - } + return contains(Triple.createMatch(s, p, o)); + } /** - Utility method: answer true iff we can find at least one instantiation of - the triple in this graph using find(TripleMatch). - - @param t Triple that is the pattern to match - @return true iff find(t) returns at least one result - */ - final protected boolean containsByFind( Triple t ) - { - ClosableIterator<Triple> it = find( t ); - try { return it.hasNext(); } finally { it.close(); } + * Utility method: answer true iff we can find at least one instantiation of the + * triple in this graph using find(TripleMatch). + * + * @param t Triple that is the pattern to match + * @return true iff find(t) returns at least one result + */ + final protected boolean containsByFind(Triple t) { + ClosableIterator<Triple> it = find(t); + try { + return it.hasNext(); + } finally { + it.close(); } + } - /** - Answer the size of this graph (ie the number of exposed triples). Defined as - the size of the triple store plus the size of the reification store. Subclasses - must override graphBaseSize() to reimplement (and reifierSize if they have - some special reason for redefined that). - */ + /** + * Answer the size of this graph (ie the number of exposed triples). Defined as + * the size of the triple store plus the size of the reification store. + * Subclasses must override graphBaseSize() to reimplement (and reifierSize if + * they have some special reason for redefined that). + */ @Override - public final int size() - { - checkOpen() ; - return graphBaseSize() ; + public final int size() { + checkOpen(); + return graphBaseSize(); } /** - Answer the number of triples in this graph. Default implementation counts its - way through the results of a findAll. Subclasses must override if they want - size() to be efficient. - */ - protected int graphBaseSize() - { - ExtendedIterator<Triple> it = GraphUtil.findAll( this ); - try - { - return (int) Iter.count(it); - } - finally - { it.close(); } + * Answer the number of triples in this graph. Default implementation counts its + * way through the results of a findAll. Subclasses must override if they want + * size() to be efficient. + */ + protected int graphBaseSize() { + ExtendedIterator<Triple> it = GraphUtil.findAll(this); + try { + return (int)Iter.count(it); + } finally { + it.close(); } + } /** - Answer true iff this graph contains no triples. - @implNote The default implementation relies on {@link #contains(Triple)} - with {@link Triple#ANY} as the argument. Subclasses may override if necessary. - */ + * Answer true iff this graph contains no triples. + * + * @implNote The default implementation relies on {@link #contains(Triple)} with + * {@link Triple#ANY} as the argument. Subclasses may override if necessary. + */ @Override - public boolean isEmpty() - { - return !contains( Triple.ANY ); - } + public boolean isEmpty() { + return !contains(Triple.ANY); + } /** - Answer true iff this graph is isomorphic to <code>g</code> according to - the algorithm (indeed, method) in <code>GraphMatcher</code>. - */ - @Override - public boolean isIsomorphicWith( Graph g ) - { checkOpen(); - return g != null && GraphMatcher.equals( this, g ); } - - /** - Answer a human-consumable representation of this graph. Not advised for - big graphs, as it generates a big string: intended for debugging purposes. - */ - - @Override public String toString() - { return toString( (closed ? "closed " : ""), this ); } - - /** - toString will not cut off up to this number of triples. - */ - public static final int TOSTRING_TRIPLE_BASE = 10; - - /** - toString will not output more than this number of triples. - */ - public static final int TOSTRING_TRIPLE_LIMIT = 17; + * Answer true iff this graph is isomorphic to <code>g</code> according to the + * algorithm (indeed, method) in <code>GraphMatcher</code>. + */ + @Override + public boolean isIsomorphicWith(Graph g) { + checkOpen(); + return g != null && GraphMatcher.equals(this, g); + } /** - Answer a human-consumable representation of <code>that</code>. The - string <code>prefix</code> will appear near the beginning of the string. Nodes - may be prefix-compressed using <code>that</code>'s prefix-mapping. This - default implementation will display all the triples exposed by the graph (ie - including reification triples if it is Standard). - */ - public static String toString( String prefix, Graph that ) - { - PrefixMapping pm = that.getPrefixMapping(); - StringBuilder b = new StringBuilder( prefix + " {" ); - int count = 0; - String gap = ""; - ClosableIterator<Triple> it = GraphUtil.findAll( that ); - while (it.hasNext() && count < TOSTRING_TRIPLE_LIMIT) - { - b.append( gap ); - gap = "; "; - count += 1; - b.append( it.next().toString( pm ) ); - } - if (it.hasNext()) b.append( "..." ); - it.close(); - b.append( "}" ); - return b.toString(); - } + * Answer a human-consumable representation of this graph. Not advised for big + * graphs, as it generates a big string: intended for debugging purposes. + */ + + @Override + public String toString() { + return toString((closed ? "closed " : ""), this); + } + /** + * toString will not cut off up to this number of triples. + */ + public static final int TOSTRING_TRIPLE_BASE = 10; + + /** + * toString will not output more than this number of triples. + */ + public static final int TOSTRING_TRIPLE_LIMIT = 17; + + /** + * Answer a human-consumable representation of <code>that</code>. The string + * <code>prefix</code> will appear near the beginning of the string. Nodes may be + * prefix-compressed using <code>that</code>'s prefix-mapping. This default + * implementation will display all the triples exposed by the graph (ie including + * reification triples if it is Standard). + */ + public static String toString(String prefix, Graph that) { + PrefixMapping pm = that.getPrefixMapping(); + StringBuilder b = new StringBuilder(prefix + " {"); + int count = 0; + String gap = ""; + ClosableIterator<Triple> it = GraphUtil.findAll(that); + while (it.hasNext() && count < TOSTRING_TRIPLE_LIMIT) { + b.append(gap); + gap = "; "; + count += 1; + b.append(it.next().toString(pm)); + } + if ( it.hasNext() ) + b.append("..."); + it.close(); + b.append("}"); + return b.toString(); + } } diff --git a/jena-core/src/main/java/org/apache/jena/graph/impl/GraphPlain.java b/jena-core/src/main/java/org/apache/jena/graph/impl/GraphPlain.java index 5b46af032a..33922e0700 100644 --- a/jena-core/src/main/java/org/apache/jena/graph/impl/GraphPlain.java +++ b/jena-core/src/main/java/org/apache/jena/graph/impl/GraphPlain.java @@ -21,6 +21,7 @@ package org.apache.jena.graph.impl; import java.util.function.Predicate; import org.apache.jena.graph.* ; +import org.apache.jena.mem.GraphMem; import org.apache.jena.rdf.model.impl.Util ; import org.apache.jena.util.iterator.ExtendedIterator ; @@ -43,18 +44,20 @@ public class GraphPlain extends WrappedGraph */ @Deprecated public static Graph plain(Graph base) { - if ( ! base.getCapabilities().handlesLiteralTyping() ) + if ( ! GraphMem.class.isInstance(base) ) + // No need to do anything. return base; return new GraphPlain(base); } /** * Return a graph that only has term-equality. - * @deprecated From Jena5, graphs are all "same term". + * @deprecated From Jena5, graphs are all "same term", + * except {@link GraphMem} which is only used in the Model API. */ @Deprecated public static Graph plain() { - return plain(GraphMemFactory.createDefaultGraph()); + return GraphMemFactory.createDefaultGraph(); } private GraphPlain(Graph other) { diff --git a/jena-core/src/main/java/org/apache/jena/graph/impl/WrappedCapabilities.java b/jena-core/src/main/java/org/apache/jena/graph/impl/WrappedCapabilities.java deleted file mode 100644 index d24b70066c..0000000000 --- a/jena-core/src/main/java/org/apache/jena/graph/impl/WrappedCapabilities.java +++ /dev/null @@ -1,51 +0,0 @@ -/* - * Licensed to the Apache Software Foundation (ASF) under one - * or more contributor license agreements. See the NOTICE file - * distributed with this work for additional information - * regarding copyright ownership. The ASF licenses this file - * to you under the Apache License, Version 2.0 (the - * "License"); you may not use this file except in compliance - * with the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package org.apache.jena.graph.impl; - -import org.apache.jena.graph.Capabilities; - -@SuppressWarnings("removal") -public class WrappedCapabilities implements Capabilities { - - protected final Capabilities other; - - public WrappedCapabilities(Capabilities other) { - this.other = other; - } - - @Override - public boolean sizeAccurate() { - return other.sizeAccurate(); - } - - @Override - public boolean addAllowed() { - return other.addAllowed(); - } - - @Override - public boolean deleteAllowed() { - return other.deleteAllowed(); - } - - @Override - public boolean handlesLiteralTyping() { - return other.handlesLiteralTyping(); - } -} diff --git a/jena-core/src/main/java/org/apache/jena/graph/impl/WrappedGraph.java b/jena-core/src/main/java/org/apache/jena/graph/impl/WrappedGraph.java index 777e285039..505756fef4 100644 --- a/jena-core/src/main/java/org/apache/jena/graph/impl/WrappedGraph.java +++ b/jena-core/src/main/java/org/apache/jena/graph/impl/WrappedGraph.java @@ -35,20 +35,10 @@ public class WrappedGraph implements GraphWithPerform public WrappedGraph( Graph base ) { this.base = base; } - @SuppressWarnings("removal") - @Override - public boolean dependsOn( Graph other ) - { return base.dependsOn( other ); } - @Override public TransactionHandler getTransactionHandler() { return base.getTransactionHandler(); } - @Deprecated(forRemoval = true) - @Override - public Capabilities getCapabilities() - { return base.getCapabilities(); } - @Override public GraphEventManager getEventManager() { diff --git a/jena-core/src/main/java/org/apache/jena/mem/GraphMem.java b/jena-core/src/main/java/org/apache/jena/mem/GraphMem.java index ff5f7de363..b19c11e95c 100644 --- a/jena-core/src/main/java/org/apache/jena/mem/GraphMem.java +++ b/jena-core/src/main/java/org/apache/jena/mem/GraphMem.java @@ -19,7 +19,6 @@ package org.apache.jena.mem; import org.apache.jena.graph.* ; -import org.apache.jena.graph.impl.AllCapabilities; import org.apache.jena.graph.impl.TripleStore ; import org.apache.jena.util.iterator.ExtendedIterator ; @@ -101,9 +100,4 @@ public class GraphMem extends GraphMemBase { public void clearStore() { store.clear(); } - - @Override - public Capabilities getCapabilities() { - return AllCapabilities.updateAllowedWithValues; - } } diff --git a/jena-core/src/main/java/org/apache/jena/reasoner/BaseInfGraph.java b/jena-core/src/main/java/org/apache/jena/reasoner/BaseInfGraph.java index ef52d03ca2..82d0c105d9 100644 --- a/jena-core/src/main/java/org/apache/jena/reasoner/BaseInfGraph.java +++ b/jena-core/src/main/java/org/apache/jena/reasoner/BaseInfGraph.java @@ -22,7 +22,6 @@ import java.util.Iterator; import org.apache.jena.graph.* ; import org.apache.jena.graph.compose.MultiUnion ; -import org.apache.jena.graph.impl.AllCapabilities; import org.apache.jena.graph.impl.GraphBase; import org.apache.jena.graph.impl.TransactionHandlerBase; import org.apache.jena.shared.PrefixMapping; @@ -48,9 +47,6 @@ public abstract class BaseInfGraph extends GraphBase implements InfGraph { /** version count */ protected volatile int version = 0; - @SuppressWarnings("removal") - private Capabilities infCapabilities; - /** Inference graphs share the prefix-mapping of their underlying raw graph. @see org.apache.jena.graph.Graph#getPrefixMapping() @@ -69,57 +65,8 @@ public abstract class BaseInfGraph extends GraphBase implements InfGraph { super( ); this.fdata = new FGraph( data ); this.reasoner = reasoner; - this.infCapabilities = calcCapabilitiesFrom(data); - } - - @SuppressWarnings("removal") - private Capabilities calcCapabilitiesFrom(Graph data) { - if ( data == null ) - return reasonerInfCapabilities; - - // Same as data graph except size is not accurate. - Capabilities baseCapabilities = data.getCapabilities(); - return AllCapabilities.create(false, - data.getCapabilities().addAllowed(), - data.getCapabilities().deleteAllowed(), - data.getCapabilities().handlesLiteralTyping()); - } - - /** - Answer the InfCapabilities of this InfGraph. - */ - @SuppressWarnings("removal") - @Override - public Capabilities getCapabilities() { - return infCapabilities; } - /** - * Capabilities that a reason must conform to. - * A base graph may also provide handling literal datatypes. - */ - - @SuppressWarnings("removal") - public static Capabilities reasonerInfCapabilities = new Capabilities() { - @Override - public boolean sizeAccurate() { return false; } - - // Reasoners do not require update. - @Override - public boolean addAllowed() { return false; } - - // Reasoners do not require update. - @Override - public boolean deleteAllowed() { return false; } - - /** - * Reasoners require "same term" but if the data graph supports "same value", - * then the reasoners will also support it. - */ - @Override - public boolean handlesLiteralTyping() { return false; } - }; - @Override public void remove( Node s, Node p, Node o ) { @@ -206,9 +153,7 @@ public abstract class BaseInfGraph extends GraphBase implements InfGraph { @Override public synchronized void rebind(Graph data) { fdata = new FGraph(data); - infCapabilities = calcCapabilitiesFrom(data); isPrepared = false; - } /** diff --git a/jena-core/src/main/java/org/apache/jena/reasoner/Reasoner.java b/jena-core/src/main/java/org/apache/jena/reasoner/Reasoner.java index 20fa465423..4000990fd1 100644 --- a/jena-core/src/main/java/org/apache/jena/reasoner/Reasoner.java +++ b/jena-core/src/main/java/org/apache/jena/reasoner/Reasoner.java @@ -135,13 +135,4 @@ public interface Reasoner { * @return true if the given property is handled specially by the reasoner. */ public boolean supportsProperty(Property property); - - /** - * Return the Jena Graph Capabilties that the inference graphs generated - * by this reasoner are expected to conform to. - * @deprecated Do not use - to be removed. - * Use the inference graph capabilities. - */ - @Deprecated - public org.apache.jena.graph.Capabilities getGraphCapabilities(); } diff --git a/jena-core/src/main/java/org/apache/jena/reasoner/rulesys/BasicForwardRuleReasoner.java b/jena-core/src/main/java/org/apache/jena/reasoner/rulesys/BasicForwardRuleReasoner.java index d4e326bf57..8f1a137a56 100755 --- a/jena-core/src/main/java/org/apache/jena/reasoner/rulesys/BasicForwardRuleReasoner.java +++ b/jena-core/src/main/java/org/apache/jena/reasoner/rulesys/BasicForwardRuleReasoner.java @@ -207,15 +207,4 @@ public class BasicForwardRuleReasoner implements Reasoner { throw new IllegalParameterException("Don't recognize configuration parameter " + parameter + " for rule-based reasoner"); } } - - - /** - * Return the Jena Graph Capabilities that the inference graphs generated - * by this reasoner are expected to conform to. - */ - @Deprecated - @Override - public Capabilities getGraphCapabilities() { - return BaseInfGraph.reasonerInfCapabilities; - } } diff --git a/jena-core/src/main/java/org/apache/jena/reasoner/rulesys/FBRuleReasoner.java b/jena-core/src/main/java/org/apache/jena/reasoner/rulesys/FBRuleReasoner.java index bc3f6ac4e9..b13f1b9130 100644 --- a/jena-core/src/main/java/org/apache/jena/reasoner/rulesys/FBRuleReasoner.java +++ b/jena-core/src/main/java/org/apache/jena/reasoner/rulesys/FBRuleReasoner.java @@ -400,14 +400,4 @@ public class FBRuleReasoner implements RuleReasoner { return false; } } - - /** - * Return the Jena Graph Capabilities that the inference graphs generated - * by this reasoner are expected to conform to. - */ - @Deprecated - @Override - public Capabilities getGraphCapabilities() { - return BaseInfGraph.reasonerInfCapabilities; - } } diff --git a/jena-core/src/main/java/org/apache/jena/reasoner/rulesys/LPBackwardRuleReasoner.java b/jena-core/src/main/java/org/apache/jena/reasoner/rulesys/LPBackwardRuleReasoner.java index b10944b113..da271a2dbf 100644 --- a/jena-core/src/main/java/org/apache/jena/reasoner/rulesys/LPBackwardRuleReasoner.java +++ b/jena-core/src/main/java/org/apache/jena/reasoner/rulesys/LPBackwardRuleReasoner.java @@ -213,14 +213,4 @@ public class LPBackwardRuleReasoner implements Reasoner { public void setParameter(Property parameter, Object value) { throw new IllegalParameterException(parameter.toString()); } - - /** - * Return the Jena Graph Capabilties that the inference graphs generated - * by this reasoner are expected to conform to. - */ - @Deprecated - @Override - public Capabilities getGraphCapabilities() { - return BaseInfGraph.reasonerInfCapabilities; - } } diff --git a/jena-core/src/main/java/org/apache/jena/reasoner/rulesys/OWLMicroReasoner.java b/jena-core/src/main/java/org/apache/jena/reasoner/rulesys/OWLMicroReasoner.java index 8a5720364e..b02bc0a4cb 100644 --- a/jena-core/src/main/java/org/apache/jena/reasoner/rulesys/OWLMicroReasoner.java +++ b/jena-core/src/main/java/org/apache/jena/reasoner/rulesys/OWLMicroReasoner.java @@ -18,11 +18,13 @@ package org.apache.jena.reasoner.rulesys; -import java.util.*; +import java.util.List; -import org.apache.jena.graph.Capabilities ; -import org.apache.jena.graph.Graph ; -import org.apache.jena.reasoner.* ; +import org.apache.jena.graph.Graph; +import org.apache.jena.reasoner.InfGraph; +import org.apache.jena.reasoner.Reasoner; +import org.apache.jena.reasoner.ReasonerException; +import org.apache.jena.reasoner.ReasonerFactory; /** * Reasoner configuration for the OWL micro reasoner. @@ -64,17 +66,6 @@ public class OWLMicroReasoner extends GenericRuleReasoner implements Reasoner { setTransitiveClosureCaching(true); } - - /** - * Return the Jena Graph Capabilities that the inference graphs generated - * by this reasoner are expected to conform to. - */ - @Deprecated - @Override - public Capabilities getGraphCapabilities() { - return BaseInfGraph.reasonerInfCapabilities; - } - /** * Attach the reasoner to a set of RDF data to process. * The reasoner may already have been bound to specific rules or ontology @@ -92,5 +83,4 @@ public class OWLMicroReasoner extends GenericRuleReasoner implements Reasoner { ((FBRuleInfGraph)graph).setDatatypeRangeValidation(true); return graph; } - } diff --git a/jena-core/src/main/java/org/apache/jena/reasoner/rulesys/OWLMiniReasoner.java b/jena-core/src/main/java/org/apache/jena/reasoner/rulesys/OWLMiniReasoner.java index 0e7116efea..b5f048b26b 100644 --- a/jena-core/src/main/java/org/apache/jena/reasoner/rulesys/OWLMiniReasoner.java +++ b/jena-core/src/main/java/org/apache/jena/reasoner/rulesys/OWLMiniReasoner.java @@ -20,7 +20,6 @@ package org.apache.jena.reasoner.rulesys; import java.util.*; -import org.apache.jena.graph.Capabilities ; import org.apache.jena.graph.Graph ; import org.apache.jena.reasoner.* ; @@ -77,15 +76,4 @@ public class OWLMiniReasoner extends GenericRuleReasoner implements Reasoner { ((FBRuleInfGraph)graph).setDatatypeRangeValidation(true); return graph; } - - /** - * Return the Jena Graph Capabilties that the inference graphs generated - * by this reasoner are expected to conform to. - */ - @Deprecated - @Override - public Capabilities getGraphCapabilities() { - return BaseInfGraph.reasonerInfCapabilities; - } - } diff --git a/jena-core/src/main/java/org/apache/jena/reasoner/rulesys/RDFSFBRuleReasoner.java b/jena-core/src/main/java/org/apache/jena/reasoner/rulesys/RDFSFBRuleReasoner.java index 1bddbda400..b7316a4f44 100644 --- a/jena-core/src/main/java/org/apache/jena/reasoner/rulesys/RDFSFBRuleReasoner.java +++ b/jena-core/src/main/java/org/apache/jena/reasoner/rulesys/RDFSFBRuleReasoner.java @@ -18,10 +18,8 @@ package org.apache.jena.reasoner.rulesys; -import java.util.*; +import java.util.List; -import org.apache.jena.graph.Capabilities ; -import org.apache.jena.reasoner.BaseInfGraph ; import org.apache.jena.reasoner.ReasonerFactory ; /** @@ -50,15 +48,4 @@ public class RDFSFBRuleReasoner extends FBRuleReasoner { if (ruleSet == null) ruleSet = loadRules( RULE_FILE ); return ruleSet; } - - /** - * Return the Jena Graph Capabilities that the inference graphs generated - * by this reasoner are expected to conform to. - */ - @Deprecated - @Override - public Capabilities getGraphCapabilities() { - return BaseInfGraph.reasonerInfCapabilities; - } - } diff --git a/jena-core/src/main/java/org/apache/jena/reasoner/rulesys/RDFSForwardRuleReasoner.java b/jena-core/src/main/java/org/apache/jena/reasoner/rulesys/RDFSForwardRuleReasoner.java index 3b8c334b90..8b2c1eac4d 100644 --- a/jena-core/src/main/java/org/apache/jena/reasoner/rulesys/RDFSForwardRuleReasoner.java +++ b/jena-core/src/main/java/org/apache/jena/reasoner/rulesys/RDFSForwardRuleReasoner.java @@ -18,10 +18,8 @@ package org.apache.jena.reasoner.rulesys; -import java.util.*; +import java.util.List; -import org.apache.jena.graph.Capabilities ; -import org.apache.jena.reasoner.BaseInfGraph ; import org.apache.jena.reasoner.ReasonerFactory ; /** @@ -46,7 +44,6 @@ public class RDFSForwardRuleReasoner extends GenericRuleReasoner { */ public RDFSForwardRuleReasoner(ReasonerFactory parent) { super(loadRules(), parent); -// setMode(FORWARD_RETE); setMode(FORWARD); } @@ -57,14 +54,4 @@ public class RDFSForwardRuleReasoner extends GenericRuleReasoner { if (ruleSet == null) ruleSet = loadRules( RULE_FILE ); return ruleSet; } - - /** - * Return the Jena Graph Capabilities that the inference graphs generated - * by this reasoner are expected to conform to. - */ - @Deprecated - @Override - public Capabilities getGraphCapabilities() { - return BaseInfGraph.reasonerInfCapabilities; - } } diff --git a/jena-core/src/main/java/org/apache/jena/reasoner/rulesys/RDFSRuleReasoner.java b/jena-core/src/main/java/org/apache/jena/reasoner/rulesys/RDFSRuleReasoner.java index 1c10672ddf..e0f21a2544 100755 --- a/jena-core/src/main/java/org/apache/jena/reasoner/rulesys/RDFSRuleReasoner.java +++ b/jena-core/src/main/java/org/apache/jena/reasoner/rulesys/RDFSRuleReasoner.java @@ -205,15 +205,4 @@ public class RDFSRuleReasoner extends GenericRuleReasoner { } return ruleSet; } - - /** - * Return the Jena Graph Capabilities that the inference graphs generated - * by this reasoner are expected to conform to. - */ - @Deprecated - @Override - public Capabilities getGraphCapabilities() { - return BaseInfGraph.reasonerInfCapabilities; - } - } diff --git a/jena-core/src/main/java/org/apache/jena/reasoner/transitiveReasoner/TransitiveReasoner.java b/jena-core/src/main/java/org/apache/jena/reasoner/transitiveReasoner/TransitiveReasoner.java index 5b655f4966..25b8e328ac 100644 --- a/jena-core/src/main/java/org/apache/jena/reasoner/transitiveReasoner/TransitiveReasoner.java +++ b/jena-core/src/main/java/org/apache/jena/reasoner/transitiveReasoner/TransitiveReasoner.java @@ -18,8 +18,11 @@ package org.apache.jena.reasoner.transitiveReasoner; -import org.apache.jena.graph.* ; -import org.apache.jena.rdf.model.* ; +import org.apache.jena.graph.Graph; +import org.apache.jena.graph.Node; +import org.apache.jena.rdf.model.Model; +import org.apache.jena.rdf.model.Property; +import org.apache.jena.rdf.model.Resource; import org.apache.jena.reasoner.* ; import org.apache.jena.vocabulary.RDFS ; import org.apache.jena.vocabulary.ReasonerVocabulary ; @@ -231,15 +234,4 @@ public class TransitiveReasoner implements Reasoner { public Finder getTbox() { return tbox; } - - /** - * Return the Jena Graph Capabilties that the inference graphs generated - * by this reasoner are expected to conform to. - */ - @Deprecated - @Override - public Capabilities getGraphCapabilities() { - return BaseInfGraph.reasonerInfCapabilities; - } - } diff --git a/jena-core/src/test/java/org/apache/jena/graph/test/AbstractTestGraph.java b/jena-core/src/test/java/org/apache/jena/graph/test/AbstractTestGraph.java index 2d2d529bfa..a0ea93a306 100644 --- a/jena-core/src/test/java/org/apache/jena/graph/test/AbstractTestGraph.java +++ b/jena-core/src/test/java/org/apache/jena/graph/test/AbstractTestGraph.java @@ -328,15 +328,6 @@ public abstract class AbstractTestGraph extends GraphTestBase { } } - @SuppressWarnings("removal") - public void testHasCapabilities() { - Graph g = getNewGraph(); - Capabilities c = g.getCapabilities(); - boolean sa = c.sizeAccurate(); - boolean aaSome = c.addAllowed(); - boolean daSome = c.deleteAllowed(); - } - public void testFind() { Graph g = getNewGraph(); graphAdd(g, "S P O"); diff --git a/jena-core/src/test/java/org/apache/jena/graph/test/TestGraphPlain.java b/jena-core/src/test/java/org/apache/jena/graph/test/TestGraphPlain.java index 89d43ecf99..3a062416f7 100644 --- a/jena-core/src/test/java/org/apache/jena/graph/test/TestGraphPlain.java +++ b/jena-core/src/test/java/org/apache/jena/graph/test/TestGraphPlain.java @@ -35,7 +35,7 @@ import org.apache.jena.util.iterator.ExtendedIterator; import org.junit.BeforeClass; import org.junit.Test; -@SuppressWarnings({"deprecation", "removal"}) +@SuppressWarnings("deprecation") public class TestGraphPlain { private static Graph graph; @@ -45,8 +45,6 @@ public class TestGraphPlain { // GraphMem is the old in-memory graph which has value-based indexing. // It is not the default graph implementation. graph = new org.apache.jena.mem.GraphMem(); - if ( !graph.getCapabilities().handlesLiteralTyping() ) - throw new IllegalArgumentException("Test graph does not do the value thing"); graphAdd(graph, "s p o; s p 1; s p 01"); } diff --git a/jena-core/src/test/java/org/apache/jena/mem2/GraphMem2Test.java b/jena-core/src/test/java/org/apache/jena/mem2/GraphMem2Test.java index 2dedd9d474..f96b425d76 100644 --- a/jena-core/src/test/java/org/apache/jena/mem2/GraphMem2Test.java +++ b/jena-core/src/test/java/org/apache/jena/mem2/GraphMem2Test.java @@ -156,21 +156,6 @@ public class GraphMem2Test { verifyNoMoreInteractions(mockStore); } - @SuppressWarnings("removal") - @Test - public void testGetCapabilities() { - TripleStore mockStore = mock(); - - var sut = new GraphMem2(mockStore); - var capapbilities = sut.getCapabilities(); - - assertTrue(capapbilities.sizeAccurate()); - assertTrue(capapbilities.addAllowed()); - assertTrue(capapbilities.deleteAllowed()); - assertFalse(capapbilities.handlesLiteralTyping()); - - } - @Test public void testCopy() { TripleStore mockStore = mock(); diff --git a/jena-core/src/test/java/org/apache/jena/reasoner/rulesys/test/FRuleEngineIFactoryTest.java b/jena-core/src/test/java/org/apache/jena/reasoner/rulesys/test/FRuleEngineIFactoryTest.java index c9fe2efbee..57c3c10de2 100644 --- a/jena-core/src/test/java/org/apache/jena/reasoner/rulesys/test/FRuleEngineIFactoryTest.java +++ b/jena-core/src/test/java/org/apache/jena/reasoner/rulesys/test/FRuleEngineIFactoryTest.java @@ -127,10 +127,6 @@ public class FRuleEngineIFactoryTest extends TestCase { @Override public Iterator<Derivation> getDerivation(Triple triple) { return null; } - @SuppressWarnings("removal") - @Override - public boolean dependsOn(Graph other) { return false; } - @Override public TransactionHandler getTransactionHandler() { return null; } diff --git a/jena-ontapi/src/main/java/org/apache/jena/ontapi/impl/UnionGraphImpl.java b/jena-ontapi/src/main/java/org/apache/jena/ontapi/impl/UnionGraphImpl.java index cd4001017e..fdceb69e93 100644 --- a/jena-ontapi/src/main/java/org/apache/jena/ontapi/impl/UnionGraphImpl.java +++ b/jena-ontapi/src/main/java/org/apache/jena/ontapi/impl/UnionGraphImpl.java @@ -28,7 +28,6 @@ import org.apache.jena.graph.Triple; import org.apache.jena.graph.compose.CompositionBase; import org.apache.jena.graph.impl.SimpleEventManager; import org.apache.jena.ontapi.UnionGraph; -import org.apache.jena.ontapi.utils.Graphs; import org.apache.jena.ontapi.utils.Iterators; import org.apache.jena.shared.PrefixMapping; import org.apache.jena.util.iterator.ExtendedIterator; @@ -412,18 +411,6 @@ public class UnionGraphImpl extends CompositionBase implements UnionGraph { getAllUnderlyingUnionGraphs().forEach(x -> x.closed = true); } - /** - * Generic dependsOn, returns {@code true} iff this graph or any sub-graphs depend on the specified graph. - * - * @param other {@link Graph} - * @return boolean - */ - @Override - public boolean dependsOn(Graph other) { - return (other instanceof UnionGraphImpl && getAllUnderlyingUnionGraphs().contains(other)) - || Iterators.anyMatch(listSubGraphBases(), x -> Graphs.dependsOn(x, other)); - } - /** * Calculates and returns a {@code Set} of all indivisible {@link Graph graph}s * that are placed somewhere lower in the hierarchy. diff --git a/jena-ontapi/src/main/java/org/apache/jena/ontapi/utils/Graphs.java b/jena-ontapi/src/main/java/org/apache/jena/ontapi/utils/Graphs.java index 142fb6dbd9..14f652b9d9 100644 --- a/jena-ontapi/src/main/java/org/apache/jena/ontapi/utils/Graphs.java +++ b/jena-ontapi/src/main/java/org/apache/jena/ontapi/utils/Graphs.java @@ -751,18 +751,6 @@ public class Graphs { return res.lock(); } - /** - * Answers {@code true} if the left graph depends on the right one. - * - * @param left {@link Graph} - * @param right {@link Graph} - * @return {@code true} if the left argument graph is dependent on the right - */ - @SuppressWarnings("removal") - public static boolean dependsOn(Graph left, Graph right) { - return left == right || (left != null && left.dependsOn(right)); - } - /** * Lists all unique subject nodes in the given graph. * Warning: the result is temporary stored in-memory! diff --git a/jena-ontapi/src/test/java/org/apache/jena/ontapi/UnionGraphTest.java b/jena-ontapi/src/test/java/org/apache/jena/ontapi/UnionGraphTest.java index 375537109e..f0fd294e9f 100644 --- a/jena-ontapi/src/test/java/org/apache/jena/ontapi/UnionGraphTest.java +++ b/jena-ontapi/src/test/java/org/apache/jena/ontapi/UnionGraphTest.java @@ -18,7 +18,15 @@ package org.apache.jena.ontapi; -import org.apache.commons.lang3.StringUtils; +import java.util.Arrays; +import java.util.HashSet; +import java.util.List; +import java.util.Set; +import java.util.stream.Collectors; + +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.Test; + import org.apache.jena.graph.Graph; import org.apache.jena.graph.GraphMemFactory; import org.apache.jena.graph.NodeFactory; @@ -36,14 +44,6 @@ import org.apache.jena.sparql.graph.GraphReadOnly; import org.apache.jena.sparql.graph.GraphWrapper; import org.apache.jena.vocabulary.OWL2; import org.apache.jena.vocabulary.RDF; -import org.junit.jupiter.api.Assertions; -import org.junit.jupiter.api.Test; - -import java.util.Arrays; -import java.util.HashSet; -import java.util.List; -import java.util.Set; -import java.util.stream.Collectors; /** * To test {@link UnionGraph}. @@ -219,49 +219,6 @@ public class UnionGraphTest { Assertions.assertEquals(2, a.listSubGraphBases().toList().size()); } - @SuppressWarnings("removal") - @Test - public void testDependsOn() { - Graph g1 = GraphMemFactory.createGraphMem(); - Graph g2 = GraphMemFactory.createGraphMem(); - UnionGraphImpl a = new UnionGraphImpl(g1); - Assertions.assertTrue(a.dependsOn(a)); - Assertions.assertTrue(a.dependsOn(g1)); - Assertions.assertFalse(g1.dependsOn(a)); - Assertions.assertFalse(a.dependsOn(GraphMemFactory.createGraphMem())); - - UnionGraphImpl b = new UnionGraphImpl(g1); - UnionGraphImpl c = new UnionGraphImpl(GraphMemFactory.createGraphMem()); - a.addSubGraph(b.addSubGraph(c)); - Assertions.assertEquals(2, a.listSubGraphBases().toList().size()); - String tree = ModelTestUtils.importsTreeAsString(a); - Assertions.assertEquals(3, tree.split("\n").length); - Assertions.assertEquals(0, StringUtils.countMatches(tree, ModelTestUtils.RECURSIVE_GRAPH_IDENTIFIER)); - - Assertions.assertTrue(a.dependsOn(b)); - Assertions.assertTrue(a.dependsOn(c)); - Assertions.assertTrue(a.dependsOn(c.getBaseGraph())); - Assertions.assertFalse(a.dependsOn(g2)); - - UnionGraphImpl d = new UnionGraphImpl(createNamedGraph("d")); - c.addSubGraph(d); - // recursion: - d.addSubGraph(a); - Assertions.assertEquals(3, a.listSubGraphBases().toList().size()); - tree = ModelTestUtils.importsTreeAsString(a); - Assertions.assertEquals(5, tree.split("\n").length); - Assertions.assertEquals(4, StringUtils.countMatches(tree, ModelTestUtils.ANONYMOUS_ONTOLOGY_IDENTIFIER)); - Assertions.assertEquals(1, StringUtils.countMatches(tree, ModelTestUtils.RECURSIVE_GRAPH_IDENTIFIER)); - - Assertions.assertTrue(a.dependsOn(b)); - Assertions.assertTrue(a.dependsOn(c)); - Assertions.assertTrue(a.dependsOn(d)); - Assertions.assertTrue(c.dependsOn(d)); - Assertions.assertTrue(d.dependsOn(c)); - Assertions.assertTrue(d.dependsOn(a)); - Assertions.assertFalse(a.dependsOn(g2)); - } - @Test public void testListBaseGraphs1() { Graph a = createTestMemGraph("a");
