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
|
package rsacomb
import tech.oxfordsemantic.jrdfox.logic.{Atom, IRI, TupleTableName}
trait RDFTriple {
implicit class RDFTriple(atom: Atom) {
/* Is this the best way to determine if an atom is an RDF triple?
* Note that we can't use `getNumberOfArguments()` because is not
* "consistent":
* - for an atom created with `rdf(<term1>, <term2>, <term3>)`,
* `getNumberOfArguments` returns 3
* - for an atom created with `Atom.create(<tupletablename>, <term1>,
* <term2>, <term3>)`, `getNumberOfArguments()` returns 3
*
* This is probably because `Atom.rdf(...) is implemented as:
* ```scala
* def rdf(term1: Term, term2: Term, term3: Term): Atom =
* Atom.create(TupleTableName.create("internal:triple"), term1, term2, term3)
* ```
*/
def isRdfTriple: Boolean =
atom.getTupleTableName.getIRI.equals("internal:triple")
def isClassAssertion: Boolean =
atom.isRdfTriple && atom.getArgument(1).equals(IRI.RDF_TYPE)
def isRoleAssertion: Boolean =
atom.isRdfTriple && !atom.getArgument(1).equals(IRI.RDF_TYPE)
def suffix(sx: String): Atom =
if (this.isClassAssertion) {
val newclass = atom.getArgument(2) match {
case iri: IRI => IRI.create(iri.getIRI.appendedAll(sx))
case other => other
}
Atom.rdf(
atom getArgument 0,
atom getArgument 1,
newclass
)
} else if (this.isRoleAssertion) {
val newrole = atom.getArgument(1) match {
case iri: IRI => IRI.create(iri.getIRI.appendedAll(sx))
case other => other
}
Atom.rdf(
atom getArgument 0,
newrole,
atom getArgument 2
)
} else {
val newname =
TupleTableName.create(atom.getTupleTableName.getIRI.appendedAll(sx))
Atom.create(newname, atom.getArguments())
}
}
}
|
