ontapi: [#55] add axioms(OWLObject, Imports) impls

Author: sszuev

src/main/java/com/github/owlcs/ontapi/BaseOntologyModelImpl.java

@@ -654,10 +654,22 @@ public <T extends OWLAxiom> Stream<T> axioms(AxiomType<T> axiomType, Imports imp
      */
     @Override
     public Stream<OWLClassAxiom> axioms(OWLClass clazz) {
-        Stream<? extends OWLClassAxiom> subClassOf = base.listOWLSubClassOfAxiomsBySubject(clazz);
-        Stream<? extends OWLClassAxiom> disjointUnion = base.listOWLDisjointUnionAxioms(clazz);
-        Stream<? extends OWLClassAxiom> disjoint = base.listOWLDisjointClassesAxioms(clazz);
-        Stream<? extends OWLClassAxiom> equivalent = base.listOWLEquivalentClassesAxioms(clazz);
+        return listOWLAxioms(base, clazz);
+    }
+
+    @Override
+    public Stream<OWLClassAxiom> axioms(OWLClass clazz, Imports imports) {
+        if (imports == Imports.INCLUDED && !config.useContentCache()) {
+            return listOWLAxioms(getFullGraphModel(), clazz);
+        }
+        return imports.stream(this).flatMap(o -> o.axioms(clazz));
+    }
+
+    private static Stream<OWLClassAxiom> listOWLAxioms(InternalGraphModel model, OWLClass clazz) {
+        Stream<? extends OWLClassAxiom> subClassOf = model.listOWLSubClassOfAxiomsBySubject(clazz);
+        Stream<? extends OWLClassAxiom> disjointUnion = model.listOWLDisjointUnionAxioms(clazz);
+        Stream<? extends OWLClassAxiom> disjoint = model.listOWLDisjointClassesAxioms(clazz);
+        Stream<? extends OWLClassAxiom> equivalent = model.listOWLEquivalentClassesAxioms(clazz);
         return Stream.of(subClassOf, disjointUnion, disjoint, equivalent).flatMap(Function.identity());
     }
 
@@ -674,28 +686,39 @@ public Stream<OWLClassAxiom> axioms(OWLClass clazz) {
      * <li>7) Any property characteristic axiom (i.e. Functional, Symmetric, Reflexive etc.) whose subject is the specified property</li>
      * <li>8) Inverse properties axioms that contain the specified property</li>
      * </ul>
-     * <b>Note: either condition *3* or OWL-API-5.1.4 implementation (owlapi-impl) are wrong as shown by tests.</b>
      *
      * @param property The property whose defining axioms are to be retrieved
      * @return A {@code Stream} of object property axioms that describe the specified property
      */
     @Override
     public Stream<OWLObjectPropertyAxiom> axioms(OWLObjectPropertyExpression property) {
-        Stream<? extends OWLObjectPropertyAxiom> subPropertyOf = base.listOWLSubObjectPropertyOfAxiomsBySubject(property);
+        return listOWLAxioms(base, property);
+    }
+
+    @Override
+    public Stream<OWLObjectPropertyAxiom> axioms(OWLObjectPropertyExpression property, Imports imports) {
+        if (imports == Imports.INCLUDED && !config.useContentCache()) {
+            return listOWLAxioms(getFullGraphModel(), property);
+        }
+        return imports.stream(this).flatMap(o -> o.axioms(property));
+    }
+
+    private static Stream<OWLObjectPropertyAxiom> listOWLAxioms(InternalGraphModel model, OWLObjectPropertyExpression property) {
+        Stream<? extends OWLObjectPropertyAxiom> subPropertyOf = model.listOWLSubObjectPropertyOfAxiomsBySubject(property);
         Stream<? extends OWLObjectPropertyAxiom> nary = Stream.of(
-                base.listOWLEquivalentObjectPropertiesAxioms(property),
-                base.listOWLDisjointObjectPropertiesAxioms(property),
-                base.listOWLInverseObjectPropertiesAxioms(property)).flatMap(Function.identity());
+                model.listOWLEquivalentObjectPropertiesAxioms(property),
+                model.listOWLDisjointObjectPropertiesAxioms(property),
+                model.listOWLInverseObjectPropertiesAxioms(property)).flatMap(Function.identity());
         Stream<? extends OWLObjectPropertyAxiom> unary = Stream.of(
-                base.listOWLObjectPropertyDomainAxioms(property),
-                base.listOWLObjectPropertyRangeAxioms(property),
-                base.listOWLTransitiveObjectPropertyAxioms(property),
-                base.listOWLIrreflexiveObjectPropertyAxioms(property),
-                base.listOWLReflexiveObjectPropertyAxioms(property),
-                base.listOWLSymmetricObjectPropertyAxioms(property),
-                base.listOWLAsymmetricObjectPropertyAxioms(property),
-                base.listOWLFunctionalObjectPropertyAxioms(property),
-                base.listOWLInverseFunctionalObjectPropertyAxioms(property)).flatMap(Function.identity());
+                model.listOWLObjectPropertyDomainAxioms(property),
+                model.listOWLObjectPropertyRangeAxioms(property),
+                model.listOWLTransitiveObjectPropertyAxioms(property),
+                model.listOWLIrreflexiveObjectPropertyAxioms(property),
+                model.listOWLReflexiveObjectPropertyAxioms(property),
+                model.listOWLSymmetricObjectPropertyAxioms(property),
+                model.listOWLAsymmetricObjectPropertyAxioms(property),
+                model.listOWLFunctionalObjectPropertyAxioms(property),
+                model.listOWLInverseFunctionalObjectPropertyAxioms(property)).flatMap(Function.identity());
         return Stream.of(subPropertyOf, nary, unary).flatMap(Function.identity());
     }
 
