Atomic

Atomic #

This page contains the following content:

The group of Atomic classes is used to store exactly one value. The counterpart in programming languages such as java are data types like integer, double, string, or boolean. It is possible to restrict the value ranges by using an interval predicate or an enumeration predicate.

Boolean #

The Boolean class is the simplest Atomic class because it represents a boolean value similar to programming languages, e.g., true or false. Further optional restrictions are not needed.

To create an object of this class, the following java code has to be used:

BooleanObject booleanObject = (BooleanObject) ModelFactory.getDefaultModel().createObject(BooleanClass.CLASS_NAME);

To create a subclass of the Boolean class, the following XML definition can be used:

<BooleanClass name="customBooleanClass"/>

To create a subclass of this class during runtime, the following java code has to be used:

BooleanClass booleanClass = ModelFactory.getDefaultModel().getClass(BooleanClass.CLASS_NAME);
BooleanClass customBooleanClass = (BooleanClass) booleanClass.createSubclass("customBooleanClass");
customBooleanClass.finishEditing();

To create an object of this class, the following java code has to be used:

BooleanObject customBooleanObject = (BooleanObject) ModelFactory.getDefaultModel.createObject("customBooleanClass");

ByteArray #

A ByteArray can be used to store more complex data objects like serialized images or serialized documents. Internally, it is an array of bytes but conceptually it is used as one value, e.g., one serialized object. To distinguish the different kinds of content types, it is necessary to specify the mime type of the content. This can be text, image, audio, or video, for example.

To create a ByteArray class, the following XML code has to be used:

<ByteArrayClass name="costumByteArrayClass" mimeType="image" maxSize="500"/>

To create this class during runtime, the following java code has to be used:

ByteArrayClass byteArrayClass = (ByteArrayClass) ModelFactory.getDefaultModel().getClass(ByteArrayClass.CLASS_NAME);
ByteArrayClass customByteArrayClass = (ByteArrayClass) byteArrayClass.createSubclass("customByteArrayClass");
customByteArrayClass.setMimeType("image");
customByteArrayClass.setMaxSize(500);
customByteArrayClass.finishEditing();

To create an object of this class, the following java code has to be used:

ByteArrayObject byteArrayObject = (ByteArrayObject) ModelFactory.getDefaultModel().createObject("customByteArrayClass");

Chronological #

The Chronological class defines a specific instance in time with millisecond precision. The Chronological class is an abstract class that can not be instantiated directly. Thus, one of the inherited classes must be used:

Please note that all objects of chronological classes are totally ordered.

Date #

The Date class is the specification of a date (without time information). It represents a date as a value in milliseconds. The Date object extends the java.sql.Date as native object. The Date class represents a particular moment in time with millisecond precision since the 1st of January 1970. For this reason, it is not possible to represent dates before that day.

To create an object of this class, the following java code has to be used:

DateObject dateObject = (DateObject) ModelFactory.getDefaultModel().createObject(DateClass.CLASS_NAME);

To create a subclass of the Date class, the following XML definition can be used:

<DateClass name="customDateClass"/>

To create a subclass of this class during runtime, the following java code has to be used:

DateClass dateClass = ModelFactory.getDefaultModel().getClass(DateClass.CLASS_NAME);
DateClass customDateClass = (DateClass) dateClass.createSubclass("customDateClass");
customDateClass.finishEditing();

To create an object of this class, the following java code has to be used:

DateObject customDateObject = (DateObject) ModelFactory.getDefaultModel.createObject("customDateClass");

Time #

The Time class is the specification of a time (without date information). It represents time as a value in milliseconds. The Time object extends the java.sql.Time as native object. This class extends the java.sql.Date class. The Time class refers similar to the Date class to the 1st of January 1970.

To create an object of this class, the following java code has to be used:

TimeObject timeObject = (TimeObject) ModelFactory.getDefaultModel().createObject(TimeClass.CLASS_NAME);

To create a subclass of the Time class, the following XML definition can be used:

<TimeClass name="customTimeClass"/>

To create a subclass of this class during runtime, the following java code has to be used:

TimeClass timeClass = ModelFactory.getDefaultModel().getClass(TimeClass.CLASS_NAME);
TimeClass customTimeClass = (TimeClass) timeClass.createSubclass("customTimeClass");
customTimeClass.finishEditing();

