How to use

ClassifiedTBox

in

it.unibz.inf.ontop.spec.ontology

private Assertion translate(OWLAxiom axiom) {
  try {
    if (axiom instanceof OWLClassAssertionAxiom)
      return owlapiTranslator.translate((OWLClassAssertionAxiom)axiom, tbox.classes());
    else if (axiom instanceof OWLObjectPropertyAssertionAxiom)
      return owlapiTranslator.translate((OWLObjectPropertyAssertionAxiom)axiom, tbox.objectProperties());
    else if (axiom instanceof OWLDataPropertyAssertionAxiom)
      return owlapiTranslator.translate((OWLDataPropertyAssertionAxiom)axiom, tbox.dataProperties());
  }
  catch (TranslationException | InconsistentOntologyException e) {
    return null;
  } 
  return null;
}

/**
 * Assign indexes for the named DAG, use a depth first listener over the DAG 
 * @param reasoner used to know ancestors and descendants of the dag
 */

public SemanticIndexBuilder(ClassifiedTBox reasoner)  {
  classRanges = createSemanticIndex(reasoner.classesDAG());
  opRanges = createSemanticIndex(reasoner.objectPropertiesDAG());
  dpRanges = createSemanticIndex(reasoner.dataPropertiesDAG());
}
  

private ImmutableMap<IRI, Datatype> getDescendentNodesPartialMap(ClassifiedTBox reasoner, DataRangeExpression node,
                                    Equivalences<DataRangeExpression> nodeSet) {
  if (node instanceof Datatype) {
    return reasoner.dataRangesDAG().getSub(nodeSet).stream()
        .map(Equivalences::getRepresentative)
        .filter(d -> d != node)
        .map(this::getPredicateIRI)
        .filter(Optional::isPresent)
        .collect(ImmutableCollectors.toMap(
            Optional::get,
            d -> (Datatype) node
        ));
  }
  return ImmutableMap.of();
}

public Iterator<IRI> iEmptyRoles() {
  return new EmptyEntitiesIterator(onto.objectProperties().iterator(), onto.dataProperties().iterator(), conn);
}