@@ -716,14 +739,26 @@ public Stream<OWLObjectPropertyAxiom> axioms(OWLObjectPropertyExpression propert
      */
     @Override
     public Stream<OWLDataPropertyAxiom> axioms(OWLDataProperty property) {
-        Stream<? extends OWLDataPropertyAxiom> subPropertyOf = base.listOWLSubDataPropertyOfAxiomsBySubject(property);
+        return listOWLAxioms(base, property);
+    }
+
+    @Override
+    public Stream<OWLDataPropertyAxiom> axioms(OWLDataProperty property, Imports imports) {
+        if (imports == Imports.INCLUDED && !config.useContentCache()) {
+            return listOWLAxioms(getFullGraphModel(), property);
+        }
+        return imports.stream(this).flatMap(o -> o.axioms(property));
+    }
+
+    private static Stream<OWLDataPropertyAxiom> listOWLAxioms(InternalGraphModel model, OWLDataProperty property) {
+        Stream<? extends OWLDataPropertyAxiom> subPropertyOf = model.listOWLSubDataPropertyOfAxiomsBySubject(property);
         Stream<? extends OWLDataPropertyAxiom> nary = Stream.of(
-                base.listOWLEquivalentDataPropertiesAxioms(property),
-                base.listOWLDisjointDataPropertiesAxioms(property)).flatMap(Function.identity());
+                model.listOWLEquivalentDataPropertiesAxioms(property),
+                model.listOWLDisjointDataPropertiesAxioms(property)).flatMap(Function.identity());
         Stream<? extends OWLDataPropertyAxiom> unary = Stream.of(
-                base.listOWLDataPropertyDomainAxioms(property),
-                base.listOWLDataPropertyRangeAxioms(property),
-                base.listOWLFunctionalDataPropertyAxioms(property)).flatMap(Function.identity());
+                model.listOWLDataPropertyDomainAxioms(property),
+                model.listOWLDataPropertyRangeAxioms(property),
+                model.listOWLFunctionalDataPropertyAxioms(property)).flatMap(Function.identity());
         return Stream.of(subPropertyOf, nary, unary).flatMap(Function.identity());
     }
 
