Knowledge Science GroupDept of Computer ScienceUniveristy of Calgary
public class Ontology extends Object implements Serializable
fatherOf accepts two
parameters, a father and a set of children;
Man is also of class
Person.
Ontology.People ontology contains an element schema called
Person. This schema states that a Person is
characterized by a name and by an address:
ConceptSchema personSchema = new ConceptSchema(PERSON);
personSchema.addSlot(NAME, stringSchema);
personSchema.addSlot(ADDRESS, addressSchema, ObjectSchema.OPTIONAL);
where PERSON, NAME and ADDRESS are
string constants. When you register your schema with the ontology, such
constants become part of the vocabulary of the ontology.
Schemas that describe concepts support inheritance. You can define the
concept Man as a refinement of the concept Person:
ConceptSchema manSchema = new ConceptSchema(MAN);
manSchema.addSuperSchema(personSchema);
Each element schema can be associated with a Java class to map elements of
the ontology that comply with a schema with Java objects of that class. The
following is a class that might be associated with the Person
schema:
public class Person extends Concept {
private String name = null;
private Address address = null;
public void setName(String name) {
this.name = name;
}
public void setAddress(Address address) {
this.address = address;
}
public String getName() {
return name;
}
public Address getAddress() {
return address;
}
}
When sending/receiving messages you can represent your content in terms of
objects belonging to classes that the ontology associates with schemas.
As the previous example suggests, you cannot use objects of class
Person when asking for the value of some attribute, e.g., when
asking for the value of address. Basically, the problem is that
you cannot 'assign' a variable to an attribute of an object, i.e.
you cannot write something like:
person.setName(new Variable("X")).
In order to solve this problem, you can describe your content in terms of
abstract descriptors. An abstract descriptor is an
object that reifies an element of the ontology.
The following is the creation of an abstract
descriptor for a concept of type Man:
AbsConcept absMan = new AbsConcept(MAN);
absMan.setSlot(NAME, "John");
absMan.setSlot(ADDRESS, absAddress);
where absAddress is the abstract descriptor for John's
address:
AbsConcept absAddress = new AbsConcept(ADDRESS);
absAddress.setSlot(CITY, "London");
Objects of class Ontology allows you to:
- register schemas with associated (i) a mandatory term of the
vocabulary e.g.
NAME and (ii) an optional Java class,
e.g. Person;
- retrieve the registered information through various keys.
The framework already provides the BasicOntology ontology
that provides all basic elements, i.e. primitive data types, aggregate
types, etc.
Application-specific ontologies should be implemented extending it.Concept,
AbsConcept,
ConceptSchema,
BasicOntology,
Serialized Form| Modifier and Type | Field and Description |
|---|---|
private static Class |
absObjectClass |
private Ontology[] |
base |
private Hashtable |
classes |
private Hashtable |
conceptSlots |
private static String |
DEFAULT_INTROSPECTOR_CLASS |
private Hashtable |
elements |
private Introspector |
introspector |
private Logger |
logger |
private String |
name |
private Hashtable |
schemas |
| Constructor and Description |
|---|
Ontology(String name,
Introspector introspector)
Construct an Ontology object with a given
name
that uses a given Introspector to
convert between Java objects and abstract descriptors. |
Ontology(String name,
Ontology base)
Construct an Ontology object with a given
name
that extends a given ontology. |
Ontology(String name,
Ontology[] base,
Introspector introspector)
Construct an Ontology object with a given
name
that extends a given set of ontologies and that uses a given Introspector to
convert between Java objects and abstract descriptors. |
Ontology(String name,
Ontology base,
Introspector introspector)
Construct an Ontology object with a given
name
that extends a given ontology and that uses a given Introspector to
convert between Java objects and abstract descriptors. |
| Modifier and Type | Method and Description |
|---|---|
void |
add(ObjectSchema schema)
Adds a schema to this ontology
|
void |
add(ObjectSchema schema,
Class javaClass)
Adds a schema to the ontology and associates it to the class
javaClass |
static void |
checkIsTerm(Object obj)
Check whether a given object is a valid term.
|
ConceptSlotFunction |
createConceptSlotFunction(String slotName,
Concept c)
Create a ConceptSlotFunction for a given slot of a given Concept.
|
protected void |
externalize(Object obj,
AbsObject abs,
ObjectSchema schema,
Ontology globalOnto)
Externalize (obj --> abs) the slots defined in
schema and its super-schemas |
static AbsObject |
externalizeSlotValue(Object obj,
Introspector introspector,
Ontology referenceOnto) |
private AbsObject |
externalizeSpecialType(Object obj,
ObjectSchema schema,
Class javaClass,
Ontology globalOnto) |
AbsObject |
fromObject(Object obj)
Converts a Java object into a proper abstract descriptor.
|
protected AbsObject |
fromObject(Object obj,
Ontology globalOnto)
Converts a Java object into a proper abstract descriptor.
|
List |
getActionNames()
Retrieve the names of all agent actions defined in this ontology (including extended ontologies).
|
Class |
getClassForElement(String name)
Retrieves the concrete class associated with element
name
in this ontology. |
List |
getConceptNames()
Retrieve the names of all concepts defined in this ontology (including extended ontologies).
|
private Ontology |
getDefiningOntology(String lcName)
Retrieves the ontology actually containing the definition of a given schema.
|
private Set |
getElementNames(Class c) |
Introspector |
getIntrospector() |
String |
getName()
Retrieves the name of this ontology.
|
List |
getOwnActionNames()
Retrieve the names of the agent actions defined in this ontology only (excluding extended ontologies).
|
List |
getOwnConceptNames()
Retrieve the names of the concepts defined in this ontology only (excluding extended ontologies).
|
private List |
getOwnElementNames(Class c) |
List |
getOwnPredicateNames()
Retrieve the names of the predicates defined in this ontology only (excluding extended ontologies).
|
List |
getPredicateNames()
Retrieve the names of all predicatess defined in this ontology (including extended ontologies).
|
ObjectSchema |
getSchema(Class clazz)
Retrieves the schema associated to a given class in this ontology.
|
ObjectSchema |
getSchema(String name)
Retrieves the schema of element
name in this ontology. |
Object |
getSlotValue(String slotName,
Object obj)
Retrieve the value of slot
slotName from object obj |
private Object |
getSlotValue(String slotName,
Object obj,
ObjectSchema schema) |
protected void |
internalize(AbsObject abs,
Object obj,
ObjectSchema schema,
Ontology globalOnto)
Internalize (abs --> obj) the slots defined in
schema and its super-schemas |
static Object |
internalizeSlotValue(AbsObject abs,
Introspector introspector,
Ontology referenceOnto) |
private Object |
internalizeSpecialType(AbsObject abs,
ObjectSchema schema,
Class javaClass,
Ontology globalOnto) |
void |
setSlotValue(String slotName,
Object slotValue,
Object obj)
Set the value of slot
slotName as slotValue to object obj |
private void |
setSlotValue(String slotName,
Object slotValue,
Object obj,
ObjectSchema schema) |
Object |
toObject(AbsObject abs)
Converts an abstract descriptor to a Java object of the proper class.
|
protected Object |
toObject(AbsObject abs,
String lcType,
Ontology globalOnto)
Converts an abstract descriptor to a Java object of the proper class.
|
String |
toString() |
protected void |
useConceptSlotsAsFunctions()
Instruct this ontology to support usage of concept slots as functions.
|
private static final String DEFAULT_INTROSPECTOR_CLASS
private Ontology[] base
private String name
private Introspector introspector
private Hashtable elements
private Hashtable classes
private Hashtable schemas
private Hashtable conceptSlots
private Logger logger
private static Class absObjectClass
public Ontology(String name, Ontology base)
name
that extends a given ontology.
The ReflectiveIntrospector is used by default to
convert between Java objects and abstract descriptors.name - The identifier of the ontology.base - The base ontology.public Ontology(String name, Introspector introspector)
name
that uses a given Introspector to
convert between Java objects and abstract descriptors.name - The identifier of the ontology.introspector - The introspector.public Ontology(String name, Ontology base, Introspector introspector)
name
that extends a given ontology and that uses a given Introspector to
convert between Java objects and abstract descriptors.name - The identifier of the ontology.base - The base ontology.introspector - The introspector.public Ontology(String name, Ontology[] base, Introspector introspector)
name
that extends a given set of ontologies and that uses a given Introspector to
convert between Java objects and abstract descriptors.name - The identifier of the ontology.base - The base ontology.introspector - The introspector.public String getName()
public Introspector getIntrospector()
public void add(ObjectSchema schema) throws OntologyException
schema - The schema to addOntologyExceptionpublic void add(ObjectSchema schema, Class javaClass) throws OntologyException
javaClassschema - the schema.javaClass - the concrete class.OntologyExceptionpublic ObjectSchema getSchema(String name) throws OntologyException
name in this ontology.
The search is extended to the base ontologies if the schema is not
found.name - the name of the schema in the vocabulary.null if the schema is not found.OntologyExceptionpublic ObjectSchema getSchema(Class clazz) throws OntologyException
clazz - the class whose associated schema must be retrieved.null if the schema is not found.OntologyExceptionpublic Object toObject(AbsObject abs) throws OntologyException, UngroundedException
abs - the abstract descriptor.UngroundedException - if the abstract descriptor contains a
variableOntologyException - if some mismatch with the schema is foundfromObject(Object)public AbsObject fromObject(Object obj) throws OntologyException
obj - the objectOntologyException - if some mismatch with the schema is foundtoObject(AbsObject)public Class getClassForElement(String name) throws OntologyException
name
in this ontology. The search is extended to the base ontologiesname - the name of the schema.name
is found or if no class is associated to that schema.OntologyException - if name is nullprivate Ontology getDefiningOntology(String lcName)
lcName - The lower-case version of the name of the schema whose defining ontology must be retrievedlcName or null if such schema
is not defined neither in this ontology nor in one of its super-ontologiesprotected Object toObject(AbsObject abs, String lcType, Ontology globalOnto) throws UnknownSchemaException, UngroundedException, OntologyException
abs - the abstract descriptor.lcType - the type of the abstract descriptor to be translated
aconverted into lower case. This is passed as parameters to avoid
making the conversion to lower case for each base ontology.globalOnto - The ontology this ontology is part of (i.e. the
ontology that extends this ontology).UnknownSchemaException - If no schema for the abs descriptor
to be translated is defined in this ontology.UngroundedException - if the abstract descriptor contains a
variableOntologyException - if some mismatch with the schema is found * ontology. In this case UnknownSchemaprivate Object internalizeSpecialType(AbsObject abs, ObjectSchema schema, Class javaClass, Ontology globalOnto) throws OntologyException
OntologyExceptionprotected void internalize(AbsObject abs, Object obj, ObjectSchema schema, Ontology globalOnto) throws OntologyException
schema and its super-schemasOntologyExceptionprotected AbsObject fromObject(Object obj, Ontology globalOnto) throws UnknownSchemaException, OntologyException
obj - the objectglobalOnto - The ontology this ontology is part of (i.e. the
ontology that extends this ontology).UnknownSchemaException - If no schema for the object to be
translated is defined in this ontology.OntologyException - if some mismatch with the schema is foundprivate AbsObject externalizeSpecialType(Object obj, ObjectSchema schema, Class javaClass, Ontology globalOnto) throws OntologyException
OntologyExceptionprotected void externalize(Object obj, AbsObject abs, ObjectSchema schema, Ontology globalOnto) throws OntologyException
schema and its super-schemasOntologyExceptionpublic void setSlotValue(String slotName, Object slotValue, Object obj) throws OntologyException
slotName as slotValue to object objOntologyExceptionprivate void setSlotValue(String slotName, Object slotValue, Object obj, ObjectSchema schema) throws OntologyException
OntologyExceptionpublic Object getSlotValue(String slotName, Object obj) throws OntologyException
slotName from object objOntologyExceptionprivate Object getSlotValue(String slotName, Object obj, ObjectSchema schema) throws OntologyException
OntologyExceptionpublic static void checkIsTerm(Object obj) throws OntologyException
List) it also check
the elements.OntologyException - if the given object is not a valid termpublic List getOwnConceptNames()
public List getConceptNames()
public List getOwnActionNames()
public List getActionNames()
public List getOwnPredicateNames()
public List getPredicateNames()
public ConceptSlotFunction createConceptSlotFunction(String slotName, Concept c) throws OntologyException
Person with a slot name and a slot age,
it is possible to create expression such asslotName - The name of the slotc - The concept a ConceptSlotFunction must be created for. This concept must have a slot called slotNameOntologyExceptionConceptSlotFunction,
useConceptSlotsAsFunctions()protected void useConceptSlotsAsFunctions()
ConceptSlotFunction,
createConceptSlotFunction(String, Concept)public static AbsObject externalizeSlotValue(Object obj, Introspector introspector, Ontology referenceOnto) throws OntologyException
OntologyExceptionpublic static Object internalizeSlotValue(AbsObject abs, Introspector introspector, Ontology referenceOnto) throws OntologyException
OntologyException