-
Notifications
You must be signed in to change notification settings - Fork 14
/
InferredAxiomLoader.java
127 lines (114 loc) · 5.78 KB
/
InferredAxiomLoader.java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
/**
* Copyright (C) 2016 Czech Technical University in Prague
* <p>
* 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.
* <p>
* 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. You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
package cz.cvut.kbss.ontodriver.owlapi;
import cz.cvut.kbss.ontodriver.owlapi.connector.OntologySnapshot;
import cz.cvut.kbss.ontodriver.owlapi.exception.ReasonerNotAvailableException;
import cz.cvut.kbss.ontodriver.owlapi.util.OwlapiUtils;
import cz.cvut.kbss.ontodriver.model.*;
import org.semanticweb.owlapi.model.*;
import org.semanticweb.owlapi.reasoner.OWLReasoner;
import java.util.*;
import java.util.stream.Collectors;
public class InferredAxiomLoader implements AxiomLoader {
private final OWLReasoner reasoner;
private final OWLOntology ontology;
private final OWLDataFactory dataFactory;
private final OwlapiAdapter adapter;
private final AxiomAdapter axiomAdapter;
private NamedResource subject;
InferredAxiomLoader(OwlapiAdapter adapter, OntologySnapshot snapshot) {
this.adapter = adapter;
this.reasoner = snapshot.getReasoner();
this.ontology = snapshot.getOntology();
this.dataFactory = snapshot.getDataFactory();
this.axiomAdapter = new AxiomAdapter(snapshot.getDataFactory(), adapter.getLanguage());
}
@Override
public Collection<Axiom<?>> loadAxioms(NamedResource subject, Set<Assertion> assertions) {
this.subject = subject;
if (assertions.isEmpty()) {
return Collections.emptySet();
}
if (reasoner == null) {
throw new ReasonerNotAvailableException();
}
reasoner.flush();
final OWLNamedIndividual individual = OwlapiUtils.getIndividual(subject, dataFactory);
final Collection<Axiom<?>> axioms = new HashSet<>();
for (Assertion a : assertions) {
switch (a.getType()) {
case CLASS:
axioms.addAll(adapter.getTypesHandler().getTypes(subject, null, true));
break;
case DATA_PROPERTY:
axioms.addAll(inferDataPropertyValues(individual, a));
break;
case OBJECT_PROPERTY:
axioms.addAll(inferObjectPropertyValues(individual, a));
break;
case PROPERTY:
// When we don't know, try all
axioms.addAll(adapter.getTypesHandler().getTypes(subject, null, true));
axioms.addAll(inferDataPropertyValues(individual, a));
axioms.addAll(inferObjectPropertyValues(individual, a));
break;
default:
break;
}
}
return axioms;
}
private Collection<Axiom<?>> inferDataPropertyValues(OWLNamedIndividual individual, Assertion dpAssertion) {
final Set<OWLLiteral> literals = reasoner.getDataPropertyValues(individual, dataProperty(dpAssertion));
return literals.stream().filter(lit -> OwlapiUtils.doesLanguageMatch(lit, adapter.getLanguage()))
.map(owlLiteral -> new AxiomImpl<>(subject, dpAssertion,
new Value<>(OwlapiUtils.owlLiteralToValue(owlLiteral)))).collect(Collectors.toSet());
}
private OWLDataProperty dataProperty(Assertion dataPropertyAssertion) {
return dataFactory.getOWLDataProperty(IRI.create(dataPropertyAssertion.getIdentifier()));
}
private Collection<Axiom<?>> inferObjectPropertyValues(OWLNamedIndividual individual, Assertion opAssertion) {
final Set<OWLNamedIndividual> individuals = reasoner.getObjectPropertyValues(individual,
objectProperty(opAssertion)).getFlattened();
return individuals.stream().map(
target -> axiomAdapter.createAxiom(subject, opAssertion, NamedResource.create(target.getIRI().toURI())))
.collect(
Collectors.toList());
}
private OWLObjectProperty objectProperty(Assertion objectPropertyAssertion) {
return dataFactory.getOWLObjectProperty(IRI.create(objectPropertyAssertion.getIdentifier()));
}
@Override
public Collection<Axiom<?>> loadPropertyAxioms(NamedResource subject) {
final Collection<Axiom<?>> axioms = new ArrayList<>();
final OWLNamedIndividual individual = OwlapiUtils.getIndividual(subject, dataFactory);
for (OWLDataProperty dp : ontology.getDataPropertiesInSignature()) {
final Set<OWLLiteral> values = reasoner.getDataPropertyValues(individual, dp);
for (OWLLiteral literal : values) {
axioms.add(axiomAdapter.createAxiom(subject,
Assertion.createDataPropertyAssertion(dp.getIRI().toURI(), true), literal));
}
}
for (OWLObjectProperty op : ontology.getObjectPropertiesInSignature()) {
final Set<OWLNamedIndividual> values = reasoner.getObjectPropertyValues(individual, op).getFlattened();
for (OWLNamedIndividual ind : values) {
axioms.add(axiomAdapter.createAxiom(subject,
Assertion.createObjectPropertyAssertion(op.getIRI().toURI(), true), NamedResource.create(
ind.getIRI().toURI())));
}
}
return axioms;
}
}