@@ -741,10 +776,22 @@ public Stream<OWLDataPropertyAxiom> axioms(OWLDataProperty property) {
      */
     @Override
     public Stream<OWLAnnotationAxiom> axioms(OWLAnnotationProperty property) {
+        return listOWLAxioms(base, property);
+    }
+
+    @Override
+    public Stream<OWLAnnotationAxiom> axioms(OWLAnnotationProperty property, Imports imports) {
+        if (imports == Imports.INCLUDED && !config.useContentCache()) {
+            return listOWLAxioms(getFullGraphModel(), property);
+        }
+        return imports.stream(this).flatMap(o -> o.axioms(property));
+    }
+
+    private static Stream<OWLAnnotationAxiom> listOWLAxioms(InternalGraphModel model, OWLAnnotationProperty property) {
         return Stream.of(
-                base.listOWLSubAnnotationPropertyOfAxiomsBySubject(property),
-                base.listOWLAnnotationPropertyDomainAxioms(property),
-                base.listOWLAnnotationPropertyRangeAxioms(property)).flatMap(Function.identity());
+                model.listOWLSubAnnotationPropertyOfAxiomsBySubject(property),
+                model.listOWLAnnotationPropertyDomainAxioms(property),
+                model.listOWLAnnotationPropertyRangeAxioms(property)).flatMap(Function.identity());
     }
 
     /**
@@ -765,14 +812,26 @@ public Stream<OWLAnnotationAxiom> axioms(OWLAnnotationProperty property) {
      */
     @Override
     public Stream<OWLIndividualAxiom> axioms(OWLIndividual individual) {
-        Stream<? extends OWLIndividualAxiom> classAssertion = base.listOWLClassAssertionAxioms(individual);
-        Stream<? extends OWLIndividualAxiom> nary = Stream.concat(base.listOWLSameIndividualAxioms(individual),
-                base.listOWLDifferentIndividualsAxioms(individual));
+        return listOWLAxioms(base, individual);
+    }
+
+    @Override
+    public Stream<OWLIndividualAxiom> axioms(OWLIndividual individual, Imports imports) {
+        if (imports == Imports.INCLUDED && !config.useContentCache()) {
+            return listOWLAxioms(getFullGraphModel(), individual);
+        }
+        return imports.stream(this).flatMap(o -> o.axioms(individual));
+    }
+
+    private static Stream<OWLIndividualAxiom> listOWLAxioms(InternalGraphModel model, OWLIndividual individual) {
+        Stream<? extends OWLIndividualAxiom> classAssertion = model.listOWLClassAssertionAxioms(individual);
+        Stream<? extends OWLIndividualAxiom> nary = Stream.concat(model.listOWLSameIndividualAxioms(individual),
+                model.listOWLDifferentIndividualsAxioms(individual));
         Stream<? extends OWLIndividualAxiom> propertyAssertion = Stream.of(
-                base.listOWLObjectPropertyAssertionAxioms(individual),
-                base.listOWLDataPropertyAssertionAxioms(individual),
-                base.listOWLNegativeObjectPropertyAssertionAxioms(individual),
-                base.listOWLNegativeDataPropertyAssertionAxioms(individual)).flatMap(Function.identity());
+                model.listOWLObjectPropertyAssertionAxioms(individual),
+                model.listOWLDataPropertyAssertionAxioms(individual),
+                model.listOWLNegativeObjectPropertyAssertionAxioms(individual),
+                model.listOWLNegativeDataPropertyAssertionAxioms(individual)).flatMap(Function.identity());
         return Stream.of(classAssertion, nary, propertyAssertion).flatMap(Function.identity());
     }
 
@@ -781,6 +840,14 @@ public Stream<OWLDatatypeDefinitionAxiom> axioms(OWLDatatype datatype) {
         return base.listOWLDatatypeDefinitionAxioms(datatype);
     }
 