To create an object of this class, the following java code has to be used:

TimeObject customTimeObject = (TimeObject) ModelFactory.getDefaultModel.createObject("customTimeClass");

Timestamp #

The Timestamp class is the specification of a date (with time information). It represents a date in the format yyyy-mm-dd hh:mm:ss and if desired, the seconds can be represented in smaller units with more characters. The Timestamp object extends the java.sql.Timestamp as native object. To be consistent with the Date and Time class, it is also not possible to represent a day before the 1st of January 1970.

To create an object of this class, the following java code has to be used:

TimestampObject timestampObject = (TimestampObject) ModelFactory.getDefaultModel().createObject(TimestampClass.CLASS_NAME);

To create a subclass of the Timestamp class, the following XML definition can be used:

<TimestampClass name="customTimestampClass"/>

To create a subclass of this class during runtime, the following java code has to be used:

TimestampClass timestampClass = ModelFactory.getDefaultModel().getClass(TimestampClass.CLASS_NAME);
TimestampClass customTimestampClass = (TimestampClass) timestampClass.createSubclass("customTimestampClass");
customTimestampClass.finishEditing();

To create an object of this class, the following java code has to be used:

TimestampObject customTimestampObject = (TimestampObject) ModelFactory.getDefaultModel.createObject("customTimestampClass");

Numeric #

The Numeric class defines a specific numerical object. The NumericClass is an abstract class that can not be instantiated directly. Thus, one of the inherited classes must be used:

Please note that all objects of numeric classes are totally ordered.

Double #

The Double class specifies double values similar to programming languages.

To create an object of this class, the following java code has to be used:

DoubleObject doubleObject = (DoubleObject) ModelFactory.getDefaultModel().createObject(DoubleClass.CLASS_NAME);

To create a subclass of the Double class, the following XML definition can be used:

<DoubleClass name="customDoubleClass"/>

To create a subclass of this class during runtime, the following java code has to be used:

DoubleClass doubleClass = ModelFactory.getDefaultModel().getClass(DoubleClass.CLASS_NAME);
DoubleClass customDoubleClass = (DoubleClass) doubleClass.createSubclass("customDoubleClass");
customDoubleClass.finishEditing();

To create an object of this class, the following java code has to be used:

DoubleObject customDoubleObject = (DoubleObject) ModelFactory.getDefaultModel.createObject("customDoubleClass");

Integer #

The Integer class specifies integer values similar to programming languages.

To create an object of this class, the following java code has to be used:

IntegerObject integerObject = (IntegerObject) ModelFactory.getDefaultModel().createObject(IntegerClass.CLASS_NAME);

To create a subclass of the Integer class, the following XML definition can be used:

<IntegerClass name="customIntegerClass"/>

To create a subclass of this class during runtime, the following java code has to be used:

IntegerClass integerClass = ModelFactory.getDefaultModel().getClass(IntegerClass.CLASS_NAME);
IntegerClass customIntegerClass = (IntegerClass) integerClass.createSubclass("customIntegerClass");
customIntegerClass.finishEditing();

To create an object of this class, the following java code has to be used:

IntegerObject customIntegerObject = (IntegerObject) ModelFactory.getDefaultModel.createObject("customIntegerClass");

String #

The String class defines the domain of String objects that represent string values.

To create an object of this class, the following java code has to be used:

StringObject stringObject = (StringObject) ModelFactory.getDefaultModel().createObject(StringClass.CLASS_NAME);

To create a subclass of the String class, the following XML definition can be used:

<StringClass name="customStringClass"/>

To create a subclass of this class during runtime, the following java code has to be used:

StringClass stringClass = ModelFactory.getDefaultModel().getClass(StringClass.CLASS_NAME);
StringClass customStringClass = (StringClass) stringClass.createSubclass("customStringClass");
customStringClass.finishEditing();

To create an object of this class, the following java code has to be used:

StringObject customStringObject = (StringObject) ModelFactory.getDefaultModel.createObject("customStringClass");

URI #

The URI class specifies a URI value from an ontology. Each URI class has to be linked to an ontology via its name. The class is abstract, so it has to be subclassed and provided with an ontology name:

<URIClass name="MyURIClass" ontologyName="myOnt"/>

To create a subclass of this class during runtime, the following java code has to be used:

URIClass uriClass = (URIClass) ModelFactory.getDefaultModel().getURISystemClass().createSubclass("MyURIClass");
uriClass.setOntologyName("myOnt");
uriClass.setAbstract(false);
uriClass.finishEditing();

The actual ontology has to be loaded beforehand from a file via the OntologyFactory where the name of the ontology has to be specified (see Configuration → Factories → OntologyFactory).

To create an object of this class, the following java code has to be used:

URIObject uriObject = ModelFactory.getDefaultModel().createObject("MyURIClass");
uriObject.setNativeURI("http://www.co-ode.org/ontologies/pizza/pizza.owl#AmericanHot");

The system throws an exception when the given URI value is not part of the ontology of the corresponding class.

Restricting value ranges #

The range of values of atomic classes may be restricted using an InstancePredicate. The following hierarchy of InstancePredicates exists in ProCAKE:

graph TD; InstancePredicate --> InstanceEnumerationPredicate; InstanceEnumerationPredicate --> InstanceValueOrderPredicate; InstanceValueOrderPredicate --> InstanceTaxonomyOrderPredicate; InstanceValueOrderPredicate --> InstanceTotalOrderPredicate; InstancePredicate --> InstanceIntervalPredicate; InstancePredicate --> InstanceOntologyOrderPredicate;

The following classes can be instantiated as predicate for atomic classes:

Instantiable Predicates Permitted data classes Methods in AtomicClass for creation
InstanceEnumerationPredicate All Atomic classes createNewInstanceEnumerationPredicate()
InstanceTaxonomyOrderPredicate String class createNewInstanceTaxonomyOrderPredicate()
InstanceTotalOrderPredicate String class createNewInstanceTotalOrderPredicate()
InstanceIntervalPredicate Numeric or chronological class createNewInstanceIntervalPredicate()
InstanceOntologyOrderPredicate URI class createNewInstanceOntologyOrderPredicate()

Please note that predicates can be only defined for custom atomic classes since system classes are abstract and not customizable. At run-time, it can be created using the the methods of AtomicClass, presented in the table above.

An interval predicate may be only used for Atomic classes that have totally ordered instances such as instances of subclasses from the Numeric or the Chronologic class. For example, a class Age as a subclass of the Integer class may restrict the value range to 0 and 150. These intervals are just restrictions of possible values of an attribute as a member of an Atomic class. It is not possible to define intervals in instances of classes.

An enumeration predicate restricts the set of valid values for a class. For example, a class Color as a subclass of the String class may restrict valid values to red, green, and blue. Furthermore, the enumeration of values can be ordered totally or arranged in taxonomies. An exceptional role plays the Atomic class ByteArray that can be used to store more complex data objects like serialized images or serialized documents. Internally, it is an array of bytes but conceptually it is used as one value, e.g., one serialized object.

It’s also possible to create a class using a enumeration predicate, that is a subclass of a custom class, which also uses a enumeration predicate. In this case, the restrictions of the super class are inherited to the subclass.

An ontology order predicate works similarly to an enumeration predicate by restricting the valid values for a class. The validity of values is restricted to these present in the subgraph represented by the given root node URI and the given set of relations.

InstanceIntervalPredicate #

In ProCAKE it is possible to set a lower and an upper bound to restrict the possible values for a custom Numeric or Chronological class. The definition of a lower and an upper bound can be defined in the model.xml file.

For example

<IntegerClass name="customIntegerInstanceIntervalPredicateClass" abstract="false">
    <InstanceIntervalPredicate lowerBound="0" upperBound="100"/>
</IntegerClass>

would create a subclass of Integer. The values for objects of this class are restricted from 0 to 100. Trying to create an object with other values would cause an exception.

To create this class during runtime, the following java code can be used:

IntegerClass integerClass = ModelFactory.getDefaultModel().getClass(IntegerClass.CLASS_NAME);
IntegerClass customIntegerClass = (IntegerClass) integerClass.createSubclass("customIntegerInstanceIntervalPredicateClass");
InstanceIntervalPredicate instanceIntervalPredicate = customIntegerClass.createNewInstanceIntervalPredicate();
IntegerObject lowerBound = (IntegerObject) customIntegerClass.getSuperClass().newObject();
lowerBound.setValueFromString("0");
instanceIntervalPredicate.setMinimum((TotallyOrdered) lowerBound);
IntegerObject upperBound = (IntegerObject) customIntegerClass.getSuperClass().newObject();
upperBound.setValueFromString("100");
instanceIntervalPredicate.setMaximum((TotallyOrdered) upperBound);
customIntegerClass.finishEditing();

