Create class that models a module

born-owlapi/src/main/java/de/tudresden/inf/lat/born/module/DefaultModuleExtractor.java

@@ -80,37 +80,36 @@ Set<DefaultIdentifierCollector> getAxiomsWithClassesOnTheLeft(Set<Integer> class
 	 *            set of classes
 	 * @return a module, i.e. a subset of axioms relevant to answer a query
 	 */
-	public Set<NormalizedIntegerAxiom> extractModule(Collection<NormalizedIntegerAxiom> setOfAxioms,
-			Set<Integer> setOfClasses) {
+	public Module extractModule(Collection<NormalizedIntegerAxiom> setOfAxioms, Set<Integer> setOfClasses) {
 
-		Set<NormalizedIntegerAxiom> ret = new HashSet<>();
+		Set<NormalizedIntegerAxiom> newAxioms = new HashSet<>();
 
 		Set<DefaultIdentifierCollector> axioms = new HashSet<>();
 		setOfAxioms.forEach(axiom -> axioms.add(new DefaultIdentifierCollector(axiom)));
 
-		ret.addAll(getAxiomsWithoutEntitiesOnTheLeft(axioms));
+		newAxioms.addAll(getAxiomsWithoutEntitiesOnTheLeft(axioms));
 
 		Map<Integer, Set<DefaultIdentifierCollector>> map = buildMapOfAxioms(axioms);
 
 		Set<Integer> visitedClasses = new HashSet<Integer>();
 		Set<Integer> classesToVisit = new HashSet<Integer>();
 		classesToVisit.addAll(setOfClasses);
 		int resultSize = -1;
-		while (ret.size() > resultSize) {
-			resultSize = ret.size();
+		while (newAxioms.size() > resultSize) {
+			resultSize = newAxioms.size();
 
 			Set<DefaultIdentifierCollector> axiomsToVisit = getAxiomsWithClassesOnTheLeft(classesToVisit, map);
 			visitedClasses.addAll(classesToVisit);
 			classesToVisit.clear();
 
 			axiomsToVisit.forEach(axiom -> {
 				classesToVisit.addAll(axiom.getClassesOnTheRight());
-				ret.add(axiom.getAxiom());
+				newAxioms.add(axiom.getAxiom());
 			});
 			classesToVisit.removeAll(visitedClasses);
 		}
 
-		return ret;
+		return new Module(visitedClasses, newAxioms);
 	}
 
 }

born-owlapi/src/main/java/de/tudresden/inf/lat/born/module/Module.java

@@ -0,0 +1,28 @@
+package de.tudresden.inf.lat.born.module;
+
+import java.util.Objects;
+import java.util.Set;
+
+import de.tudresden.inf.lat.jcel.coreontology.axiom.NormalizedIntegerAxiom;
+
+public class Module {
+
+	private Set<Integer> entities;
+	private Set<NormalizedIntegerAxiom> axioms;
+
+	public Module(Set<Integer> entities, Set<NormalizedIntegerAxiom> axioms) {
+		Objects.requireNonNull(entities);
+		Objects.requireNonNull(axioms);
+		this.entities = entities;
+		this.axioms = axioms;
+	}
+
+	public Set<Integer> getEntities() {
+		return this.entities;
+	}
+
+	public Set<NormalizedIntegerAxiom> getAxioms() {
+		return this.axioms;
+	}
+
+}

born-owlapi/src/main/java/de/tudresden/inf/lat/born/owlapi/processor/ProblogInputCreator.java

@@ -39,6 +39,7 @@
 import de.tudresden.inf.lat.born.core.term.Clause;
 import de.tudresden.inf.lat.born.core.term.Symbol;
 import de.tudresden.inf.lat.born.module.DefaultModuleExtractor;
+import de.tudresden.inf.lat.born.module.Module;
 import de.tudresden.inf.lat.born.problog.parser.Token;
 import de.tudresden.inf.lat.born.problog.parser.TokenCreator;
 import de.tudresden.inf.lat.born.problog.parser.TokenType;
@@ -110,19 +111,31 @@ void write(Writer output, ProblogProgram program) throws IOException {
 		writer.close();
 	}
 
-	List<Clause> getDeclarations(IntegerOntologyObjectFactory factory, Set<NormalizedIntegerAxiom> axioms) {
+	List<Clause> getDeclarations(IntegerOntologyObjectFactory factory, Module module) {
 		Objects.requireNonNull(factory);
-		Objects.requireNonNull(axioms);
+		Objects.requireNonNull(module);
 		List<Clause> ret = new ArrayList<>();
 		AxiomRenderer renderer = new AxiomRenderer(factory);
 
 		Set<Integer> classes = new TreeSet<>();
 		Set<Integer> objectProperties = new TreeSet<>();
 		Set<Integer> individuals = new TreeSet<>();
-		axioms.forEach(axiom -> {
-			classes.addAll(axiom.getClassesInSignature());
+		Set<Integer> entities = module.getEntities();
+		entities.forEach(entity -> {
+			if (factory.getEntityManager().getType(entity).equals(IntegerEntityType.INDIVIDUAL)) {
+				individuals.add(entity);
+			} else if (factory.getEntityManager().getType(entity).equals(IntegerEntityType.CLASS)) {
+				classes.add(entity);
+			} else if (factory.getEntityManager().getType(entity).equals(IntegerEntityType.OBJECT_PROPERTY)) {
+				objectProperties.add(entity);
+			} else {
+				throw new IllegalStateException("Entity of unknown type: '" + entity + "'.");
+			}
+		});
+		module.getAxioms().forEach(axiom -> {
+			// classes.addAll(axiom.getClassesInSignature());
 			objectProperties.addAll(axiom.getObjectPropertiesInSignature());
-			individuals.addAll(axiom.getIndividualsInSignature());
+			// individuals.addAll(axiom.getIndividualsInSignature());
 		});
 
 		classes.forEach(cls -> ret.add(renderer.renderDeclarationOfClass(cls)));
@@ -132,15 +145,15 @@ List<Clause> getDeclarations(IntegerOntologyObjectFactory factory, Set<Normalize
 		return ret;
 	}
 
-	List<Clause> getClauses(IntegerOntologyObjectFactory factory, Set<NormalizedIntegerAxiom> axioms)
-			throws IOException {
+	List<Clause> getClauses(IntegerOntologyObjectFactory factory, Module module) throws IOException {
 		Objects.requireNonNull(factory);
-		Objects.requireNonNull(axioms);
+		Objects.requireNonNull(module);
+
 		List<Clause> ontology = new ArrayList<>();
 		AxiomRenderer renderer = new AxiomRenderer(factory);
-		ontology.addAll(getDeclarations(factory, axioms));
+		ontology.addAll(getDeclarations(factory, module));
 
-		axioms.forEach(axiom -> {
+		module.getAxioms().forEach(axiom -> {
 			Clause clause = axiom.accept(renderer);
 			ontology.add(clause);
 		});
@@ -225,10 +238,10 @@ public String createProblogFile(boolean useOfDefaultCompletionRules, String addi
 		long moduleExtractionStart = System.nanoTime();
 		DefaultModuleExtractor moduleExtractor = new DefaultModuleExtractor();
 		Set<Integer> setOfClasses = getSetOfClasses(factory, relevantSymbols);
-		Set<NormalizedIntegerAxiom> module = moduleExtractor.extractModule(normalizedAxioms, setOfClasses);
+		Module module = moduleExtractor.extractModule(normalizedAxioms, setOfClasses);
 		executionResult.setModuleExtractionTime(System.nanoTime() - moduleExtractionStart);
-		executionResult.setModuleSize(module.size());
-		sbuf.append(NUMBER_OF_AXIOMS_IN_MODULE + module.size());
+		executionResult.setModuleSize(module.getAxioms().size());
+		sbuf.append(NUMBER_OF_AXIOMS_IN_MODULE + module.getAxioms().size());
 		sbuf.append(Symbol.NEW_LINE_CHAR);
 
 		program.setOntology(getClauses(factory, module));

born-owlapi/src/main/java/de/tudresden/inf/lat/born/tool/moduleextractor/BornModuleExtractor.java

@@ -30,6 +30,7 @@
 import org.semanticweb.owlapi.owlxml.renderer.OWLXMLRenderer;
 
 import de.tudresden.inf.lat.born.module.DefaultModuleExtractor;
+import de.tudresden.inf.lat.born.module.Module;
 import de.tudresden.inf.lat.born.owlapi.processor.ProcessorConfigurationImpl;
 import de.tudresden.inf.lat.jcel.coreontology.axiom.NormalizedIntegerAxiom;
 import de.tudresden.inf.lat.jcel.ontology.axiom.complex.ComplexIntegerAxiom;
@@ -110,8 +111,8 @@ public OWLOntology extractModule(OWLOntology owlOntology, Set<OWLClass> signatur
 				.map(intClass -> intClass.getId()).collect(Collectors.toSet());
 
 		Set<Integer> classesInSignature = new HashSet<>();
-		(new DefaultModuleExtractor()).extractModule(normalizedAxioms, setOfClasses)
-				.forEach(axiom -> classesInSignature.addAll(axiom.getClassesInSignature()));
+		Module module = (new DefaultModuleExtractor()).extractModule(normalizedAxioms, setOfClasses);
+		module.getAxioms().forEach(axiom -> classesInSignature.addAll(axiom.getClassesInSignature()));
 
 		Set<OWLClass> moduleOwlClasses = classesInSignature.stream()
 				.filter(cls -> !translator.getOntologyObjectFactory().getEntityManager().isAuxiliary(cls))