+    @Override
+    public Stream<OWLDatatypeDefinitionAxiom> axioms(OWLDatatype datatype, Imports imports) {
+        if (imports == Imports.INCLUDED && !config.useContentCache()) {
+            return getFullGraphModel().listOWLDatatypeDefinitionAxioms(datatype);
+        }
+        return imports.stream(this).flatMap(o -> o.axioms(datatype));
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public <A extends OWLAxiom> Stream<A> axioms(OWLAxiomSearchFilter filter, Object key) {
@@ -791,7 +858,7 @@ public <A extends OWLAxiom> Stream<A> axioms(OWLAxiomSearchFilter filter, Object
      * The generic search method: results all axioms which refer the given object.
      * This method may walk over the whole axiom cache in the {@link #base internal model} or read graph directly,
      * as it sees fit.
-     * Functionally it differs from the original OWL-API method: it can handle a wider class of cases.
+     * Functionally, it differs from the original OWL-API method: it can handle a wider class of cases.
      * For internal usage only.
      *
      * @param type     {@link Class Class&lt;OWLAxiom&gt;}, not null, type of axiom

src/test/java/com/github/owlcs/ontapi/tests/model/InfOntModelTest.java

@@ -1,10 +1,13 @@
 package com.github.owlcs.ontapi.tests.model;
 
+import com.github.owlcs.ontapi.BlankNodeId;
 import com.github.owlcs.ontapi.DataFactory;
 import com.github.owlcs.ontapi.OntManagers;
 import com.github.owlcs.ontapi.Ontology;
 import com.github.owlcs.ontapi.OntologyManager;
 import org.apache.jena.ontapi.OntSpecification;
+import org.apache.jena.ontapi.model.OntDataRange;
+import org.apache.jena.ontapi.model.OntIndividual;
 import org.apache.jena.ontapi.model.OntModel;
 import org.apache.jena.vocabulary.OWL;
 import org.apache.jena.vocabulary.RDFS;
@@ -85,6 +88,78 @@ void testListAllAxiomsAndGetCounts() {
         Assertions.assertEquals(1, o1.getAxiomCount(AxiomType.EQUIVALENT_CLASSES, Imports.INCLUDED));
     }
 
+    @Test
+    void testListAxiomsByObject() {
+        OntologyManager om = OntManagers.createDirectManager();
+        DataFactory df = om.getOWLDataFactory();
+        om.getOntologyConfigurator().setSpecification(OntSpecification.OWL2_FULL_MEM_MICRO_RULES_INF);
+
+        OntModel m1 = om.createGraphModel("http://a#A");
+        OntModel m2 = om.createGraphModel("http://b#B");
+        m1.addImport(m2);
+
+        m2.createOntClass("http://b#C1")
+                .addEquivalentClass(
+                        m2.createOntClass("http://b#C2")
+                );
+        m1.createOntClass("http://a#C1");
+
+        m2.createIndividual("http://b#i1");
+        m1.createOntClass("http://a#C1");
+        m1.createObjectProperty("http://a#p2");
+        m1.createAnnotationProperty("http://a#p3").addSubProperty(
+                m1.createAnnotationProperty("http://a#p4")
+        );
+        m1.createDataProperty("http://a#p3").addSubProperty(
+                m2.createDataProperty("http://b#p1")
+        );
+        OntIndividual i1 = m1.createIndividual("http://b#i1", m2.getOntClass("http://b#C2"));
+        OntIndividual i2 = m2.createIndividual(null, m2.getOntClass("http://b#C1"));
+        i1.addSameAsStatement(i2);
+        OntDataRange d1 = m2.createDataOneOf(m2.createTypedLiteral(1), m2.createTypedLiteral(2));
+        OntDataRange d2 = m1.createDatatype("1&2").addEquivalentClass(d1);
+
+        Ontology o1 = Objects.requireNonNull(om.getOntology(IRI.create("http://a#A")));
+
+        // SubClassOf(<http://b#C2> <http://b#C1>)
+        // SubClassOf(<http://b#C2> owl:Thing)
+        // SubClassOf(<http://b#C2> <http://b#C2>)
+        // SubClassOf(<http://b#C2> rdfs:Resource)
+        // EquivalentClasses(<http://b#C1> <http://b#C2>)
+        // EquivalentClasses(<http://b#C2>)
+        // EquivalentClasses(<http://b#C1> <http://b#C2>)
+        // EquivalentClasses(<http://b#C2>)
+        Assertions.assertEquals(8, o1.axioms(df.getOWLClass("http://b#C2"), Imports.INCLUDED).count());
+
+        // ObjectPropertyDomain(<http://a#p2> owl:Thing)
+        // ObjectPropertyDomain(<http://a#p2> rdfs:Resource)
+        // ObjectPropertyRange(<http://a#p2> owl:Thing)
+        // ObjectPropertyRange(<http://a#p2> rdfs:Resource)
+        Assertions.assertEquals(4, o1.axioms(df.getOWLObjectProperty("http://a#p2"), Imports.INCLUDED).count());
+
+        // SubDataPropertyOf(<http://b#p1> <http://a#p3>)
+        // SubDataPropertyOf(<http://b#p1> <http://b#p1>)
+        // EquivalentDataProperties(<http://b#p1>)
+        Assertions.assertEquals(3, o1.axioms(df.getOWLDataProperty("http://b#p1"), Imports.INCLUDED).count());
+
+        // SubAnnotationPropertyOf(<http://a#p4> <http://a#p3>)
+        // SubAnnotationPropertyOf(<http://a#p4> <http://a#p4>)
+        Assertions.assertEquals(2, o1.axioms(df.getOWLAnnotationProperty("http://a#p4"), Imports.INCLUDED).count());
+
+        // ClassAssertion(<http://b#C1> _:c9613ce1-e0bd-4e2c-8855-cffc04961da4)
+        // ClassAssertion(<http://b#C2> _:c9613ce1-e0bd-4e2c-8855-cffc04961da4)
+        // ClassAssertion(owl:Thing _:c9613ce1-e0bd-4e2c-8855-cffc04961da4)
+        // ClassAssertion(rdfs:Resource _:c9613ce1-e0bd-4e2c-8855-cffc04961da4)
+        // SameIndividual(<http://b#i1> _:c9613ce1-e0bd-4e2c-8855-cffc04961da4)
+        // SameIndividual(<http://b#i1> _:c9613ce1-e0bd-4e2c-8855-cffc04961da4)
+        // ObjectPropertyAssertion(owl:sameAs _:c9613ce1-e0bd-4e2c-8855-cffc04961da4 <http://b#i1>)
+        Assertions.assertEquals(7, o1.axioms(df.getOWLAnonymousIndividual(BlankNodeId.of(i2.asNode())), Imports.INCLUDED).count());
+
+        // DatatypeDefinition(<1&2> DataOneOf("1"^^xsd:int "2"^^xsd:int))
+        // DatatypeDefinition(<1&2> <1&2>)
+        Assertions.assertEquals(2, o1.axioms(df.getOWLDatatype(d2.getURI()), Imports.INCLUDED).count());
+    }
+
     @Test
     void testListSignature1() {
         OntologyManager om = OntManagers.createDirectManager();