Here, two Integer objects need to be created that represent the values for the lower and the upper bound. To set these values, it is necessary to get an InstanceIntervalPredicate. This can be called by using the class method createNewInstanceIntervalPredicate().

To create an object of this class, the following java code has to be used:

IntegerObject customIntegerObject = (IntegerObject) ModelFactory.getDefaultModel.createObject("customIntegerInstanceIntervalPredicateClass");

The value of this object can be set by using the method setNativeInteger of the parent class. If trying to use a value that is not in the defined interval, an exception will be thrown.

InstanceEnumerationPredicate #

In ProCAKE, it is possible to restrict the possible values for a custom Atomic class to a set of valid values. This definition can be specified in the model.xml file.

For example

<StringClass name="customInstanceEnumerationPredicateClass">
   <InstanceEnumerationPredicate>
      <Value v="1"/>
      <Value v="2"/>
      <Value v="3"/>
   </InstanceEnumerationPredicate>
</IntegerClass>

would create a subclass of String (with numeric values represented as String). There are only three possible values that objects of this class can have: 1, 2, and 3. Trying to create an object with other values would cause an exception.

To create this class during runtime, the following java code should be used:

StringClass stringClass = ModelFactory.getDefaultModel().getClass(StringClass.CLASS_NAME);
StringClass testEnumerationClass = (StringClass) stringClass.createSubclass("testEnumerationClass");
InstanceEnumerationPredicate instanceEnumerationPredicate = testEnumerationClass.createNewInstanceEnumerationPredicate();
StringObject firstValue = (StringObject) testEnumerationClass.getSuperClass().newObject();
firstValue.setValueFromString("1");
instanceEnumerationPredicate.addValue(firstValue);
testEnumerationClass.addAtomicObject(firstValue);
StringObject secondValue = (StringObject) testEnumerationClass.getSuperClass().newObject();
secondValue.setValueFromString("2");
instanceEnumerationPredicate.addValue(secondValue);
testEnumerationClass.addAtomicObject(secondValue);
StringObject thirdValue = (StringObject) testEnumerationClass.getSuperClass().newObject();
thirdValue.setValueFromString("3");
instanceEnumerationPredicate.addValue(thirdValue);
testEnumerationClass.addAtomicObject(thirdValue);
testEnumerationClass.finishEditing();

The InstanceEnumerationPredicate can be created by using the method createNewInstanceEnumerationPredicate(). Here, a String object (in general an Atomic object) needs to be created for each value. These can be added to the InstanceEnumerationPredicate by using the method addValue. They also need to be added to the created class by using the method addAtomicObject.

To create an object of this class, the following java code has to be used:

StringObject customStringObject = (StringObject) ModelFactory.getDefaultModel.createObject("testEnumerationClass");

The value of this object can be set by using the method setValueFromString of the parent class. If trying to use a value that is not in the defined set, an exception will be thrown.

InstanceValueOrderPredicate #

InstanceTotalOrderPredicate #

It is possible to define a total order for the values of a String class. Other Atomic classes are not allowed for this type.

To create such an order, the model.xml file may be extended as follows:

<StringClass name="testTotalOrderClass">
   <InstanceTotalOrderPredicate>
      <Value v="1"/>
      <Value v="3"/>
      <Value v="2"/>
   </InstanceTotalOrderPredicate>
</StringClass>

Here, the custom atomic class is a subclass of the String system class. The custom defined class has the values 1, 2, and 3. The order is created in the tag InstanceTotalOrderPredicate. This predicate inherits from its super predicate InstanceEnumerationPredicate. All values, defined in the total order are also the only allowed values for this class. The order is defined by listing the values according to this order.

By using this order during runtime, only the values that are defined in the atomic class can be used. Otherwise, an exception would be thrown. The runtime creation can look like:

