Added sugar for data property restrictions, and fixed some bugs with data ranges.

Author: drdozer

core/src/main/scala/uk/co/turingatemyhamster/owl2/ast/DataPropertyRestrictionsModuleAst.scala

@@ -21,8 +21,8 @@ trait DataPropertyRestrictionsModuleImpl extends owl2.DataPropertyRestrictionsMo
 
 }
 
-case class DataSomeValuesFrom(dataPropertyExpression: DataPropertyExpression, arity: BigInt) extends ClassExpression
+case class DataSomeValuesFrom(dataPropertyExpression: List[DataPropertyExpression], dataRange: DataRange, arity: BigInt = BigInt(1)) extends ClassExpression
 
-case class DataAllValuesFrom(dataPropertyExpression: DataPropertyExpression, arity: BigInt) extends ClassExpression
+case class DataAllValuesFrom(dataPropertyExpression: List[DataPropertyExpression], dataRange: DataRange, arity: BigInt = BigInt(1)) extends ClassExpression
 
 case class DataHasValue(dataPropertyExpression: DataPropertyExpression, literal: Literal) extends ClassExpression

core/src/main/scala/uk/co/turingatemyhamster/owl2/ast/DataRangesModuleAst.scala

@@ -36,7 +36,7 @@ case class DataUnionOf(arity: BigInt = BigInt(1), dataRanges: List[DataRange]) e
 
 case class DataOneOf(arity: BigInt = BigInt(1), literals: List[Literal]) extends DataRange
 
-case class DatatypeRestriction(arity: BigInt = BigInt(1), datatype: Datatype) extends DataRange
+case class DatatypeRestriction(arity: BigInt = BigInt(1), datatype: Datatype, restrictions: List[FacetRestriction]) extends DataRange
 
 // 2..* dataRanges
 case class DataIntersectionOf(arity: BigInt = BigInt(1), dataRanges: List[DataRange]) extends DataRange

core/src/main/scala/uk/co/turingatemyhamster/owl2/examples/UsingAst.scala

@@ -36,6 +36,11 @@ object UsingAst {
     def === (c: Int): ===[I] = examples.===(_i, BigInt(c))
 
     def ≥ (c: Int): ≥[I] = examples.≥(_i, BigInt(c))
+
+    def ^^[J](j: J)(implicit iString: I => String, jDatatype: J => Datatype): TypedLiteral = TypedLiteral(_i, j)
+
+    def | [J](j: J)(implicit iDT: I => Datatype, jFR: J => FacetRestriction): DatatypeRestriction =
+      DatatypeRestriction(datatype = _i, restrictions = j::Nil)
   }
 }
 
@@ -64,11 +69,19 @@ object Triple {
     AnnotationAssertion(Nil, t.sub, t.pred, t.obj)
 
   implicit def toObjectPropertyAssertion[Sub, Pred, Obj](t: Triple[Sub, Pred, Obj]
-                                               )(implicit
-                                                 subIndividual: Sub => Individual,
-                                                 predPE: Pred => ObjectPropertyExpression,
-                                                 objIndividual: Obj => Individual): ObjectPropertyAssertion =
-      ObjectPropertyAssertion(Nil, t.sub, t.pred, t.obj)
+                                                          )(implicit
+                                                            subIndividual: Sub => Individual,
+                                                            predPE: Pred => ObjectPropertyExpression,
+                                                            objIndividual: Obj => Individual): ObjectPropertyAssertion =
+    ObjectPropertyAssertion(Nil, t.sub, t.pred, t.obj)
+
+  implicit def toDataPropertyAssertion[Sub, Pred, Obj](t: Triple[Sub, Pred, Obj]
+                                                        )(implicit
+                                                          subIndividual: Sub => Individual,
+                                                          predPE: Pred => DataPropertyExpression,
+                                                          objLit: Obj => Literal): DataPropertyAssertion =
+    DataPropertyAssertion(Nil, t.sub, t.pred, t.obj)
+
 }
 
 case class Inverse[P](p: P) {
@@ -145,7 +158,12 @@ case object ∃ {
   implicit def someObjectSomeValuesFrom[P, V](some: ∃[P, V])(implicit
                                                              pPE: P => ObjectPropertyExpression,
                                                              vCE: V => ClassExpression): ObjectSomeValuesFrom =
-      ObjectSomeValuesFrom(some.p, some.v)
+    ObjectSomeValuesFrom(some.p, some.v)
+
+  implicit def someDataSomeValuesFrom[P, V](some: ∃[P, V])(implicit
+                                                           pPE: P => DataPropertyExpression,
+                                                           vDR: V => DataRange): DataSomeValuesFrom =
+    DataSomeValuesFrom(some.p::Nil, some.v)
 }
 
 case class ∀[P, V](p: P, v: V)
@@ -155,6 +173,11 @@ case object ∀ {
                                                        pPE: P => ObjectPropertyExpression,
                                                        vCE: V => ClassExpression): ObjectAllValuesFrom =
     ObjectAllValuesFrom(all.p, all.v)
+
+  implicit def allDataValuesFrom[P, V](all: ∀[P, V])(implicit
+                                                     pPE: P => DataPropertyExpression,
+                                                     vDR: V => DataRange): DataAllValuesFrom =
+    DataAllValuesFrom(all.p::Nil, all.v)
 }
 
 case class ∈[P, V](p: P, v: V)
@@ -164,6 +187,11 @@ object ∈ {
                                                    pPE: P => ObjectPropertyExpression,
                                                    vI: V => Individual): ObjectHasValue =
     ObjectHasValue(pv.p, pv.v)
+
+  implicit def toDataHasValue[P, V](pv: ∈[P, V])(implicit
+                                                 pPE: P => DataPropertyExpression,
+                                                 vI: V => Literal): DataHasValue =
+    DataHasValue(pv.p, pv.v)
 }
 
 case class ≤[P](p: P, c: BigInt)
@@ -348,6 +376,21 @@ class UsingAst {
   ObjectMinCardinality(objectPropertyExpression = "a" -> "hasPet", cardinality = BigInt(1))
   "a" -> "hasPet" ≥ 1 : ObjectMinCardinality
 
+  DataPropertyAssertion(Nil, "a" -> "Meg", "a" -> "hasAge", "17"^^("xsd" -> "integer"))
+  ("a" -> "Meg") --- ("a" -> "hasAge") --> ("17"^^("xsd" -> "integer")) : DataPropertyAssertion
+
+  DataSomeValuesFrom(
+    ("a" -> "hasAge")::Nil,
+    DatatypeRestriction(
+      BigInt(1),
+      "xsd" -> "integer",
+      FacetRestriction("xsd" -> "maxExclusive", "20"^^("xsd" -> "integer"))::Nil),
+    BigInt(1))
+
+  ∃("a" -> "hasAge", "xsd" -> "integer" | "xsd" -> "maxExclusive" -> ("20"^^("xsd" -> "integer"))) : DataSomeValuesFrom
+  ∀("a" -> "hasZIP", "xsd" -> "integer") : DataAllValuesFrom
+  ∈("a" -> "hasAge", "17"^^("xsd" -> "integer")) : DataHasValue
+
   SubObjectPropertyOf(Nil, "a" -> "hasDog", ("a" -> "hasPet" : ObjectPropertyExpression) :: Nil)
   ObjectPropertyAssertion(Nil, "a" -> "Peter", "a" -> "hasDog", "a" -> "Brian")
   ObjectPropertyAssertion(Nil, "a" -> "Peter", "a" -> "hasPet", "a" -> "Brian")