@skaterqiang/protege-js 0.1.0

package/src/model/OWLClassExpression.js

@@ -0,0 +1,242 @@
+'use strict';
+
+const { OWLClass } = require('./OWLEntity');
+
+// ---------------------------------------------------------------------------
+// OWLClassExpression — mirrors org.semanticweb.owlapi.model.OWLClassExpression
+// Named classes are OWLClass instances; anonymous expressions are objects
+// created here: ObjectIntersectionOf / ObjectUnionOf / ObjectComplementOf /
+// ObjectSomeValuesFrom / ObjectAllValuesFrom / ObjectHasValue /
+// ObjectOneOf / ObjectExactCardinality / etc.
+// ---------------------------------------------------------------------------
+
+const ClassExpressionType = Object.freeze({
+  OWL_CLASS: 'OWLClass',
+  // Object-side
+  OBJECT_INTERSECTION_OF: 'ObjectIntersectionOf',
+  OBJECT_UNION_OF: 'ObjectUnionOf',
+  OBJECT_COMPLEMENT_OF: 'ObjectComplementOf',
+  OBJECT_SOME_VALUES_FROM: 'ObjectSomeValuesFrom',
+  OBJECT_ALL_VALUES_FROM: 'ObjectAllValuesFrom',
+  OBJECT_HAS_VALUE: 'ObjectHasValue',
+  OBJECT_ONE_OF: 'ObjectOneOf',
+  OBJECT_HAS_SELF: 'ObjectHasSelf',
+  OBJECT_MIN_CARDINALITY: 'ObjectMinCardinality',
+  OBJECT_MAX_CARDINALITY: 'ObjectMaxCardinality',
+  OBJECT_EXACT_CARDINALITY: 'ObjectExactCardinality',
+  OBJECT_MIN_QUALIFIED_CARDINALITY: 'ObjectMinQualifiedCardinality',
+  OBJECT_MAX_QUALIFIED_CARDINALITY: 'ObjectMaxQualifiedCardinality',
+  OBJECT_EXACT_QUALIFIED_CARDINALITY: 'ObjectExactQualifiedCardinality',
+  // Data-side
+  DATA_SOME_VALUES_FROM: 'DataSomeValuesFrom',
+  DATA_ALL_VALUES_FROM: 'DataAllValuesFrom',
+  DATA_HAS_VALUE: 'DataHasValue',
+  DATA_MIN_CARDINALITY: 'DataMinCardinality',
+  DATA_MAX_CARDINALITY: 'DataMaxCardinality',
+  DATA_EXACT_CARDINALITY: 'DataExactCardinality',
+  // Data ranges (not strictly class expressions but part of OWL2 syntax)
+  DATA_INTERSECTION_OF: 'DataIntersectionOf',
+  DATA_UNION_OF: 'DataUnionOf',
+  DATA_COMPLEMENT_OF: 'DataComplementOf',
+  DATA_ONE_OF: 'DataOneOf',
+  DATATYPE_RESTRICTION: 'DatatypeRestriction'
+});
+
+class OWLObjectIntersectionOf {
+  constructor(operands) {
+    this.type = ClassExpressionType.OBJECT_INTERSECTION_OF;
+    this.operands = operands.slice();
+  }
+  toString() { return `(${this.operands.map(String).join(' and ')})`; }
+}
+
+class OWLObjectUnionOf {
+  constructor(operands) {
+    this.type = ClassExpressionType.OBJECT_UNION_OF;
+    this.operands = operands.slice();
+  }
+  toString() { return `(${this.operands.map(String).join(' or ')})`; }
+}
+
+class OWLObjectComplementOf {
+  constructor(operand) {
+    this.type = ClassExpressionType.OBJECT_COMPLEMENT_OF;
+    this.operand = operand;
+  }
+  toString() { return `(not ${this.operand})`; }
+}
+
+class OWLObjectSomeValuesFrom {
+  constructor(property, filler) {
+    this.type = ClassExpressionType.OBJECT_SOME_VALUES_FROM;
+    this.property = property;
+    this.filler = filler;
+  }
+  toString() { return `(${this.property.getShortForm()} some ${this.filler})`; }
+}
+
+class OWLObjectAllValuesFrom {
+  constructor(property, filler) {
+    this.type = ClassExpressionType.OBJECT_ALL_VALUES_FROM;
+    this.property = property;
+    this.filler = filler;
+  }
+  toString() { return `(${this.property.getShortForm()} only ${this.filler})`; }
+}
+
+class OWLObjectHasValue {
+  constructor(property, value) {
+    this.type = ClassExpressionType.OBJECT_HAS_VALUE;
+    this.property = property;
+    this.value = value; // OWLNamedIndividual
+  }
+  toString() { return `(${this.property.getShortForm()} value ${this.value.getShortForm()})`; }
+}
+
+class OWLObjectOneOf {
+  constructor(individuals) {
+    this.type = ClassExpressionType.OBJECT_ONE_OF;
+    this.operands = individuals.slice();
+  }
+  toString() { return `{${this.operands.map(i => i.getShortForm()).join(', ')}}`; }
+}
+
+class OWLObjectCardinalityRestriction {
+  constructor(type, cardinality, property, filler) {
+    this.type = type;
+    this.cardinality = cardinality;
+    this.property = property;
+    this.filler = filler;
+  }
+  toString() {
+    const op = this.type === ClassExpressionType.OBJECT_MIN_CARDINALITY
+      || this.type === ClassExpressionType.OBJECT_MIN_QUALIFIED_CARDINALITY ? 'min'
+      : this.type === ClassExpressionType.OBJECT_MAX_CARDINALITY
+      || this.type === ClassExpressionType.OBJECT_MAX_QUALIFIED_CARDINALITY ? 'max' : 'exactly';
+    return `(${this.property.getShortForm()} ${op} ${this.cardinality} ${this.filler || ''})`;
+  }
+}
+
+class OWLObjectHasSelf {
+  constructor(property) {
+    this.type = ClassExpressionType.OBJECT_HAS_SELF;
+    this.property = property;
+  }
+  toString() { return `(${this.property.getShortForm()} Self)`; }
+}
+
+// ---- Data-side class expressions -------------------------------------------
+
+class OWLDataSomeValuesFrom {
+  constructor(property, dataRange) {
+    this.type = ClassExpressionType.DATA_SOME_VALUES_FROM;
+    this.property = property;
+    this.filler = dataRange;
+  }
+  toString() { return `(${this.property.getShortForm()} some ${this.filler})`; }
+}
+
+class OWLDataAllValuesFrom {
+  constructor(property, dataRange) {
+    this.type = ClassExpressionType.DATA_ALL_VALUES_FROM;
+    this.property = property;
+    this.filler = dataRange;
+  }
+  toString() { return `(${this.property.getShortForm()} only ${this.filler})`; }
+}
+
+class OWLDataHasValue {
+  constructor(property, literal) {
+    this.type = ClassExpressionType.DATA_HAS_VALUE;
+    this.property = property;
+    this.value = literal; // OWLLiteral
+  }
+  toString() { return `(${this.property.getShortForm()} value ${this.value})`; }
+}
+
+class OWLDataCardinalityRestriction {
+  constructor(type, cardinality, property, dataRange) {
+    this.type = type;
+    this.cardinality = cardinality;
+    this.property = property;
+    this.filler = dataRange;
+  }
+  toString() {
+    const op = this.type === ClassExpressionType.DATA_MIN_CARDINALITY ? 'min'
+      : this.type === ClassExpressionType.DATA_MAX_CARDINALITY ? 'max' : 'exactly';
+    return `(${this.property.getShortForm()} ${op} ${this.cardinality} ${this.filler || ''})`;
+  }
+}
+
+// ---- Data ranges ------------------------------------------------------------
+
+class OWLDataIntersectionOf {
+  constructor(operands) {
+    this.type = ClassExpressionType.DATA_INTERSECTION_OF;
+    this.operands = operands.slice();
+  }
+  toString() { return `(${this.operands.map(String).join(' and ')})`; }
+}
+
+class OWLDataUnionOf {
+  constructor(operands) {
+    this.type = ClassExpressionType.DATA_UNION_OF;
+    this.operands = operands.slice();
+  }
+  toString() { return `(${this.operands.map(String).join(' or ')})`; }
+}
+
+class OWLDataComplementOf {
+  constructor(operand) {
+    this.type = ClassExpressionType.DATA_COMPLEMENT_OF;
+    this.operand = operand;
+  }
+  toString() { return `(not ${this.operand})`; }
+}
+
+class OWLDataOneOf {
+  constructor(literals) {
+    this.type = ClassExpressionType.DATA_ONE_OF;
+    this.operands = literals.slice();
+  }
+  toString() { return `{${this.operands.join(', ')}}`; }
+}
+
+class OWLDatatypeRestriction {
+  constructor(datatype, facetRestrictions) {
+    this.type = ClassExpressionType.DATATYPE_RESTRICTION;
+    this.datatype = datatype;             // OWLDatatype
+    this.facetRestrictions = facetRestrictions.slice(); // [{facet: IRI, value: OWLLiteral}]
+  }
+  toString() {
+    const fr = this.facetRestrictions.map(f => `${f.facet.getShortForm()} ${f.value}`).join(' ');
+    return `${this.datatype.getShortForm()}[${fr}]`;
+  }
+}
+
+function isNamedClass(expr) {
+  return expr instanceof OWLClass;
+}
+
+module.exports = {
+  ClassExpressionType,
+  OWLObjectIntersectionOf,
+  OWLObjectUnionOf,
+  OWLObjectComplementOf,
+  OWLObjectSomeValuesFrom,
+  OWLObjectAllValuesFrom,
+  OWLObjectHasValue,
+  OWLObjectOneOf,
+  OWLObjectHasSelf,
+  OWLObjectCardinalityRestriction,
+  OWLDataSomeValuesFrom,
+  OWLDataAllValuesFrom,
+  OWLDataHasValue,
+  OWLDataCardinalityRestriction,
+  OWLDataIntersectionOf,
+  OWLDataUnionOf,
+  OWLDataComplementOf,
+  OWLDataOneOf,
+  OWLDatatypeRestriction,
+  isNamedClass
+};