StringClass stringClass = ModelFactory.getDefaultModel().getClass(StringClass.CLASS_NAME);
AtomicClass testTotalOrderClass = (AtomicClass) stringClass.createSubclass("testTotalOrderClass");
InstanceTotalOrderPredicate instanceTotalOrderPredicate = testTotalOrderClass.createNewInstanceTotalOrderPredicate();
AtomicObject firstValue = (AtomicObject) testTotalOrderClass.getSuperClass().newObject();
firstValue.setValueFromString("1");
instanceTotalOrderPredicate.add(firstValue);
testTotalOrderClass.addAtomicObject(firstValue);
AtomicObject secondValue = (AtomicObject) testTotalOrderClass.getSuperClass().newObject();
secondValue.setValueFromString("2");
instanceTotalOrderPredicate.add(secondValue);
testTotalOrderClass.addAtomicObject(secondValue);
AtomicObject thirdValue = (AtomicObject) testTotalOrderClass.getSuperClass().newObject();
thirdValue.setValueFromString("3");
instanceTotalOrderPredicate.add(thirdValue);
testTotalOrderClass.addAtomicObject(thirdValue);

testTotalOrderClass.finishEditing();

This code is nearly the same as above in the Enumeration example. Additionally, the total order is created by using the method createNewInstanceTotalOrderPredicate instead of the creation of InstanceEnmuerationPredicate. After this, the values have to be added with the method add in the preferred order (which also calls the method addValue of InstanceEnumerationPredicate, if not done manually).

InstanceTaxonomyOrderPredicate #

Taxonomies can be used to specify relationships between attribute values. In contrast to enumerations that only contain possible attribute values, a taxonomy represents an additional relationship between the symbols by their position in the taxonomy. A taxonomy is a n-ary tree in which the nodes represent symbolic values, i.e., string objects. Taxonomies can be build upon only StringObject by enumerating values and building a tree-like structure with a TaxonomyOrder.

In the model.xml file, the name of the StringClass and the corresponding super class that determines which kind of values are used must be defined. The tree structure of the values is specified by nesting nodes in the InstanceTaxonomyOrderPredicate. This predicate inherits from its super predicate InstanceEnumerationPredicate. All values, defined in the taxonomy order are also the only allowed values for this class. The order is defined by listing the values according to this order.

For example

<StringClass name="GraphicCardType">
   <InstanceTaxonomyOrderPredicate>
      <Node v="Graphics Card">
         <Node v="S3 Graphics Card">
            <Node v="S3 Virge Card">
               <Node v="ELSA 2000"/>
               <Node v="Stealth 3D200"/>
            </Node>
            <Node v="S3 Trio Card">
               <Node v="Miro Video"/>
               <Node v="VGA V64"/>
            </Node>
         </Node>
         <Node v="MGA Graphics Card">
            <Node v="Matrox Mill. 220"/>
            <Node v="Matrox Mystique"/>
         </Node>
      </Node>
   </InstanceTaxonomyOrderPredicate>
</StringClass>

creates the atomic class GraphicCardType with the default system super class String. During runtime, several graphic cards can be instantiated and the taxonomy defines their order.

To create this class during runtime, the following java code has to be used:

StringClass stringClass = ModelFactory.getDefaultModel().getClass(StringClass.CLASS_NAME);
StringClass taxonomyStringClass = (StringClass) stringClass.createSubclass("GraphicCardType");

InstanceTaxonomyOrderPredicate instanceTaxonomyOrderPredicate = taxonomyStringClass.createNewInstanceTaxonomyOrderPredicate();

StringObject graphicsCard = (StringObject ) taxonomyStringClass.getSuperClass().newObject();
graphicsCard.setValueFromString("Graphics Card");
instanceTaxonomyOrderPredicate.addValue(graphicsCard);
instanceTaxonomyOrderPredicate.addRelation(null, graphicsCard);

