jena-owl2: rename Graphs#getBase -> Graphs#getPrimary + add Graphs#unwrap; remove UnionGraph#withBase (was useless); other changes; fix bug in UnionGraphImpl#remove

Author: sszuev

src/main/java/com/github/sszuev/jena/ontapi/OntModelFactory.java

@@ -85,7 +85,18 @@ public static UnionGraph createUnionGraph(Graph base) {
      * @see org.apache.jena.rdf.model.ModelFactory#createDefaultModel()
      */
     public static Model createDefaultModel() {
-        return new ModelCom(createDefaultGraph());
+        return createDefaultModel(createDefaultGraph());
+    }
+
+    /**
+     * Creates default RDF Model implementation wrapping the given graph.
+     *
+     * @param graph {@link Graph}, not {@code null}
+     * @return {@link Model}
+     * @see org.apache.jena.rdf.model.ModelFactory#createDefaultModel()
+     */
+    public static Model createDefaultModel(Graph graph) {
+        return new ModelCom(Objects.requireNonNull(graph));
     }
 
     /**
@@ -245,7 +256,7 @@ public static OntModel createModel(Graph graph, OntSpecification spec, GraphRepo
         UnionGraph union;
         if (graph instanceof UnionGraph) {
             union = (UnionGraph) graph;
-            Graphs.flatTree((UnionGraph) graph).forEach(it -> {
+            Graphs.flatHierarchy((UnionGraph) graph).forEach(it -> {
                 Graphs.findOntologyNameNode(it.getBaseGraph()).orElseGet(() -> Graphs.createOntologyHeaderNode(it, null));
                 ontUnionGraphRepository.put(it);
             });
@@ -256,7 +267,7 @@ public static OntModel createModel(Graph graph, OntSpecification spec, GraphRepo
                         .toString();
                 repository.put(name, it);
             });
-            union = ontUnionGraphRepository.put(Graphs.getBase(graph));
+            union = ontUnionGraphRepository.put(Graphs.getPrimary(graph));
         }
         ReasonerFactory reasonerFactory = spec.getReasonerFactory();
         if (reasonerFactory == null) {

src/main/java/com/github/sszuev/jena/ontapi/UnionGraph.java

@@ -85,15 +85,6 @@ public interface UnionGraph extends Graph {
      */
     UnionGraph removeSubGraph(Graph graph);
 
-    /**
-     * Creates a copy of this graph with replacement the base.
-     * Changing hierarchy of the new graph will change hierarchy of this graph and vice versa.
-     * This can be useful for building graph's manager.
-     * @param base {@code Graph}, new base, not {@code null}
-     * @return {@link UnionGraph} a new instance with new {@code base} but with the hierarchy inheriting from this graph
-     */
-    UnionGraph withBase(Graph base);
-
     /**
      * Adds the specified graph to the underlying graph collection if it is absent.
      *

src/main/java/com/github/sszuev/jena/ontapi/impl/UnionGraphImpl.java

@@ -206,7 +206,7 @@ public void remove(Node s, Node p, Node o) {
         Triple t = Triple.createMatch(s, p, o);
         UnionGraph.EventManager em = getEventManager();
         em.onDeleteTriple(this, t);
-        base.remove(s, p, o);
+        super.remove(s, p, o);
         em.notifyEvent(this, GraphEvents.remove(s, p, o));
     }
 
@@ -270,11 +270,6 @@ public UnionGraph removeSubGraph(Graph graph) {
         return this;
     }
 
-    @Override
-    public UnionGraph withBase(Graph base) {
-        return new UnionGraphImpl(base, getSubGraphs(), getEventManager(), isDistinct());
-    }
-
     protected void removeUnion(Graph graph) {
         if (!(graph instanceof UnionGraphImpl)) {
             return;
@@ -619,12 +614,12 @@ public void notifySuperGraphAdded(UnionGraph graph, UnionGraph superGraph) {
 
         @Override
         public void onRemoveSubGraph(UnionGraph graph, Graph subGraph) {
-            listeners(Listener.class).forEach(it -> it.onRemoveSubGraph(graph, graph));
+            listeners(Listener.class).forEach(it -> it.onRemoveSubGraph(graph, subGraph));
         }
 
         @Override
         public void notifySubGraphRemoved(UnionGraph graph, Graph subGraph) {
-            listeners(Listener.class).forEach(it -> it.notifySubGraphRemoved(graph, graph));
+            listeners(Listener.class).forEach(it -> it.notifySubGraphRemoved(graph, subGraph));
         }
 
         @Override

src/main/java/com/github/sszuev/jena/ontapi/impl/repositories/OntUnionGraphListener.java

@@ -62,8 +62,8 @@ public void onDeleteTriple(UnionGraph graph, Triple triple) {
 
     @Override
     public void onAddSubGraph(UnionGraph graph, Graph subGraph) {
-        if (Graphs.isOntGraph(Graphs.getBase(subGraph))) {
-            Node ontology = Graphs.findOntologyNameNode(Graphs.getBase(subGraph))
+        if (Graphs.isOntGraph(Graphs.getPrimary(subGraph))) {
+            Node ontology = Graphs.findOntologyNameNode(Graphs.getPrimary(subGraph))
                     .orElseThrow(() -> new OntJenaException.IllegalArgument("Unnamed or misconfigured graph is specified"));
             if (!ontology.isURI()) {
                 throw new OntJenaException.IllegalArgument("Anonymous graph specified");
@@ -80,7 +80,7 @@ public void onClear(UnionGraph graph) {
 
     @Override
     public void notifySubGraphAdded(UnionGraph thisGraph, Graph subGraph) {
-        if (Graphs.isOntGraph(Graphs.getBase(subGraph))) {
+        if (Graphs.isOntGraph(Graphs.getPrimary(subGraph))) {
             Graph ontSubGraphBase = OntUnionGraphRepository.getBase(subGraph);
             Node ontSubGraphIri = Graphs.findOntologyNameNode(ontSubGraphBase)
                     .filter(Node::isURI)

src/main/java/com/github/sszuev/jena/ontapi/utils/Graphs.java

@@ -10,9 +10,11 @@
 import org.apache.jena.graph.Triple;
 import org.apache.jena.graph.compose.Dyadic;
 import org.apache.jena.graph.compose.Polyadic;
+import org.apache.jena.graph.impl.WrappedGraph;
 import org.apache.jena.mem.GraphMem;
 import org.apache.jena.reasoner.InfGraph;
 import org.apache.jena.shared.PrefixMapping;
+import org.apache.jena.sparql.graph.GraphWrapper;
 import org.apache.jena.sparql.util.graph.GraphUtils;
 import org.apache.jena.util.iterator.ExtendedIterator;
 import org.apache.jena.util.iterator.NullIterator;
@@ -58,7 +60,7 @@ public class Graphs {
      *
      * @param graph {@link Graph}
      * @return {@code Stream} of {@link Graph}s
-     * @see Graphs#getBase(Graph)
+     * @see Graphs#getPrimary(Graph)
      * @see UnionGraph
      * @see Polyadic
      * @see Dyadic
@@ -77,12 +79,9 @@ public static Stream<Graph> directSubGraphs(Graph graph) {
     }
 
     /**
-     * Extracts the base (primary) base graph from a composite or wrapper graph if it is possible
+     * Gets the base (primary) base graph from a composite or wrapper graph if it is possible
      * otherwise returns the same graph.
      * If the specified graph is {@link Dyadic}, the left part is considered as base graph.
-     * Note: wrappers ({@link org.apache.jena.graph.impl.WrappedGraph} and {@link org.apache.jena.sparql.graph.GraphWrapper})
-     * are intentionally not included in the consideration:
-     * any sub-instances of that class are considered as indivisible.
      *
      * @param graph {@link Graph}
      * @return {@link Graph}
@@ -91,9 +90,37 @@ public static Stream<Graph> directSubGraphs(Graph graph) {
      * @see org.apache.jena.graph.compose.MultiUnion
      * @see Polyadic
      * @see Dyadic
+     */
+    public static Graph getPrimary(Graph graph) {
+        if (graph instanceof UnionGraph) {
+            return ((UnionGraph) graph).getBaseGraph();
+        }
+        if (graph instanceof Polyadic) {
+            return ((Polyadic) graph).getBaseGraph();
+        }
+        if (graph instanceof Dyadic) {
+            return ((Dyadic) graph).getL();
+        }
+        return graph;
+    }
+
+    /**
+     * Unwraps the base (primary) base graph from a composite or wrapper graph if it is possible
+     * otherwise returns the same graph.
+     * If the specified graph is {@link Dyadic}, the left part is considered as base graph.
+     *
+     * @param graph {@link Graph}
+     * @return {@link Graph}
+     * @see #isWrapper(Graph)
+     * @see UnionGraph
+     * @see org.apache.jena.graph.compose.MultiUnion
+     * @see Polyadic
+     * @see Dyadic
      * @see InfGraph
+     * @see GraphWrapper
+     * @see WrappedGraph
      */
-    public static Graph getBase(Graph graph) {
+    public static Graph unwrap(Graph graph) {
         if (isGraphMem(graph)) {
             return graph;
         }
@@ -105,6 +132,14 @@ public static Graph getBase(Graph graph) {
             if (!seen.add(g)) {
                 continue;
             }
+            if (g instanceof GraphWrapper) {
+                candidates.add(((GraphWrapper) g).get());
+                continue;
+            }
+            if (g instanceof WrappedGraph) {
+                candidates.add(((WrappedGraph) g).getWrapped());
+                continue;
+            }
             if (g instanceof UnionGraph) {
                 candidates.add(((UnionGraph) g).getBaseGraph());
                 continue;
@@ -125,6 +160,22 @@ public static Graph getBase(Graph graph) {
         return graph;
     }
 
+    /**
+     * Answers {@code true} if the given graph can be unwrapped.
+     *
+     * @param g {@link Graph}
+     * @return boolean
+     * @see #unwrap(Graph)
+     */
+    public static boolean isWrapper(Graph g) {
+        return g instanceof GraphWrapper ||
+                g instanceof WrappedGraph ||
+                g instanceof UnionGraph ||
+                g instanceof Polyadic ||
+                g instanceof Dyadic ||
+                g instanceof InfGraph;
+    }
+
     /**
      * Answers {@code true} if the graph specified is {@code GraphMem}.
      *
@@ -154,6 +205,20 @@ public static boolean isGraphInf(Graph graph) {
      * @return {@code Stream} of {@link Graph}s
      */
     public static Stream<Graph> dataGraphs(Graph graph) {
+        return flatTree(graph, Graphs::unwrap, Graphs::directSubGraphs);
+    }
+
+    /**
+     * Lists all indivisible data graphs extracted from the composite or wrapper graph;
+     *
+     * @param graph         {@link Graph}
+     * @param getBase       a {@link Function} to extract primary graph
+     * @param listSubGraphs a {@link Function} to extract subgraphs
+     * @return {@code Stream} of {@link Graph}s
+     */
+    public static Stream<Graph> flatTree(Graph graph,
+                                         Function<Graph, Graph> getBase,
+                                         Function<Graph, Stream<Graph>> listSubGraphs) {
         if (graph == null) {
             return Stream.empty();
         }
@@ -169,9 +234,9 @@ public static Stream<Graph> dataGraphs(Graph graph) {
             if (!seen.add(g)) {
                 continue;
             }
-            Graph bg = getBase(g);
+            Graph bg = getBase.apply(g);
             res.add(bg);
-            directSubGraphs(g).forEach(queue::add);
+            listSubGraphs.apply(g).forEach(queue::add);
         }
         return res.stream();
     }
@@ -184,7 +249,7 @@ public static Stream<Graph> dataGraphs(Graph graph) {
      * @return {@code boolean}
      */
     public static boolean isSameBase(Graph left, Graph right) {
-        return Objects.equals(getBase(left), getBase(right));
+        return Objects.equals(unwrap(left), unwrap(right));
     }
 
     /**
@@ -203,7 +268,7 @@ public static boolean isDistinct(Graph graph) {
         }
         if (graph instanceof UnionGraph) {
             UnionGraph u = (UnionGraph) graph;
-            return u.isDistinct() || !u.hasSubGraph() && isDistinct(getBase(u));
+            return u.isDistinct() || !u.hasSubGraph() && isDistinct(getPrimary(u));
         }
         return false;
     }
@@ -226,7 +291,7 @@ public static boolean isSized(Graph graph) {
         if (directSubGraphs(graph).findFirst().isPresent()) {
             return false;
         }
-        return isGraphMem(getBase(graph));
+        return isGraphMem(getPrimary(graph));
     }
 
     /**
@@ -243,7 +308,7 @@ public static long size(Graph graph) {
         if (directSubGraphs(graph).findFirst().isPresent()) {
             return Iterators.count(graph.find());
         }
-        return getBase(graph).size();
+        return getPrimary(graph).size();
     }
 
     /**
@@ -262,7 +327,7 @@ public static UnionGraph makeOntUnionFrom(Graph graph, Function<Graph, UnionGrap
         if (isGraphMem(graph)) {
             return wrapAsUnion.apply(graph);
         }
-        return makeOntUnion(getBase(graph), dataGraphs(graph).collect(Collectors.toSet()), wrapAsUnion);
+        return makeOntUnion(getPrimary(graph), dataGraphs(graph).collect(Collectors.toSet()), wrapAsUnion);
     }
 
     /**
@@ -314,14 +379,14 @@ public static UnionGraph makeOntUnion(Graph graph,
     }
 
     /**
-     * Lists all graphs in the tree which is specified as {@code UnionGraph}.
+     * Lists all graphs in the tree that is specified as {@code UnionGraph}.
      *
      * @param graph {@link UnionGraph}
      * @return {@code Stream} of {@link UnionGraph}s
      * @see UnionGraph#superGraphs()
      * @see UnionGraph#subGraphs()
      */
-    public static Stream<UnionGraph> flatTree(UnionGraph graph) {
+    public static Stream<UnionGraph> flatHierarchy(UnionGraph graph) {
         Objects.requireNonNull(graph);
         Set<UnionGraph> res = new LinkedHashSet<>();
         Deque<UnionGraph> queue = new ArrayDeque<>();
@@ -415,21 +480,40 @@ public static Node createOntologyHeaderNode(Graph graph, String uriOrNull) {
     }
 
     /**
-     * Creates a new ontology header ({@code node rdf:type owl:Ontology}) for the specified node,
+     * Creates (if absents) a new ontology header ({@code node rdf:type owl:Ontology}) for the specified node,
      * removing existing ontology headers (if any) and moving their contents to the new header.
+     * Note that a valid ontology must have a single header,
+     * but there could be multiple headers in imports closure.
      *
      * @param graph       {@link Graph}
      * @param newOntology {@link Node} the new ontology header (iri or blank)
      * @return {@code newOntology}
      */
     public static Node makeOntologyHeaderNode(Graph graph, Node newOntology) {
-        List<Triple> prev = Iterators.addAll(Iterators.flatMap(
+        Objects.requireNonNull(graph, "graph is null");
+        Objects.requireNonNull(newOntology, "ontology node is null");
+        Set<Triple> prev = Iterators.addAll(Iterators.flatMap(
                 graph.find(Node.ANY, RDF.type.asNode(), OWL.Ontology.asNode()),
-                it -> graph.find(it.getSubject(), Node.ANY, Node.ANY)), new ArrayList<>());
-
-        prev.forEach(graph::delete);
-        graph.add(newOntology, RDF.type.asNode(), OWL.Ontology.asNode());
-        prev.forEach(triple -> graph.add(newOntology, triple.getPredicate(), triple.getObject()));
+                it -> graph.find(it.getSubject(), Node.ANY, Node.ANY)), new HashSet<>());
+        Set<Node> subjects = prev.stream().map(Triple::getSubject).collect(Collectors.toSet());
+        if (subjects.contains(newOntology)) {
+            if (subjects.size() == 1) {
+                // nothing to do
+                return newOntology;
+            }
+        } else {
+            graph.add(newOntology, RDF.type.asNode(), OWL.Ontology.asNode());
+        }
+        prev.forEach(t -> {
+            if (!newOntology.equals(t.getSubject())) {
+                graph.delete(t);
+            }
+        });
+        prev.forEach(t -> {
+            if (!newOntology.equals(t.getSubject())) {
+                graph.add(newOntology, t.getPredicate(), t.getObject());
+            }
+        });
         return newOntology;
     }
 
@@ -713,7 +797,7 @@ public static Node createNode(String iri) {
     }
 
     /**
-     * Answers {@code true} if all parts of the given RDF triple are URIs (i.e. not blank nodes or literals).
+     * Answers {@code true} if all parts of the given RDF triple are URIs (i.e., not blank nodes or literals).
      *
      * @param triple a regular graph {@link Triple}, not {@code null}
      * @return {@code boolean}