package/src/model/OWLEntity.js

@@ -0,0 +1,142 @@
+'use strict';
+
+const { IRI } = require('./IRI');
+
+// ---------------------------------------------------------------------------
+// OWLEntity — mirrors org.semanticweb.owlapi.model.OWLEntity hierarchy
+// OWLClass, OWLObjectProperty, OWLDataProperty, OWLNamedIndividual,
+// OWLDatatype, OWLAnnotationProperty
+// ---------------------------------------------------------------------------
+
+const EntityType = Object.freeze({
+  CLASS: 'Class',
+  OBJECT_PROPERTY: 'ObjectProperty',
+  DATA_PROPERTY: 'DataProperty',
+  NAMED_INDIVIDUAL: 'NamedIndividual',
+  DATATYPE: 'Datatype',
+  ANNOTATION_PROPERTY: 'AnnotationProperty'
+});
+
+class OWLEntity {
+  constructor(iri, entityType) {
+    this.iri = iri instanceof IRI ? iri : IRI.create(iri);
+    this.entityType = entityType;
+  }
+
+  getIRI() {
+    return this.iri;
+  }
+
+  getEntityType() {
+    return this.entityType;
+  }
+
+  getShortForm() {
+    return this.iri.getShortForm();
+  }
+
+  isOWLClass() { return this.entityType === EntityType.CLASS; }
+  isOWLObjectProperty() { return this.entityType === EntityType.OBJECT_PROPERTY; }
+  isOWLDataProperty() { return this.entityType === EntityType.DATA_PROPERTY; }
+  isOWLNamedIndividual() { return this.entityType === EntityType.NAMED_INDIVIDUAL; }
+  isOWLDatatype() { return this.entityType === EntityType.DATATYPE; }
+  isOWLAnnotationProperty() { return this.entityType === EntityType.ANNOTATION_PROPERTY; }
+
+  equals(other) {
+    return other instanceof OWLEntity
+      && other.entityType === this.entityType
+      && other.iri.equals(this.iri);
+  }
+
+  toString() {
+    return `${this.entityType}(<${this.iri}>)`;
+  }
+}
+
+class OWLClass extends OWLEntity {
+  constructor(iri) { super(iri, EntityType.CLASS); }
+}
+
+class OWLObjectProperty extends OWLEntity {
+  constructor(iri) { super(iri, EntityType.OBJECT_PROPERTY); }
+}
+
+class OWLDataProperty extends OWLEntity {
+  constructor(iri) { super(iri, EntityType.DATA_PROPERTY); }
+}
+
+class OWLNamedIndividual extends OWLEntity {
+  constructor(iri) { super(iri, EntityType.NAMED_INDIVIDUAL); }
+}
+
+class OWLDatatype extends OWLEntity {
+  constructor(iri) { super(iri, EntityType.DATATYPE); }
+}
+
+class OWLAnnotationProperty extends OWLEntity {
+  constructor(iri) { super(iri, EntityType.ANNOTATION_PROPERTY); }
+}
+
+// ---------------------------------------------------------------------------
+// OWLAnonymousIndividual — mirrors org.semanticweb.owlapi.model.OWLAnonymousIndividual
+// An individual identified only by a blank node id (Turtle _:b0), not by an IRI.
+// ---------------------------------------------------------------------------
+
+class OWLAnonymousIndividual {
+  constructor(nodeId) {
+    if (!nodeId) throw new Error('OWLAnonymousIndividual requires a nodeId');
+    this.nodeId = String(nodeId);
+  }
+
+  getNodeId() { return this.nodeId; }
+
+  isAnonymous() { return true; }
+  isNamed() { return false; }
+  isOWLNamedIndividual() { return false; }
+  isOWLAnonymousIndividual() { return true; }
+
+  getEntityType() { return EntityType.NAMED_INDIVIDUAL; } // treated as individual in indexes
+
+  equals(other) {
+    return other instanceof OWLAnonymousIndividual && other.nodeId === this.nodeId;
+  }
+
+  getShortForm() { return this.nodeId; }
+
+  toString() { return `_:${this.nodeId.replace(/^_:/, '')}`; }
+}
+
+/** Well-known entities. */
+const OWL = Object.freeze({
+  THING: new OWLClass('http://www.w3.org/2002/07/owl#Thing'),
+  NOTHING: new OWLClass('http://www.w3.org/2002/07/owl#Nothing'),
+  TOP_OBJECT_PROPERTY: new OWLObjectProperty('http://www.w3.org/2002/07/owl#topObjectProperty'),
+  BOTTOM_OBJECT_PROPERTY: new OWLObjectProperty('http://www.w3.org/2002/07/owl#bottomObjectProperty'),
+  TOP_DATA_PROPERTY: new OWLDataProperty('http://www.w3.org/2002/07/owl#topDataProperty'),
+  BOTTOM_DATA_PROPERTY: new OWLDataProperty('http://www.w3.org/2002/07/owl#bottomDataProperty')
+});
+
+/** Entity factory — mirrors OWLDataFactory entity getters. */
+class OWLEntityFactory {
+  getOWLClass(iri) { return new OWLClass(iri); }
+  getOWLObjectProperty(iri) { return new OWLObjectProperty(iri); }
+  getOWLDataProperty(iri) { return new OWLDataProperty(iri); }
+  getOWLNamedIndividual(iri) { return new OWLNamedIndividual(iri); }
+  getOWLDatatype(iri) { return new OWLDatatype(iri); }
+  getOWLAnnotationProperty(iri) { return new OWLAnnotationProperty(iri); }
+  getOWLAnonymousIndividual(nodeId) { return new OWLAnonymousIndividual(nodeId); }
+}
+
+module.exports = {
+  EntityType,
+  OWLEntity,
+  OWLClass,
+  OWLObjectProperty,
+  OWLDataProperty,
+  OWLNamedIndividual,
+  OWLAnonymousIndividual,
+  OWLDatatype,
+  OWLAnnotationProperty,
+  OWL,
+  OWLEntityFactory
+};