StringObject s3GraphicsCard = (StringObject ) taxonomyStringClass.getSuperClass().newObject();
s3GraphicsCard.setValueFromString("S3 Graphics Card");
instanceTaxonomyOrderPredicate.addValue(s3GraphicsCard);
instanceTaxonomyOrderPredicate.addRelation(graphicsCard, s3GraphicsCard);
StringObject s3VirgeCard = (StringObject ) taxonomyStringClass.getSuperClass().newObject();
s3VirgeCard.setValueFromString("S3 Virge Card");
instanceTaxonomyOrderPredicate.addRelation(s3GraphicsCard, s3VirgeCard);
StringObject elsa2000 = (StringObject ) taxonomyStringClass.getSuperClass().newObject();
elsa2000.setValueFromString("ELSA 2000");
instanceTaxonomyOrderPredicate.addRelation(s3VirgeCard, elsa2000);
StringObject stealth3D200 = (StringObject) taxonomyStringClass.getSuperClass().newObject();
stealth3D200.setValueFromString("Stealth 3D200");
instanceTaxonomyOrderPredicate.addRelation(s3VirgeCard, stealth3D200);
StringObject s3TrioCard = (StringObject) taxonomyStringClass.getSuperClass().newObject();
s3TrioCard.setValueFromString("S3 Trio Card");
instanceTaxonomyOrderPredicate.addRelation(s3GraphicsCard, s3TrioCard);
StringObject miroVideo = (StringObject) taxonomyStringClass.getSuperClass().newObject();
miroVideo.setValueFromString("Miro Video");
instanceTaxonomyOrderPredicate.addRelation(s3TrioCard, miroVideo);
StringObject vgaV64 = (StringObject) taxonomyStringClass.getSuperClass().newObject();
vgaV64.setValueFromString("VGA V64");
instanceTaxonomyOrderPredicate.addRelation(s3TrioCard, vgaV64);
StringObject mgaGraphicsCard = (StringObject) taxonomyStringClass.getSuperClass().newObject();
mgaGraphicsCard.setValueFromString("MGA Graphics Card");
instanceTaxonomyOrderPredicate.addRelation(graphicsCard, mgaGraphicsCard);
StringObject matroxMill220 = (StringObject) taxonomyStringClass.getSuperClass().newObject();
matroxMill220.setValueFromString("Matrox Mill. 220");
instanceTaxonomyOrderPredicate.addRelation(mgaGraphicsCard, matroxMill220);
StringObject matroxMystique = (StringObject) taxonomyStringClass.getSuperClass().newObject();
matroxMystique.setValueFromString("Matrox Mystique");
instanceTaxonomyOrderPredicate.addRelation(mgaGraphicsCard, matroxMystique);

taxonomyStringClass.finishEditing();

The InstanceTaxonomyOrderPredicate can be created by using the method createNewInstanceTaxonomyOrderPredicate(). For each value, a String object needs to be created. They and their parent node need to be added to the TaxonomyOrder by using the method addRelation(AtomicObject fatherNode, AtomicObject currentNode) of the taxonomy order (which also calls the method addValue of InstanceEnumerationPredicate, if not done manually).

Inheritance of Enumerations #

It’s also possible to create a custom Atomic class, which has a custom Atomic class as super class. If the super class has a value enumeration (defined directly or in its order), it is also used for the current class. Also, it’s possible, to define new values in a new value enumeration, which are only allowed in the new class and extend the allowed values.

For example, such a class can look like:

<StringClass name="GraphicsCardInheritanceClass" superClass="GraphicsCard">
   <InstanceEnumerationPredicate>
      <Value v="GeForce RTX 2060"/>
   </InstanceEnumerationPredicate>
</StringClass>

In this case, a atomic class is created, which allows the values of the class GraphicsCard. Additionally, the new value GeForce RTX 2060 is added for this class.

If a inherited class uses a InstanceValueOrderPredicate, it’s necessary, that all values, defined in the super class, are also existing in the super class. Otherwise, an exception would be thrown. It’s also possible, to inherited from other Atomic classes with InstancePredicates (for example, a Numeric class with a ValueEnumeration inherits from a Numeric class with an interval). In such cases, no specific behavior is provided. There is no check of the value range, but by means of the logger a warning is issued.

InstanceOntologyOrderPredicate #

This predicate can restrict the possible values to a subset of entities in the ontology. By providing a root node URI and a set of relations, a set of valid values is collected by traversing the subtree which is defined by the root and by the nodes reachable via the given relations.

Example:

<URIClass name="MyURIClass" ontologyName="myOnt">
  <InstanceOntologyOrderPredicate rootNodeURI="http://www.co-ode.org/ontologies/pizza/pizza.owl#NamedPizza">
    <Relation type="rdfs:subClassOf" />
    <Relation type="rdf:type" />
  </InstanceOntologyOrderPredicate>
</URIClass>

This allows http://www.co-ode.org/ontologies/pizza/pizza.owl#NamedPizza and all subclasses or individuals (via the rdf:type relation) in arbitrary depth of NamedPizza as values for objects of the class MyURIClass.