ont-api: implement NamedIndividualSearcher (graph-optimization, issue #15)

Author: sszuev

src/main/java/com/github/owlcs/ontapi/internal/AxiomTranslator.java

@@ -1,7 +1,7 @@
 /*
  * This file is part of the ONT API.
  * The contents of this file are subject to the LGPL License, Version 3.0.
- * Copyright (c) 2020, The University of Manchester, owl.cs group.
+ * Copyright (c) 2020, owl.cs group.
  *
  * This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.
  * This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
@@ -16,18 +16,17 @@
 
 import com.github.owlcs.ontapi.DataFactory;
 import com.github.owlcs.ontapi.config.AxiomsSettings;
-import com.github.owlcs.ontapi.jena.impl.PersonalityModel;
-import com.github.owlcs.ontapi.jena.model.OntClass;
 import com.github.owlcs.ontapi.jena.model.OntModel;
 import com.github.owlcs.ontapi.jena.model.OntStatement;
 import com.github.owlcs.ontapi.jena.utils.Iter;
-import org.apache.jena.graph.Node;
 import org.apache.jena.shared.JenaException;
 import org.apache.jena.util.iterator.ExtendedIterator;
 import org.semanticweb.owlapi.model.AxiomType;
 import org.semanticweb.owlapi.model.OWLAxiom;
 
-import java.util.*;
+import java.util.List;
+import java.util.Objects;
+import java.util.Optional;
 import java.util.function.Supplier;
 import java.util.stream.Stream;
 
@@ -71,19 +70,6 @@ public static ONTObjectFactory getObjectFactory(OntModel model) {
                 ((HasObjectFactory) model).getObjectFactory() : ONTObjectFactory.DEFAULT;
     }
 
-    /**
-     * Gets all uri-{@link Node}s that are reserved for a model and cannot represent a {@link OntClass.Named}.
-     *
-     * @param model {@link OntModel}, not {@code null}
-     * @return a {@code Set} of {@link Node}s
-     */
-    protected static Set<Node> getSystemResources(OntModel model) {
-        if (model instanceof PersonalityModel) {
-            return ((PersonalityModel) model).getSystemResources(OntClass.Named.class);
-        }
-        return Collections.emptySet();
-    }
-
     /**
      * Reads all model's axioms in the form of stream.
      *

src/main/java/com/github/owlcs/ontapi/internal/BaseSearcher.java

@@ -1,7 +1,7 @@
 /*
  * This file is part of the ONT API.
  * The contents of this file are subject to the LGPL License, Version 3.0.
- * Copyright (c) 2020, The University of Manchester, owl.cs group.
+ * Copyright (c) 2020, owl.cs group.
  *
  * This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.
  * This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
@@ -16,10 +16,13 @@
 
 import com.github.owlcs.ontapi.DataFactory;
 import com.github.owlcs.ontapi.config.AxiomsSettings;
+import com.github.owlcs.ontapi.jena.impl.PersonalityModel;
+import com.github.owlcs.ontapi.jena.model.OntClass;
 import com.github.owlcs.ontapi.jena.model.OntModel;
 import com.github.owlcs.ontapi.jena.model.OntStatement;
 import com.github.owlcs.ontapi.jena.utils.Iter;
 import com.github.owlcs.ontapi.jena.utils.OntModels;
+import org.apache.jena.graph.Node;
 import org.apache.jena.rdf.model.Property;
 import org.apache.jena.rdf.model.RDFNode;
 import org.apache.jena.rdf.model.Resource;
@@ -28,8 +31,10 @@
 import org.semanticweb.owlapi.model.OWLAxiom;
 import org.semanticweb.owlapi.model.OWLObject;
 
+import java.util.Collections;
 import java.util.List;
 import java.util.Set;
+import java.util.stream.Stream;
 
 /**
  * A base abstraction for {@link AxiomTranslator}s and searchers.
@@ -119,10 +124,11 @@ protected static <T extends AxiomTranslator<? extends A>, A extends OWLAxiom> T
     }
 
     protected static Set<AxiomTranslator<OWLAxiom>> selectTranslators(OWLComponentType type) {
-        return OWLTopObjectType.axioms().filter(x -> type == null || x.hasComponent(type))
-                .map(OWLTopObjectType::getAxiomType)
-                .map(AxiomParserProvider::get)
-                .collect(Iter.toUnmodifiableSet());
+        return selectTranslators(OWLTopObjectType.axioms().filter(x -> type == null || x.hasComponent(type)));
+    }
+
+    private static Set<AxiomTranslator<OWLAxiom>> selectTranslators(Stream<OWLTopObjectType> types) {
+        return types.map(OWLTopObjectType::getAxiomType).map(AxiomParserProvider::get).collect(Iter.toUnmodifiableSet());
     }
 
     @SuppressWarnings("unchecked")
@@ -135,6 +141,19 @@ static <X extends OWLObject> ObjectsSearcher<X> cast(ObjectsSearcher<?> searcher
         return (ObjectsSearcher<X>) searcher;
     }
 
+    /**
+     * Gets all uri-{@link Node}s that are reserved for a model and cannot represent a {@link OntClass.Named}.
+     *
+     * @param model {@link OntModel}, not {@code null}
+     * @return a {@code Set} of {@link Node}s
+     */
+    protected static Set<Node> getSystemResources(OntModel model) {
+        if (model instanceof PersonalityModel) {
+            return ((PersonalityModel) model).getSystemResources(OntClass.Named.class);
+        }
+        return Collections.emptySet();
+    }
+
     protected final ExtendedIterator<OntStatement> listBySubject(OntModel model, Resource subject) {
         return listStatements(model, subject, null, null);
     }

src/main/java/com/github/owlcs/ontapi/internal/InternalReadModel.java

@@ -20,6 +20,7 @@
 import com.github.owlcs.ontapi.internal.axioms.AbstractNaryTranslator;
 import com.github.owlcs.ontapi.internal.searchers.axioms.*;
 import com.github.owlcs.ontapi.internal.searchers.objects.ClassSearcher;
+import com.github.owlcs.ontapi.internal.searchers.objects.NamedIndividualSearcher;
 import com.github.owlcs.ontapi.jena.OntJenaException;
 import com.github.owlcs.ontapi.jena.RWLockedGraph;
 import com.github.owlcs.ontapi.jena.impl.OntGraphModelImpl;
@@ -146,6 +147,7 @@ abstract class InternalReadModel extends OntGraphModelImpl implements ListAxioms
 
     // To search OWLObjects
     protected final ObjectsSearcher<OWLClass> classSearcher = new ClassSearcher();
+    protected final ObjectsSearcher<OWLNamedIndividual> individualSearcher = new NamedIndividualSearcher();
 
     InternalReadModel(Graph base,
                       OntPersonality personality,
@@ -854,10 +856,8 @@ protected ObjectMap<OWLObject> createComponentObjectMap(OWLComponentType type) {
         InternalConfig conf = getConfig();
         Supplier<Iterator<ONTObject<OWLObject>>> loader = () -> InternalReadModel.this.listOWLObjects(type, conf);
         if (!conf.useComponentCache()) {
-            ObjectsSearcher<OWLObject> searcher;
-            if (OWLComponentType.CLASS == type) {
-                searcher = BaseSearcher.cast(classSearcher);
-            } else { // TODO: other types
+            ObjectsSearcher<OWLObject> searcher = getEntitySearcher(type);
+            if (searcher == null) {
                 return new DirectObjectMapImpl<>(loader);
             }
             return new DirectObjectMapImpl<>(loader, toFinder(searcher), toTester(searcher));
@@ -874,17 +874,28 @@ protected ObjectMap<OWLObject> createComponentObjectMap(OWLComponentType type) {
      * @param conf {@link InternalConfig}
      * @return an {@code Iterator} of {@link ONTObject} with the given type
      */
-    @SuppressWarnings({"unchecked", "rawtypes"})
     protected Iterator<ONTObject<OWLObject>> listOWLObjects(OWLComponentType type, InternalConfig conf) {
         ModelObjectFactory factory = getObjectFactory();
         OntModel model = getSearchModel();
-        if (OWLComponentType.CLASS == type && useObjectsSearchOptimization(conf)) {
-            return ((Iterator) classSearcher.listONTObjects(model, factory, conf));
+        ObjectsSearcher<OWLObject> searcher = getEntitySearcher(type);
+        if (searcher != null && useObjectsSearchOptimization(conf)) {
+            return searcher.listONTObjects(model, factory, conf);
         }
-        // if content cache is loaded its parsing is faster than graph-optimization
+        // if content cache is loaded then its parsing is faster than graph-optimization (at least for classes)
         return selectContentObjects(type).flatMap(x -> type.select(x, model, factory)).iterator();
     }
 
+    private ObjectsSearcher<OWLObject> getEntitySearcher(OWLComponentType type) {
+        if (OWLComponentType.CLASS == type) {
+            return BaseSearcher.cast(classSearcher);
+        }
+        if (OWLComponentType.NAMED_INDIVIDUAL == type) {
+            return BaseSearcher.cast(individualSearcher);
+        }
+        // TODO: support other types (see https://github.com/owlcs/ont-api/issues/15)
+        return null;
+    }
+
     /**
      * Answers {@code true} when need to use {@link ObjectsSearcher} optimization.
      *

src/main/java/com/github/owlcs/ontapi/internal/searchers/objects/ClassSearcher.java

@@ -1,7 +1,7 @@
 /*
  * This file is part of the ONT API.
  * The contents of this file are subject to the LGPL License, Version 3.0.
- * Copyright (c) 2020, The University of Manchester, owl.cs group.
+ * Copyright (c) 2020, owl.cs group.
  *
  * This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.
  * This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
@@ -17,10 +17,7 @@
 import com.github.owlcs.ontapi.OntApiException;
 import com.github.owlcs.ontapi.config.AxiomsSettings;
 import com.github.owlcs.ontapi.internal.*;
-import com.github.owlcs.ontapi.internal.searchers.WithRootStatement;
 import com.github.owlcs.ontapi.internal.searchers.axioms.ByClass;
-import com.github.owlcs.ontapi.jena.impl.PersonalityModel;
-import com.github.owlcs.ontapi.jena.impl.conf.OntPersonality;
 import com.github.owlcs.ontapi.jena.model.OntModel;
 import com.github.owlcs.ontapi.jena.model.OntStatement;
 import com.github.owlcs.ontapi.jena.utils.Iter;
@@ -35,81 +32,60 @@
 import org.semanticweb.owlapi.model.OWLClass;
 
 import java.util.HashSet;
-import java.util.Optional;
 import java.util.Set;
-import java.util.function.Function;
 
 /**
+ * An {@link ObjectsSearcher} that retrieves {@link OWLClass OWL-API Class}es.
  * Created by @ssz on 19.04.2020.
  */
-public class ClassSearcher extends WithRootStatement implements ObjectsSearcher<OWLClass> {
-
+public class ClassSearcher extends EntitySearcher<OWLClass> {
     private static final Set<AxiomTranslator<OWLAxiom>> TRANSLATORS = selectTranslators(OWLComponentType.CLASS);
 
-    protected static OntPersonality.Builtins getBuiltins(OntModel m) {
-        return PersonalityModel.asPersonalityModel(m).getOntPersonality().getBuiltins();
-    }
-
-    private static Function<String, ONTObject<OWLClass>> factoryMapping(OntModel model, ONTObjectFactory factory) {
-        if (factory instanceof ModelObjectFactory) {
-            return ((ModelObjectFactory) factory)::getClass;
-        }
-        return uri -> factory.getClass(OntApiException.mustNotBeNull(model.getOntClass(uri)));
-    }
-
     @Override
-    public ExtendedIterator<ONTObject<OWLClass>> listONTObjects(OntModel model,
-                                                                ONTObjectFactory factory,
-                                                                AxiomsSettings config) {
-        return listClasses(model, config).mapWith(factoryMapping(model, factory));
+    protected ONTObject<OWLClass> createEntity(String uri, OntModel model, ONTObjectFactory factory) {
+        return factory.getClass(OntApiException.mustNotBeNull(model.getOntClass(uri)));
     }
 
     @Override
-    public boolean containsONTObject(OWLClass object, OntModel model, ONTObjectFactory factory, AxiomsSettings config) {
-        return containsClass(object.getIRI().getIRIString(), model, config);
+    protected ONTObject<OWLClass> createEntity(String uri, ModelObjectFactory factory) {
+        return factory.getClass(uri);
     }
 
     @Override
-    public Optional<ONTObject<OWLClass>> findONTObject(OWLClass object,
-                                                       OntModel model,
-                                                       ONTObjectFactory factory,
-                                                       AxiomsSettings config) {
-        String uri = object.getIRI().getIRIString();
-        if (containsClass(uri, model, config)) {
-            return Optional.of(InternalObjectFactory.getONTClass(uri, model, factory));
-        }
-        return Optional.empty();
+    protected ExtendedIterator<? extends AxiomTranslator<OWLAxiom>> listTranslators() {
+        return Iter.create(TRANSLATORS);
     }
 
-    protected boolean containsClass(String uri, OntModel m, AxiomsSettings conf) {
+    @Override
+    protected boolean containsEntity(String uri, OntModel m, AxiomsSettings conf) {
         Resource clazz = m.getResource(uri);
         if (getBuiltins(m).getClasses().contains(clazz.asNode())) {
             if (OWL.Thing.equals(clazz)) {
-                if (containAxiom(Iter.flatMap(listImplicitStatements(m), s -> listRootStatements(m, s)), conf)) {
+                if (containsAxiom(Iter.flatMap(listImplicitStatements(m), s -> listRootStatements(m, s)), conf)) {
                     return true;
                 }
             }
-            return containAxiom(listStatements(m, clazz), conf);
+            return containsInAxiom(clazz, m, conf);
         }
         if (m.independent()) {
             return m.getBaseGraph().contains(clazz.asNode(), RDF.type.asNode(), OWL.Class.asNode());
         }
         if (!m.contains(clazz, RDF.type, OWL.Class)) {
             return false;
         }
-        return containAxiom(listStatements(m, clazz), conf);
+        return containsInAxiom(clazz, m, conf);
     }
 
-    protected ExtendedIterator<String> listClasses(OntModel m, AxiomsSettings conf) {
+    @Override
+    protected ExtendedIterator<String> listEntities(OntModel m, AxiomsSettings conf) {
         Set<String> builtins = new HashSet<>();
-        getBuiltins(m).getClasses()
-                .forEach(x -> {
-                    if (containAxiom(listStatements(m, m.getResource(x.getURI())), conf)) {
-                        builtins.add(x.getURI());
-                    }
-                });
+        getBuiltins(m).getClasses().forEach(x -> {
+            if (containsInAxiom(x.getURI(), m, conf)) {
+                builtins.add(x.getURI());
+            }
+        });
         if (!builtins.contains(OWL.Thing.getURI())) {
-            if (containAxiom(Iter.flatMap(listImplicitStatements(m), s -> listRootStatements(m, s)), conf)) {
+            if (containsAxiom(Iter.flatMap(listImplicitStatements(m), s -> listRootStatements(m, s)), conf)) {
                 builtins.add(OWL.Thing.getURI());
             }
         }
@@ -119,16 +95,12 @@ protected ExtendedIterator<String> listClasses(OntModel m, AxiomsSettings conf)
         ExtendedIterator<String> res = Iter.concat(explicit, Iter.create(builtins));
         if (!m.independent()) {
             ExtendedIterator<String> shared = listClassesFromImports(m)
-                    .filterKeep(x -> containAxiom(listStatements(m, m.getResource(x)), conf));
+                    .filterKeep(x -> containsInAxiom(x, m, conf));
             res = Iter.concat(res, shared);
         }
         return res;
     }
 
-    protected ExtendedIterator<OntStatement> listStatements(OntModel m, Resource clazz) {
-        return Iter.concat(listBySubject(m, clazz), Iter.flatMap(listByObject(m, clazz), s -> listRootStatements(m, s)));
-    }
-
     protected ExtendedIterator<OntStatement> listImplicitStatements(OntModel m) {
         return Iter.flatMap(Iter.of(OWL.cardinality, OWL.maxCardinality, OWL.minCardinality), p -> listByPredicate(m, p))
                 .filterKeep(this::isCardinalityRestriction);
@@ -144,12 +116,4 @@ protected boolean isCardinalityRestriction(OntStatement s) {
         return ByClass.OBJECT_CARDINALITY_TYPES.stream().anyMatch(t -> s.getSubject().canAs(t));
     }
 
-    protected boolean containAxiom(ExtendedIterator<OntStatement> top, AxiomsSettings conf) {
-        return Iter.anyMatch(top, s -> Iter.findFirst(listTranslators(s, conf)).isPresent());
-    }
-
-    protected ExtendedIterator<? extends AxiomTranslator<OWLAxiom>> listTranslators(OntStatement statement,
-                                                                                    AxiomsSettings conf) {
-        return Iter.create(TRANSLATORS).filterKeep(t -> t.testStatement(statement, conf));
-    }
 }