package/src/model/OWLLiteral.js

@@ -0,0 +1,30 @@
+'use strict';
+
+// ---------------------------------------------------------------------------
+// OWLLiteral — mirrors org.semanticweb.owlapi.model.OWLLiteral
+// ---------------------------------------------------------------------------
+
+class OWLLiteral {
+  constructor(lexicalValue, datatype = null, lang = null) {
+    this.lexicalValue = String(lexicalValue);
+    this.datatype = datatype; // OWLDatatype | null
+    this.lang = lang;         // language tag | null
+  }
+  getLiteral() { return this.lexicalValue; }
+  getLang() { return this.lang; }
+  getDatatype() { return this.datatype; }
+  toString() {
+    let s = `"${this.lexicalValue}"`;
+    if (this.lang) s += `@${this.lang}`;
+    else if (this.datatype) s += `^^<${this.datatype.getIRI()}>`;
+    return s;
+  }
+  equals(other) {
+    return other instanceof OWLLiteral
+      && other.lexicalValue === this.lexicalValue
+      && other.lang === this.lang
+      && String(other.datatype) === String(this.datatype);
+  }
+}
+
+module.exports = { OWLLiteral };

package/src/model/OWLModelManager.js

@@ -0,0 +1,106 @@
+'use strict';
+
+const { OWLOntology, OWLOntologyID } = require('./OWLOntology');
+const { EventType, OWLModelManagerChangeEvent } = require('./event/OWLModelManagerEvent');
+
+// ---------------------------------------------------------------------------
+// OWLModelManager — mirrors org.protege.editor.owl.model.OWLModelManager /
+// OWLModelManagerImpl. Holds a set of ontologies, the active ontology,
+// fires change events, and exposes hierarchy providers.
+// ---------------------------------------------------------------------------
+
+class OWLModelManager {
+  constructor() {
+    this._ontologies = new Map(); // key: ontology id string
+    this._activeOntology = null;
+    this._listeners = new Set();
+    this._hierarchyProviders = new Map(); // EntityType -> provider
+  }
+
+  // --- ontology registry -----------------------------------------------------
+
+  addOntology(ontology) {
+    const key = ontology.getOntologyID().toString();
+    this._ontologies.set(key, ontology);
+    this._fire(EventType.ONTOLOGY_CREATED, ontology);
+    if (!this._activeOntology) {
+      this.setActiveOntology(ontology);
+    }
+    return ontology;
+  }
+
+  createOntology(ontologyIRI = null) {
+    const ont = new OWLOntology(new OWLOntologyID(ontologyIRI));
+    return this.addOntology(ont);
+  }
+
+  removeOntology(ontology) {
+    const key = ontology.getOntologyID().toString();
+    const removed = this._ontologies.delete(key);
+    if (removed && this._activeOntology === ontology) {
+      this._activeOntology = this.getOntologies()[0] || null;
+      this._fire(EventType.ACTIVE_ONTOLOGY_CHANGED, this._activeOntology);
+    }
+    return removed;
+  }
+
+  getOntologies() { return [...this._ontologies.values()]; }
+
+  setActiveOntology(ontology) {
+    if (this._activeOntology !== ontology) {
+      this._activeOntology = ontology;
+      this._fire(EventType.ACTIVE_ONTOLOGY_CHANGED, ontology);
+    }
+  }
+
+  getActiveOntology() { return this._activeOntology; }
+
+  // --- change events ---------------------------------------------------------
+
+  addListener(listener) {
+    this._listeners.add(listener);
+  }
+
+  removeListener(listener) {
+    this._listeners.delete(listener);
+  }
+
+  _fire(type, payload) {
+    const event = new OWLModelManagerChangeEvent(type, payload);
+    for (const l of this._listeners) {
+      try { l(event); } catch (e) { console.error('OWLModelManager listener error:', e); }
+    }
+  }
+
+  fireEvent(type, payload) {
+    this._fire(type, payload);
+  }
+
+  // --- hierarchy providers ---------------------------------------------------
+
+  setOWLClassHierarchyProvider(provider) {
+    this._hierarchyProviders.set('CLASS', provider);
+  }
+
+  getOWLClassHierarchyProvider() {
+    return this._hierarchyProviders.get('CLASS') || null;
+  }
+
+  setOWLObjectPropertyHierarchyProvider(provider) {
+    this._hierarchyProviders.set('OBJECT_PROPERTY', provider);
+  }
+
+  getOWLObjectPropertyHierarchyProvider() {
+    return this._hierarchyProviders.get('OBJECT_PROPERTY') || null;
+  }
+
+  setOWLDataPropertyHierarchyProvider(provider) {
+    this._hierarchyProviders.set('DATA_PROPERTY', provider);
+  }
+
+  getOWLDataPropertyHierarchyProvider() {
+    return this._hierarchyProviders.get('DATA_PROPERTY') || null;
+  }
+}
+
+module.exports = { OWLModelManager };

