ont-api: minor changes in axiom searchers and InternalModel (related to #reduce() and list* #methods) + add tests for OWLOntology#subClassAxiomsForSuperClass (#12)

sszuev · sszuev · commit 31977e9dea14 · 2020-05-06T23:07:15.000+03:00
diff --git a/src/main/java/com/github/owlcs/ontapi/OntBaseModelImpl.java b/src/main/java/com/github/owlcs/ontapi/OntBaseModelImpl.java
@@ -369,7 +369,7 @@ public <T extends OWLAxiom> Stream<T> axioms(AxiomType<T> axiomType) {
      */
     @Override
     public Stream<OWLClassAxiom> axioms(OWLClass clazz) {
-        Stream<? extends OWLClassAxiom> subClassOf = base.listOWLSubClassOfAxioms(clazz);
+        Stream<? extends OWLClassAxiom> subClassOf = base.listOWLSubClassOfAxiomsBySubject(clazz);
         Stream<? extends OWLClassAxiom> disjointUnion = base.listOWLAxioms(OWLDisjointUnionAxiom.class)
                 .filter(a -> Objects.equals(a.getOWLClass(), clazz));
         Stream<? extends OWLClassAxiom> disjoint = base.listOWLAxioms(OWLDisjointClassesAxiom.class)
@@ -588,7 +588,7 @@ public <A extends OWLAxiom> Stream<A> axioms(Class<A> type, OWLObject object, bo
         if (OWLSubClassOfAxiom.class.equals(type) && object instanceof OWLClassExpression) {
             OWLClassExpression c = (OWLClassExpression) object;
             if (c.isOWLClass() && sub) {
-                return (Stream<A>) base.listOWLSubClassOfAxioms(c.asOWLClass());
+                return (Stream<A>) base.listOWLSubClassOfAxiomsBySubject(c.asOWLClass());
             }
             return (Stream<A>) base.listOWLAxioms(OWLSubClassOfAxiom.class)
                     .filter(a -> c.equals(sub ? a.getSubClass() : a.getSuperClass()));
diff --git a/src/main/java/com/github/owlcs/ontapi/internal/BaseSearcher.java b/src/main/java/com/github/owlcs/ontapi/internal/BaseSearcher.java
@@ -153,7 +153,7 @@ protected final ExtendedIterator<OntStatement> listStatements(OntModel model) {
         return listStatements(model, null, null, null);
     }
 
-    private ExtendedIterator<OntStatement> listStatements(OntModel model, Resource s, Property p, RDFNode o) {
+    protected final ExtendedIterator<OntStatement> listStatements(OntModel model, Resource s, Property p, RDFNode o) {
         return OntModels.listLocalStatements(model, s, p, o);
     }
 }
diff --git a/src/main/java/com/github/owlcs/ontapi/internal/InternalModel.java b/src/main/java/com/github/owlcs/ontapi/internal/InternalModel.java
@@ -653,17 +653,16 @@ public Stream<OWLDeclarationAxiom> listOWLDeclarationAxioms(OWLEntity e) {
      * with the given {@link OWLAnnotationSubject subject}.
      * Note: method returns non-cached axioms.
      *
-     * @param s {@link OWLAnnotationSubject}, not {@code null}
+     * @param subject {@link OWLAnnotationSubject}, not {@code null}
      * @return {@code Stream} of {@link OWLAnnotationAssertionAxiom}s
      */
-    public Stream<OWLAnnotationAssertionAxiom> listOWLAnnotationAssertionAxioms(OWLAnnotationSubject s) {
+    public Stream<OWLAnnotationAssertionAxiom> listOWLAnnotationAssertionAxioms(OWLAnnotationSubject subject) {
         InternalConfig config = getConfig();
         if (!config.isLoadAnnotationAxioms()) return Stream.empty();
         if (!useAxiomsSearchOptimization(config)) {
-            return listOWLAxioms(OWLAnnotationAssertionAxiom.class).filter(a -> s.equals(a.getSubject()));
+            return listOWLAxioms(OWLAnnotationAssertionAxiom.class).filter(a -> subject.equals(a.getSubject()));
         }
-        return reduce(Iter.asStream(annotationAssertionsBySubject.listONTAxioms(s, getSearchModel(), getObjectFactory(), config)
-                .mapWith(ONTObject::getOWLObject)));
+        return listOWLAxioms(annotationAssertionsBySubject, subject, config);
     }
 
     /**
@@ -673,30 +672,35 @@ public Stream<OWLAnnotationAssertionAxiom> listOWLAnnotationAssertionAxioms(OWLA
      * @param sub {@link OWLClass}, not {@code null}
      * @return {@code Stream} of {@link OWLSubClassOfAxiom}s
      */
-    public Stream<OWLSubClassOfAxiom> listOWLSubClassOfAxioms(OWLClass sub) {
+    public Stream<OWLSubClassOfAxiom> listOWLSubClassOfAxiomsBySubject(OWLClass sub) {
         InternalConfig config = getConfig();
         if (!useAxiomsSearchOptimization(config)) {
             return listOWLAxioms(OWLSubClassOfAxiom.class).filter(a -> Objects.equals(a.getSubClass(), sub));
         }
-        return reduce(Iter.asStream(subClassOfBySubject.listONTAxioms(sub, getSearchModel(), getObjectFactory(), config)
-                .mapWith(ONTObject::getOWLObject)));
+        return listOWLAxioms(subClassOfBySubject, sub, config);
     }
 
     /**
      * Lists {@link OWLEquivalentClassesAxiom EquivalentClasses Axiom}s by the given {@link OWLClass class}-component.
      * Note: method returns non-cached axioms.
      *
-     * @param c {@link OWLClass}, not {@code null}
+     * @param clazz {@link OWLClass}, not {@code null}
      * @return {@code Stream} of {@link OWLEquivalentClassesAxiom}s
      * @see AbstractNaryTranslator#axioms(OntModel)
      */
-    public Stream<OWLEquivalentClassesAxiom> listOWLEquivalentClassesAxioms(OWLClass c) {
+    public Stream<OWLEquivalentClassesAxiom> listOWLEquivalentClassesAxioms(OWLClass clazz) {
         InternalConfig config = getConfig();
         if (!useAxiomsSearchOptimization(config)) {
-            return listOWLAxioms(OWLEquivalentClassesAxiom.class).filter(a -> a.operands().anyMatch(c::equals));
+            return listOWLAxioms(OWLEquivalentClassesAxiom.class).filter(a -> a.operands().anyMatch(clazz::equals));
         }
-        return reduce(Iter.asStream(equivalentClassesByOperand.listONTAxioms(c, getSearchModel(), getObjectFactory(), config)
-                .mapWith(ONTObject::getOWLObject)));
+        return listOWLAxioms(equivalentClassesByOperand, clazz, config);
+    }
+
+    protected <A extends OWLAxiom, K extends OWLObject> Stream<A> listOWLAxioms(ByObjectSearcher<A, K> searcher,
+                                                                                K parameter,
+                                                                                InternalConfig config) {
+        return reduce(searcher.listONTAxioms(parameter, getSearchModel(), getObjectFactory(), config)
+                .mapWith(ONTObject::getOWLObject));
     }
 
     /**
@@ -733,7 +737,7 @@ public Stream<OWLAxiom> listOWLAxioms(OWLPrimitive primitive) {
             } else {
                 throw new OntApiException.IllegalArgument("Wrong type: " + filter);
             }
-            return reduce(Iter.asStream(res.mapWith(ONTObject::getOWLObject)));
+            return reduce(res.mapWith(ONTObject::getOWLObject));
         }
         // the default way:
         if (OWLTopObjectType.ANNOTATION.hasComponent(filter)) {
@@ -922,7 +926,26 @@ protected <R> Stream<R> reduce(Stream<R> stream) {
         // Uniqueness is guaranteed by other mechanisms.
         // 1024 is a magic approximate number of axioms/objects; it is not tested yet.
         ArrayList<R> res = new ArrayList<>(1024);
-        stream.collect(Collectors.toCollection(() -> res));
+        stream.forEach(res::add);
+        res.trimToSize();
+        return res.stream();
+    }
+
+    /**
+     * Performs a final operation over the specified {@code stream} before releasing it out.
+     *
+     * @param stream {@code ExtendedIterator} of {@link R}s
+     * @param <R>    anything
+     * @return {@code Stream} of {@link R}s
+     * @see #reduce(Stream)
+     */
+    protected <R> Stream<R> reduce(ExtendedIterator<R> stream) {
+        InternalConfig conf = getConfig();
+        if (!conf.parallel() || !conf.useContentCache()) {
+            return Iter.asStream(stream);
+        }
+        ArrayList<R> res = new ArrayList<>(1024);
+        stream.forEachRemaining(res::add);
         res.trimToSize();
         return res.stream();
     }
diff --git a/src/main/java/com/github/owlcs/ontapi/internal/searchers/axioms/DeclarationByEntity.java b/src/main/java/com/github/owlcs/ontapi/internal/searchers/axioms/DeclarationByEntity.java
@@ -26,7 +26,7 @@
 import com.github.owlcs.ontapi.jena.model.OntStatement;
 import com.github.owlcs.ontapi.jena.utils.Iter;
 import com.github.owlcs.ontapi.jena.vocabulary.RDF;
-import org.apache.jena.graph.Node;
+import org.apache.jena.rdf.model.Resource;
 import org.apache.jena.util.iterator.ExtendedIterator;
 import org.semanticweb.owlapi.model.OWLDeclarationAxiom;
 import org.semanticweb.owlapi.model.OWLEntity;
@@ -42,11 +42,12 @@ public ExtendedIterator<ONTObject<OWLDeclarationAxiom>> listONTAxioms(OWLEntity
                                                                           OntModel model,
                                                                           ONTObjectFactory factory,
                                                                           AxiomsSettings config) {
-        Node node = WriteHelper.toNode(entity);
-        if (!model.independent() && !model.getBaseGraph().contains(node, RDF.type.asNode(), WriteHelper.getRDFType(entity).asNode())) {
-            return Iter.of();
+        Resource subject = WriteHelper.toResource(entity.getIRI());
+        if (!model.independent()) {
+            return listStatements(model, subject, RDF.type, WriteHelper.getRDFType(entity))
+                    .mapWith(x -> toAxiom(TRANSLATOR, x, factory, config));
         }
-        OntEntity res = PersonalityModel.asPersonalityModel(model).findNodeAs(node, WriteHelper.getEntityType(entity));
+        OntEntity res = PersonalityModel.asPersonalityModel(model).findNodeAs(subject.asNode(), WriteHelper.getEntityType(entity));
         if (res == null) return Iter.of();
         OntStatement statement = res.getMainStatement();
         return statement == null ? Iter.of() : Iter.of(toAxiom(TRANSLATOR, statement, factory, config));
diff --git a/src/test/java/com/github/owlcs/ontapi/tests/model/SearchByObjectTest.java b/src/test/java/com/github/owlcs/ontapi/tests/model/SearchByObjectTest.java
@@ -71,6 +71,11 @@ public void testSubClassAxiomsForSubClass() {
         data.doTest(T.SUB_CLASS_OF_BY_SUBJECT, HasClassesInSignature::classesInSignature);
     }
 
+    @Test
+    public void testSubClassAxiomsForSuperClass() {
+        data.doTest(T.SUB_CLASS_OF_BY_OBJECT, HasClassesInSignature::classesInSignature);
+    }
+
     @Test
     public void testEquivalentClassesAxioms() {
         data.doTest(T.EQUIVALENT_CLASS_BY_OPERAND, HasClassesInSignature::classesInSignature);
@@ -81,66 +86,77 @@ enum TestData {
                 T.DECLARATIONS.of(-5190508530L),
                 T.ANNOTATION_ASSERTIONS_BY_SUBJECT.of(5847447319L),
                 T.SUB_CLASS_OF_BY_SUBJECT.of(23994790843L),
+                T.SUB_CLASS_OF_BY_OBJECT.of(15875097811L),
                 T.EQUIVALENT_CLASS_BY_OPERAND.of(743207879L)
         ),
         FAMILY(ModelData.FAMILY,
                 T.DECLARATIONS.of(34226271096L),
                 T.ANNOTATION_ASSERTIONS_BY_SUBJECT.of(375920279L),
                 T.SUB_CLASS_OF_BY_SUBJECT.of(-405443220L),
+                T.SUB_CLASS_OF_BY_OBJECT.of(30468706L),
                 T.EQUIVALENT_CLASS_BY_OPERAND.of(1149278276L)
         ),
         PEOPLE(ModelData.PEOPLE,
                 T.DECLARATIONS.of(-31040926516L),
                 T.ANNOTATION_ASSERTIONS_BY_SUBJECT.of(14660248630L),
                 T.SUB_CLASS_OF_BY_SUBJECT.of(-6044474129L),
+                T.SUB_CLASS_OF_BY_OBJECT.of(-8307389053L),
                 T.EQUIVALENT_CLASS_BY_OPERAND.of(229986282L)
         ),
         CAMERA(ModelData.CAMERA,
                 T.DECLARATIONS.of(2967944221L),
                 T.ANNOTATION_ASSERTIONS_BY_SUBJECT.of(),
                 T.SUB_CLASS_OF_BY_SUBJECT.of(3537056616L),
+                T.SUB_CLASS_OF_BY_OBJECT.of(5364459487L),
                 T.EQUIVALENT_CLASS_BY_OPERAND.of(2619197590L)
         ),
         KOALA(ModelData.KOALA,
                 T.DECLARATIONS.of(6488467972L),
                 T.ANNOTATION_ASSERTIONS_BY_SUBJECT.of(2255627747L),
                 T.SUB_CLASS_OF_BY_SUBJECT.of(-4740693142L),
+                T.SUB_CLASS_OF_BY_OBJECT.of(-6410317539L),
                 T.EQUIVALENT_CLASS_BY_OPERAND.of(1433290824L)
         ),
         TRAVEL(ModelData.TRAVEL,
                 T.DECLARATIONS.of(-25825023334L),
                 T.ANNOTATION_ASSERTIONS_BY_SUBJECT.of(-3973926788L),
                 T.SUB_CLASS_OF_BY_SUBJECT.of(3792566851L),
+                T.SUB_CLASS_OF_BY_OBJECT.of(1596226755L),
                 T.EQUIVALENT_CLASS_BY_OPERAND.of(-1797460855L)
         ),
         WINE(ModelData.WINE,
                 T.DECLARATIONS.of(20065711780L),
                 T.ANNOTATION_ASSERTIONS_BY_SUBJECT.of(1282021579L),
                 T.SUB_CLASS_OF_BY_SUBJECT.of(23989074593L),
+                T.SUB_CLASS_OF_BY_OBJECT.of(-2872929990L),
                 T.EQUIVALENT_CLASS_BY_OPERAND.of(15637987080L)
         ),
         FOOD(ModelData.FOOD,
                 T.DECLARATIONS.of(6794851452L),
                 T.ANNOTATION_ASSERTIONS_BY_SUBJECT.of(),
                 T.SUB_CLASS_OF_BY_SUBJECT.of(-2766054837L),
+                T.SUB_CLASS_OF_BY_OBJECT.of(-490371437L),
                 T.EQUIVALENT_CLASS_BY_OPERAND.of(16744408703L)
         ),
         NCBITAXON_CUT(ModelData.NCBITAXON_CUT,
                 T.DECLARATIONS.of(244310200631L),
                 T.ANNOTATION_ASSERTIONS_BY_SUBJECT.of(120569949408L),
                 T.SUB_CLASS_OF_BY_SUBJECT.of(-1220817325L),
+                T.SUB_CLASS_OF_BY_OBJECT.of(-1220817325L),
                 T.EQUIVALENT_CLASS_BY_OPERAND.of()
         ),
         HP_CUT(ModelData.HP_CUT,
                 T.DECLARATIONS.of(-14640456193L),
                 T.ANNOTATION_ASSERTIONS_BY_SUBJECT.of(2061724906L),
                 T.SUB_CLASS_OF_BY_SUBJECT.of(-2245851740L),
+                T.SUB_CLASS_OF_BY_OBJECT.of(-2245851740L),
                 T.EQUIVALENT_CLASS_BY_OPERAND.of(-1475922263L)
         ),
         FAMILY_PEOPLE_UNION(ModelData.FAMILY_PEOPLE_UNION,
                 T.DECLARATIONS.of(-637777500L),
                 T.ANNOTATION_ASSERTIONS_BY_SUBJECT.of(-311728567L),
                 T.SUB_CLASS_OF_BY_SUBJECT.of(-730374961L),
+                T.SUB_CLASS_OF_BY_OBJECT.of(-730374961L),
                 T.EQUIVALENT_CLASS_BY_OPERAND.of(1108552553L)
         ),
         ;
@@ -187,6 +203,12 @@ Stream<? extends OWLObject> listAxioms(OWLOntology ont, OWLObject param) {
                 return ont.subClassAxiomsForSubClass((OWLClass) param);
             }
         },
+        SUB_CLASS_OF_BY_OBJECT {
+            @Override
+            Stream<? extends OWLObject> listAxioms(OWLOntology ont, OWLObject param) {
+                return ont.subClassAxiomsForSuperClass((OWLClass) param);
+            }
+        },
         EQUIVALENT_CLASS_BY_OPERAND {
             @Override
             Stream<? extends OWLObject> listAxioms(OWLOntology ont, OWLObject param) {

Original file line number	Diff line number	Diff line change
`@@ -153,7 +153,7 @@ protected final ExtendedIterator<OntStatement> listStatements(OntModel model) {`
`153`	`153`	`return listStatements(model, null, null, null);`
`154`	`154`	`}`
`155`	`155`
`156`		`- private ExtendedIterator<OntStatement> listStatements(OntModel model, Resource s, Property p, RDFNode o) {`
	`156`	`+ protected final ExtendedIterator<OntStatement> listStatements(OntModel model, Resource s, Property p, RDFNode o) {`
`157`	`157`	`return OntModels.listLocalStatements(model, s, p, o);`
`158`	`158`	`}`
`159`	`159`	`}`