private void setIndex(String iri, int type, int idx) {
  if (type == CLASS_TYPE) {
    OClass c = reasonerDag.classes().get(iri);
    if (reasonerDag.classesDAG().getVertex(c) == null)
      throw new RuntimeException("UNKNOWN CLASS: " + iri);
    if (reasonerDag.objectProperties().contains(iri)) {
      ObjectPropertyExpression ope = reasonerDag.objectProperties().get(iri);
      if (cacheSI.getEntry(ope) != null)  {
        DataPropertyExpression dpe = reasonerDag.dataProperties().get(iri);
        if (reasonerDag.dataPropertiesDAG().getVertex(dpe) != null) {
          if (cacheSI.getEntry(dpe) != null)
            throw new RuntimeException("DUPLICATE PROPERTY: " + iri);
      DataPropertyExpression dpe = reasonerDag.dataProperties().get(iri);
      if (reasonerDag.dataPropertiesDAG().getVertex(dpe) != null) {
        if (cacheSI.getEntry(dpe) != null)
          throw new RuntimeException("DUPLICATE PROPERTY: " + iri);

private void checkObjectOrAnnotationProperty(String predicateIRI, PPMappingAssertionProvenance provenance,
                       Ontology ontology)
    throws MappingOntologyMismatchException {
  /*
   * Cannot be a data property (should be either an object or an annotation property)
   */
  if (ontology.tbox().dataProperties().contains(predicateIRI))
    throw new MappingOntologyMismatchException(generatePropertyOrClassConflictMessage(predicateIRI, provenance,
        DATA_PROPERTY_STR, OBJECT_PROPERTY_STR));
  /*
   * Cannot be a class
   */
  if (ontology.tbox().classes().contains(predicateIRI))
    throw new MappingOntologyMismatchException(generatePropertyOrClassConflictMessage(predicateIRI, provenance,
        CLASS_STR, OBJECT_PROPERTY_STR));
}

if (ontology.tbox().objectProperties().contains(predicateIRI))
  throw new MappingOntologyMismatchException(generatePropertyOrClassConflictMessage(predicateIRI, provenance,
      OBJECT_PROPERTY_STR, DATA_PROPERTY_STR));
if (ontology.tbox().classes().contains(predicateIRI))
  throw new MappingOntologyMismatchException(generatePropertyOrClassConflictMessage(predicateIRI, provenance,
      CLASS_STR, DATA_PROPERTY_STR));

for (ClassExpression b : concepts) 
  if (b instanceof ObjectSomeValuesFrom)
    extension.addAll(reasoner.classesDAG().getSubRepresentatives(b));
concepts.addAll(extension);
    for (ClassExpression b : concepts) 
      if (b instanceof OClass) {
        Set<ClassExpression> bsubconcepts = reasoner.classesDAG().getSubRepresentatives(b);
        Iterator<ClassExpression> i = concepts.iterator();
        while (i.hasNext()) {
        ObjectSomeValuesFrom some = (ObjectSomeValuesFrom)b;
        ObjectPropertyExpression prop = some.getProperty();
        Set<ObjectPropertyExpression> bsubproperties = reasoner.objectPropertiesDAG().getSubRepresentatives(prop);
        Iterator<ClassExpression> i = concepts.iterator();
        while (i.hasNext()) {

public Intersection<ClassExpression> getSubConcepts(Collection<Function> atoms) {
  Intersection<ClassExpression> subc = new Intersection<>(reasoner.classesDAG());
  for (Function a : atoms) {
    Optional<IRI> optionalClassIRI = extractClassIRI(a);
    if (!optionalClassIRI.isPresent()) {
      subc.setToBottom();   // binary predicates R(x,x) cannot be matched to the anonymous part
      break;
    }
    IRI classIRI = optionalClassIRI.get();
     if (reasoner.classes().contains(classIRI))
       subc.intersectWith(reasoner.classes().get(classIRI));
     else
       subc.setToBottom();
     if (subc.isBottom())
       break;
  }
  return subc;
}

Intersection<ObjectPropertyExpression> properties = propertiesCache.get(idx);            
if (properties == null) {
  properties = new Intersection<>(reasoner.objectPropertiesDAG());
  for (Function a : edge.getBAtoms()) {
    if (a.isOperation()) {
      Optional<IRI> optionalPropertyIRIString = extractPropertyIRI(a);
      if (optionalPropertyIRIString
          .filter(i -> reasoner.objectProperties().contains(i))
          .isPresent()) {
        ObjectPropertyExpression prop = reasoner.objectProperties().get(optionalPropertyIRIString.get());
        if (!root.equals(a.getTerm(0)))
            prop = prop.getInverse();

public Set<ClassExpression> getSubConcepts() {
  if (subconcepts == null) {
    subconcepts = new HashSet<>();
    for (ClassExpression con : concepts)
      subconcepts.addAll(reasoner.classesDAG().getSubRepresentatives(con));
  }
  return subconcepts;
}

public Intersection<ObjectPropertyExpression> getTopProperty() {
  return new Intersection<>(reasoner.objectPropertiesDAG());
}

public Iterator<IRI> iEmptyConcepts() {
  return new EmptyEntitiesIterator(onto.classes().iterator(), conn);
}

DataPropertyExpression dpe = reasonerDag.dataPropertiesDAG().getCanonicalForm(dpe0);
int idx = cacheSI.getEntry(dpe).getIndex();

if (classIRI.isPresent() && reasoner.classes().contains(classIRI.get())) {
  OClass c = reasoner.classes().get(classIRI.get());
  OClass equivalent = (OClass)reasoner.classesDAG().getCanonicalForm(c);
  if (equivalent != null && !equivalent.equals(c)) {
    return atomFactory.getMutableTripleBodyAtom(bodyAtom.getTerm(0), equivalent.getIRI());
else if (propertyIRI.isPresent() && reasoner.objectProperties().contains(propertyIRI.get())) {
  ObjectPropertyExpression ope = reasoner.objectProperties().get(propertyIRI.get());
  ObjectPropertyExpression equivalent = reasoner.objectPropertiesDAG().getCanonicalForm(ope);
  if (equivalent != null && !equivalent.equals(ope)) {
    if (!equivalent.isInverse())
else if (propertyIRI.isPresent()  && reasoner.dataProperties().contains(propertyIRI.get())) {
  DataPropertyExpression dpe = reasoner.dataProperties().get(propertyIRI.get());
  DataPropertyExpression equivalent = reasoner.dataPropertiesDAG().getCanonicalForm(dpe);
  if (equivalent != null && !equivalent.equals(dpe)) {
    return atomFactory.getMutableTripleBodyAtom(bodyAtom.getTerm(0), equivalent.getIRI(), bodyAtom.getTerm(2));

private void checkClass(String predicateIRI, PPMappingAssertionProvenance provenance,
            Ontology ontology) throws MappingOntologyMismatchException {
  /*
   * Cannot be an object property
   */
  if (ontology.tbox().objectProperties().contains(predicateIRI))
    throw new MappingOntologyMismatchException(generatePropertyOrClassConflictMessage(predicateIRI, provenance,
        OBJECT_PROPERTY_STR, CLASS_STR));
  /*
   * Cannot be a data property
   */
  else if (ontology.tbox().dataProperties().contains(predicateIRI))
    throw new MappingOntologyMismatchException(generatePropertyOrClassConflictMessage(predicateIRI, provenance,
        DATA_PROPERTY_STR, CLASS_STR));
  /*
   * Cannot be an annotation property
   */
  if (ontology.annotationProperties().contains(predicateIRI))
    throw new MappingOntologyMismatchException(generatePropertyOrClassConflictMessage(predicateIRI, provenance,
        ANNOTATION_PROPERTY_STR, DATA_PROPERTY_STR));
}

private void checkObjectOrAnnotationProperty(IRI predicateIRI, PPMappingAssertionProvenance provenance,
                       Ontology ontology)
    throws MappingOntologyMismatchException {
  /*
   * Cannot be a data property (should be either an object or an annotation property)
   */
  if (ontology.tbox().dataProperties().contains(predicateIRI))
    throw new MappingOntologyMismatchException(generatePropertyOrClassConflictMessage(predicateIRI, provenance,
        DATA_PROPERTY_STR, OBJECT_PROPERTY_STR));
  /*
   * Cannot be a class
   */
  if (ontology.tbox().classes().contains(predicateIRI))
    throw new MappingOntologyMismatchException(generatePropertyOrClassConflictMessage(predicateIRI, provenance,
        CLASS_STR, OBJECT_PROPERTY_STR));
}

if (ontology.tbox().objectProperties().contains(predicateIRI))
  throw new MappingOntologyMismatchException(generatePropertyOrClassConflictMessage(predicateIRI, provenance,
      OBJECT_PROPERTY_STR, DATA_PROPERTY_STR));
if (ontology.tbox().classes().contains(predicateIRI))
  throw new MappingOntologyMismatchException(generatePropertyOrClassConflictMessage(predicateIRI, provenance,
      CLASS_STR, DATA_PROPERTY_STR));

public Intersection<ClassExpression> getTopClass() {
  return new Intersection<>(reasoner.classesDAG());
}

  throw new RuntimeException("INVERSE PROPERTIES ARE NOT SUPPORTED IN ABOX:" + ax);
ObjectPropertyExpression ope = reasonerDag.objectPropertiesDAG().getCanonicalForm(ope0);