001: /*
002: * Created on Dez 03, 2005
003: */
004: package org.ontoware.rdf2go.vocabulary;
005:
006: import org.ontoware.rdf2go.model.node.URI;
007: import org.ontoware.rdf2go.model.node.impl.URIImpl;
008:
009: /**
010: * OWL vocabulary items as URIs
011: *
012: * there are all vocabulary items (OWL Full), some have usage-restrictions
013: * in other owl sublanguages (OWL DL and especially OWL Lite). They are not
014: * all stated here.
015: *
016: * The comments provided in this class are (almost) all derived form one of the
017: * following urls
018: *
019: * - http://www.w3.org/TR/owl-ref/
020: * - http://www.w3.org/TR/owl-semantics/
021: *
022: * @author wth (thiemann@blue-age.de), 2005
023: */
024: public class OWL {
025:
026: /**
027: * The OWL Namespace
028: */
029: public static final String OWL_NS = "http://www.w3.org/2002/07/owl#";
030:
031: protected static final URI toURI(String local) {
032: return new URIImpl(OWL_NS + local, false);
033: }
034:
035: //ontology header
036: /**
037: * An OWL ontology contains a sequence of annotations, axioms, and facts.
038: */
039: public static final URI Ontology = toURI("Ontology");
040: /**
041: * OWL has a built-in class owl:OntologyProperty.
042: * Instances of owl:OntologyProperty must have the class owl:Ontology as
043: * their domain and range. It is permitted to define other instances of
044: * owl:OntologyProperty.
045: */
046: public static final URI OntologyProperty = toURI("OntologyProperty");
047: /**
048: * OWL Full does not put any constraints on annotations in an ontology.
049: * OWL DL allows annotations on classes, properties, individuals and
050: * ontology headers, but only under the following conditions:
051: *
052: * - The sets of object properties, datatype properties, annotation properties
053: * and ontology properties must be mutually disjoint. Thus, in OWL DL
054: * dc:creator cannot be at the same time a datatype property and an
055: * annotation property.
056: * - Annotation properties must have an explicit typing triple of the form:
057: * -- AnnotationPropertyID rdf:type owl:AnnotationProperty .
058: * - Annotation properties must not be used in property axioms. Thus, in
059: * OWL DL one cannot define subproperties or domain/range constraints for
060: * annotation properties.
061: * - The object of an annotation property must be either a data literal, a
062: * URI reference, or an individual.
063: */
064: public static final URI AnnotationProperty = toURI("AnnotationProperty");
065: /**
066: * An owl:imports statement references another OWL ontology containing
067: * definitions, whose meaning is considered to be part of the meaning of
068: * the importing ontology. Each reference consists of a URI specifying from
069: * where the ontology is to be imported. Syntactically, owl:imports is a
070: * property with the class owl:Ontology as its domain and range.
071: *
072: * The owl:imports statements are transitive, that is, if ontology A
073: * imports B, and B imports C, then A imports both B and C.
074: */
075: public static final URI imports = toURI("imports");
076:
077: //classes
078: /**
079: * OWL distinguishes six types of class descriptions:
080: *
081: * 1. a class identifier (a URI reference)
082: * 2. an exhaustive enumeration of individuals that together form the
083: * instances of a class
084: * 3. a property restriction
085: * 4. the intersection of two or more class descriptions
086: * 5. the union of two or more class descriptions
087: * 6. the complement of a class description
088: */
089: public static final URI Class = toURI("Class");
090:
091: /**
092: * A property restriction is a special kind of class description. It
093: * describes an anonymous class, namely a class of all individuals that
094: * satisfy the restriction. OWL distinguishes two kinds of property
095: * restrictions: value constraints and cardinality constraints.
096: */
097: public static final URI Restriction = toURI("Restriction");
098: /**
099: * A restriction class should have exactly one triple linking the
100: * restriction to a particular property, using the owl:onProperty property.
101: */
102: public static final URI onProperty = toURI("onProperty");
103:
104: //cardinality restrictions
105: /**
106: * The cardinality constraint owl:cardinality is a built-in OWL property
107: * that links a restriction class to a data value belonging to the range of
108: * the XML Schema datatype nonNegativeInteger. A restriction containing an
109: * owl:cardinality constraint describes a class of all individuals that
110: * have exactly N semantically distinct values (individuals or data values)
111: * for the property concerned, where N is the value of the cardinality
112: * constraint. Syntactically, the cardinality constraint is represented as
113: * an RDF property element with the corresponding rdf:datatype attribute.
114: */
115: public static final URI cardinality = toURI("cardinality");
116: /**
117: * A restriction containing an owl:maxCardinality constraint describes a
118: * class of all individuals that have at most N semantically distinct values
119: * (individuals or data values) for the property concerned, where N is the
120: * value of the cardinality constraint.
121: */
122: public static final URI maxCardinality = toURI("maxCardinality");
123: /**
124: * A restriction containing an owl:minCardinality constraint describes a
125: * class of all individuals that have at least N semantically distinct
126: * values (individuals or data values) for the property concerned, where N
127: * is the value of the cardinality constraint.
128: */
129: public static final URI minCardinality = toURI("minCardinality");
130:
131: //value restricitons
132: public static final URI someValuesFrom = toURI("someValuesFrom");
133: public static final URI allValuesFrom = toURI("allValuesFrom");
134: public static final URI hasValue = toURI("hasValue");
135:
136: //intersection + union
137: public static final URI intersectionOf = toURI("intersectionOf");
138: public static final URI unionOf = toURI("unionOf");
139: public static final URI complementOf = toURI("complementOf");
140:
141: public static final URI equivalentClass = toURI("equivalentClass");
142: public static final URI disjointWith = toURI("disjointWith");
143:
144: //properties
145: public static final URI ObjectProperty = toURI("ObjectProperty");
146: public static final URI DatatypeProperty = toURI("DatatypeProperty");
147: public static final URI SymmetricProperty = toURI("SymmetricProperty");
148: public static final URI TransitiveProperty = toURI("TransitiveProperty");
149: public static final URI FunctionalProperty = toURI("FunctionalProperty");
150: public static final URI InverseFunctionalProperty = toURI("InverseFunctionalProperty");
151:
152: public static final URI equivalentProperty = toURI("equivalentProperty");
153: public static final URI inverseOf = toURI("inverseOf");
154:
155: //individuals
156: /**
157: * The class with identifier owl:Thing is the class of all individuals.
158: */
159: public static final URI Thing = toURI("Thing");
160: /**
161: * The class with identifier owl:Nothing is the empty class.
162: */
163: public static final URI Nothing = toURI("Nothing");
164:
165: public static final URI sameAs = toURI("sameAs");
166: public static final URI differentFrom = toURI("differentFrom");
167: public static final URI AllDifferent = toURI("AllDifferent");
168: public static final URI distinctMembers = toURI("distinctMembers");
169:
170: //Datatype enumeration
171: public static final URI DataRange = toURI("DataRange");
172: public static final URI oneOf = toURI("oneOf");
173:
174: //Version information
175: /**
176: * An owl:versionInfo statement generally has as its object a string giving
177: * information about this version, for example RCS/CVS keywords. This
178: * statement does not contribute to the logical meaning of the ontology
179: * other than that given by the RDF(S) model theory.
180: *
181: * Although this property is typically used to make statements about
182: * ontologies, it may be applied to any OWL construct. For example, one
183: * could attach a owl:versionInfo statement to an OWL class.
184: *
185: * NOTE: owl:versionInfo is an instance of owl:AnnotationProperty.
186: */
187: public static final URI versionInfo = toURI("versionInfo");
188: /**
189: * An owl:priorVersion statement contains a reference to another ontology.
190: * This identifies the specified ontology as a prior version of the
191: * containing ontology. This has no meaning in the model-theoretic
192: * semantics other than that given by the RDF(S) model theory. However, it
193: * may be used by software to organize ontologies by versions.
194: *
195: * owl:priorVersion is a built-in OWL property with the class owl:Ontology
196: * as its domain and range.
197: *
198: * NOTE: owl:priorVersion is an instance of owl:OntologyProperty.
199: */
200: public static final URI priorVersion = toURI("priorVersion");
201: /**
202: * An owl:backwardCompatibleWith statement contains a reference to another
203: * ontology. This identifies the specified ontology as a prior version of
204: * the containing ontology, and further indicates that it is backward
205: * compatible with it. In particular, this indicates that all identifiers
206: * from the previous version have the same intended interpretations in the
207: * new version. Thus, it is a hint to document authors that they can safely
208: * change their documents to commit to the new version (by simply updating
209: * namespace declarations and owl:imports statements to refer to the URL of
210: * the new version). If owl:backwardCompatibleWith is not declared for two
211: * versions, then compatibility should not be assumed.
212: *
213: * owl:backwardCompatibleWith has no meaning in the model theoretic
214: * semantics other than that given by the RDF(S) model theory.
215: *
216: * owl:backwardCompatibleWith is a built-in OWL property with the class
217: * owl:Ontology as its domain and range.
218: *
219: * NOTE: owl:backwardCompatibleWith is an instance of owl:OntologyProperty.
220: */
221: public static final URI backwardCompatibleWith = toURI("backwardCompatibleWith");
222: /**
223: * An owl:incompatibleWith statement contains a reference to another
224: * ontology. This indicates that the containing ontology is a later version
225: * of the referenced ontology, but is not backward compatible with it.
226: * Essentially, this is for use by ontology authors who want to be explicit
227: * that documents cannot upgrade to use the new version without checking
228: * whether changes are required.
229: *
230: * owl:incompatibleWith has no meaning in the model theoretic semantics
231: * other than that given by the RDF(S) model theory.
232: *
233: * owl:incompatibleWith is a built-in OWL property with the class
234: * owl:Ontology as its domain and range.
235: *
236: * NOTE: owl:backwardCompatibleWith is an instance of owl:OntologyProperty.
237: */
238: public static final URI incompatibleWith = toURI("incompatibleWith");
239: /**
240: * Here, a specific identifier is said to be of type owl:DeprecatedClass,
241: * which is a subclass of rdfs:Class. By deprecating a term, it means that
242: * the term should not be used in new documents that commit to the ontology.
243: * This allows an ontology to maintain backward-compatibility while phasing
244: * out an old vocabulary (thus, it only makes sense to use deprecation in
245: * combination with backward compatibility).
246: */
247: public static final URI DeprecatedClass = toURI("DeprecatedClass");
248: /**
249: * Here, a specific identifier is said to be of type or
250: * owl:DeprecatedProperty, which is a subclass of rdf:Property.
251: * @see OWL#DeprecatedClass
252: */
253: public static final URI DeprecatedProperty = toURI("DeprecatedProperty");
254:
255: }
|