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
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
|
package rsacomb
import scala.collection.JavaConverters._
import java.util.stream.{Stream, Collectors}
import org.semanticweb.owlapi.model.{
OWLClassExpression,
OWLClass,
OWLObjectSomeValuesFrom,
OWLObjectIntersectionOf,
OWLObjectOneOf,
OWLObjectMaxCardinality
}
import org.semanticweb.owlapi.model.OWLClassExpressionVisitorEx
import tech.oxfordsemantic.jrdfox.logic.Datatype
import tech.oxfordsemantic.jrdfox.logic.datalog.{
BindAtom,
TupleTableName,
TupleTableAtom
}
import tech.oxfordsemantic.jrdfox.logic.expression.{
Term,
Literal,
Variable,
FunctionCall,
IRI
}
import rsacomb.SkolemStrategy
import rsacomb.RDFoxRuleShards
import org.semanticweb.owlapi.model.OWLObjectPropertyExpression
import org.semanticweb.owlapi.model.OWLObjectProperty
object RDFoxClassExprConverter {
def apply(
term: Term,
unsafe: List[OWLObjectPropertyExpression] = List(),
skolem: SkolemStrategy = SkolemStrategy.None,
suffix: RSASuffix = RSASuffix.None
): RDFoxClassExprConverter =
new RDFoxClassExprConverter(term, unsafe, skolem, suffix)
def merge(rules: List[RDFoxRuleShards]): RDFoxRuleShards = {
rules.foldLeft(RDFoxRuleShards(List(), List())) { (r1, r2) =>
RDFoxRuleShards(
r1.res ++ r2.res,
r1.ext ++ r2.ext
)
}
}
} // object RDFoxClassExprConverter
class RDFoxClassExprConverter(
term: Term,
unsafe: List[OWLObjectPropertyExpression],
skolem: SkolemStrategy,
suffix: RSASuffix
) extends OWLClassExpressionVisitorEx[RDFoxRuleShards] {
import RDFoxUtil.owlapi2rdfox;
// OWLClass
override def visit(expr: OWLClass): RDFoxRuleShards = {
val iri: IRI = if (expr.isTopEntity()) IRI.THING else expr.getIRI()
val atom = List(TupleTableAtom.rdf(term, IRI.RDF_TYPE, iri))
RDFoxRuleShards(atom, List())
}
// OWLObjectIntersectionOf
override def visit(expr: OWLObjectIntersectionOf): RDFoxRuleShards = {
val visitor = new RDFoxClassExprConverter(term, unsafe, skolem, suffix)
// TODO: maybe using `flatMap` instead of `merge` + `map` works as well
RDFoxClassExprConverter.merge(
expr.asConjunctSet.asScala.toList
.map((e: OWLClassExpression) => e.accept(visitor))
)
}
// OWLObjectOneOf
override def visit(expr: OWLObjectOneOf): RDFoxRuleShards = {
val visitor = RDFoxClassExprConverter(term, unsafe, skolem, suffix)
// TODO: review nominal handling. Here we are taking "just" one
val ind = expr.individuals
.collect(Collectors.toList())
.asScala
.filter(_.isOWLNamedIndividual)
.head // restricts to proper "nominals"
.asOWLNamedIndividual
.getIRI
val atom = List(
TupleTableAtom.rdf(term, IRI.SAME_AS, ind)
)
RDFoxRuleShards(atom, List())
}
// OWLObjectSomeValuesFrom
override def visit(expr: OWLObjectSomeValuesFrom): RDFoxRuleShards = {
val y = RSA.getFreshVariable()
// Here we are assuming a role name
val prop = expr.getProperty()
// Computes the result of rule skolemization. Depending on the used
// technique it might involve the introduction of additional atoms,
// and/or fresh constants and variables.
val (head, body, term1) = skolem match {
case SkolemStrategy.None => (List(), List(), y)
case SkolemStrategy.Constant(c) => (List(), List(), c)
case SkolemStrategy.ConstantRSA(c) => {
if (unsafe.contains(prop))
(
List(
TupleTableAtom.rdf(term, RSA.rsa("PE"), c),
TupleTableAtom.rdf(c, IRI.RDF_TYPE, RSA.rsa("U"))
),
List(),
c
)
else
(List(), List(), c)
}
case SkolemStrategy.Standard(f) => {
(
List(),
List(BindAtom.create(FunctionCall.create("SKOLEM", f, term), y)),
y
)
}
}
val classVisitor =
new RDFoxClassExprConverter(term1, unsafe, skolem, suffix)
val classResult = expr.getFiller.accept(classVisitor)
val propertyVisitor = new RDFoxPropertyExprConverter(term, term1, suffix)
val propertyResult = expr.getProperty.accept(propertyVisitor)
RDFoxRuleShards(
classResult.res ++ propertyResult ++ head,
classResult.ext ++ body
)
}
// OWLObjectMaxCardinality
override def visit(expr: OWLObjectMaxCardinality): RDFoxRuleShards = {
// TODO: again, no hardcoded variables
val vars = List(RSA.getFreshVariable(), RSA.getFreshVariable())
val classResult = RDFoxClassExprConverter.merge(
vars
.map(new RDFoxClassExprConverter(_, unsafe, skolem, suffix))
.map(expr.getFiller.accept(_))
)
val propertyResult =
vars
.map(new RDFoxPropertyExprConverter(term, _, suffix))
.map(expr.getProperty.accept(_))
.flatten
RDFoxRuleShards(
List(TupleTableAtom.rdf(vars(0), IRI.SAME_AS, vars(1))),
classResult.res ++ propertyResult
)
}
def doDefault(expr: OWLClassExpression): RDFoxRuleShards =
RDFoxRuleShards(List(), List())
} // class RDFoxClassExprConverter
|