package/src/model/OWLOntology.js

@@ -0,0 +1,119 @@
+'use strict';
+
+const { AxiomType } = require('./OWLAxiom');
+const { EntityType } = require('./OWLEntity');
+
+// ---------------------------------------------------------------------------
+// OWLOntology — mirrors org.semanticweb.owlapi.model.OWLOntology
+// An in-memory set of axioms plus an ontology IRI / version IRI.
+// ---------------------------------------------------------------------------
+
+class OWLOntologyID {
+  constructor(ontologyIRI = null, versionIRI = null) {
+    this.ontologyIRI = ontologyIRI;
+    this.versionIRI = versionIRI;
+  }
+  isAnonymous() { return !this.ontologyIRI; }
+  toString() {
+    if (this.isAnonymous()) return 'OntologyID(Anonymous)';
+    return `OntologyID(<${this.ontologyIRI}>${this.versionIRI ? ' version <' + this.versionIRI + '>' : ''})`;
+  }
+}
+
+class OWLOntology {
+  constructor(id = new OWLOntologyID()) {
+    this.id = id;
+    this._axioms = new Set();
+    this._ontologyAnnotations = []; // OWLAnnotationAssertion on the ontology itself
+    this.format = null; // e.g. 'RDF/XML', 'Turtle'
+    // Ontology header (W3C OWL 2 §3.1): imports closure + version compatibility
+    this.imports = [];
+    this.priorVersion = [];
+    this.backwardCompatibleWith = [];
+    this.incompatibleWith = [];
+    // Prefix fidelity: prefix -> namespace map captured at parse time so
+    // writers can re-emit the original abbreviations.
+    this.prefixes = {};
+  }
+
+  /** Record a prefix mapping (e.g. 'ex' -> 'http://ex.org/'). */
+  addPrefix(prefix, namespace) { this.prefixes[prefix] = namespace; }
+
+  /** Get the recorded prefix map. */
+  getPrefixes() { return Object.assign({}, this.prefixes); }
+
+  getOntologyID() { return this.id; }
+
+  isAnonymous() { return this.id.isAnonymous(); }
+
+  getAxiomCount() { return this._axioms.size; }
+
+  getAxioms() { return [...this._axioms]; }
+
+  addAxiom(axiom) {
+    this._axioms.add(axiom);
+    return true;
+  }
+
+  removeAxiom(axiom) {
+    return this._axioms.delete(axiom);
+  }
+
+  getAxiomsOfType(type) {
+    return this.getAxioms().filter(a => a.getAxiomType() === type);
+  }
+
+  // --- entity indexes --------------------------------------------------------
+
+  getClassesInSignature() { return this._entitiesOf(EntityType.CLASS); }
+  getObjectPropertiesInSignature() { return this._entitiesOf(EntityType.OBJECT_PROPERTY); }
+  getDataPropertiesInSignature() { return this._entitiesOf(EntityType.DATA_PROPERTY); }
+  getIndividualsInSignature() { return this._entitiesOf(EntityType.NAMED_INDIVIDUAL); }
+  getAnnotationPropertiesInSignature() { return this._entitiesOf(EntityType.ANNOTATION_PROPERTY); }
+
+  _entitiesOf(entityType) {
+    const byIri = new Map();
+    for (const ax of this._axioms) {
+      for (const e of ax.entities()) {
+        if (e.getEntityType && e.getEntityType() === entityType) {
+          byIri.set(e.getIRI().toString(), e);
+        }
+      }
+    }
+    return [...byIri.values()];
+  }
+
+  // --- subclass indexes (asserted) ------------------------------------------
+
+  getSubClassAxiomsForSubClass(cls) {
+    return this.getAxiomsOfType(AxiomType.SUBCLASS_OF)
+      .filter(a => a.subClass && a.subClass.equals && a.subClass.equals(cls));
+  }
+
+  getSubClassAxiomsForSuperClass(cls) {
+    return this.getAxiomsOfType(AxiomType.SUBCLASS_OF)
+      .filter(a => a.superClass && a.superClass.equals && a.superClass.equals(cls));
+  }
+
+  // --- annotations -----------------------------------------------------------
+
+  addOntologyAnnotation(annotationAssertion) {
+    this._ontologyAnnotations.push(annotationAssertion);
+  }
+
+  getOntologyAnnotations() { return this._ontologyAnnotations.slice(); }
+
+  getAnnotationsForSubject(iriString) {
+    return this.getAxiomsOfType(AxiomType.ANNOTATION_ASSERTION)
+      .filter(a => a.subject && a.subject.toString() === iriString);
+  }
+
+  /** rdfs:label (or other annotation property) literal values for an entity. */
+  getAnnotationValues(entity, propertyIRI) {
+    return this.getAnnotationsForSubject(entity.getIRI().toString())
+      .filter(a => a.property.getIRI().toString() === propertyIRI)
+      .map(a => a.value);
+  }
+}
+
+module.exports = { OWLOntology, OWLOntologyID };