How to use

classesDAG

method

in

it.unibz.inf.ontop.spec.ontology.ClassifiedTBox

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

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

for (Equivalences<ClassExpression> set : reasoner.classesDAG()) {
  Set<Equivalences<ClassExpression>> subClasses = reasoner.classesDAG().getSub(set);
  boolean couldBeGenerating = set.size() > 1 || subClasses.size() > 1; 
  for (ClassExpression concept : set) {

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()) {

/**
 * 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 void process(Connection conn, ClassAssertion ax, PreparedStatement uriidStm, Map<SemanticIndexViewID, PreparedStatement> stmMap) throws SQLException {
  
  // replace concept by the canonical representative (which must be a concept name)
  OClass concept0 = ax.getConcept();
  OClass concept = (OClass)reasonerDag.classesDAG().getCanonicalForm(concept0);
  int conceptIndex = cacheSI.getEntry(concept).getIndex();	
  ObjectConstant c1 = ax.getIndividual();
  SemanticIndexView view =  views.getView(c1.getType());

  PreparedStatement stm = stmMap.get(view.getId());
  if (stm == null) {
    stm = conn.prepareStatement(view.getINSERT());
    stmMap.put(view.getId(), stm);
  }
  int uri_id = getObjectConstantUriId(c1, uriidStm); 
  
  // Construct the database INSERT statements
  stm.setInt(1, uri_id);
  stm.setInt(2, conceptIndex);
  stm.addBatch();

  // Register non emptiness
  view.addIndex(conceptIndex);
}

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;
}

for (Equivalences<ClassExpression> classNode : reasoner.classesDAG()) {
  for (Equivalences<ClassExpression> subclassNode : reasoner.classesDAG().getSub(classNode)) {
    for (ClassExpression subclass : subclassNode) {
      DataAtom<AtomPredicate> body = translate(subclass, variableYname);

for (Equivalences<ClassExpression> classSet : reasoner.classesDAG()) {
  TMappingIndexEntry currentNodeMappings = getMappings(mappingIndex, currentPredicate);
  for (Equivalences<ClassExpression> descendants : reasoner.classesDAG().getSub(classSet)) {
    for (ClassExpression childDescription : descendants) {

OClass equivalent = (OClass)reasoner.classesDAG().getCanonicalForm(c);
if (equivalent != null && !equivalent.equals(c)) {
  return atomFactory.getMutableTripleBodyAtom(bodyAtom.getTerm(0), equivalent.getIRI());

for (Equivalences<ClassExpression> classSet : reasoner.classesDAG()) {
  TMappingIndexEntry currentNodeMappings = getMappings(mappingIndex, currentPredicate);
  for (Equivalences<ClassExpression> descendants : reasoner.classesDAG().getSub(classSet)) {
    for (ClassExpression childDescription : descendants) {

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);

for(Equivalences<ClassExpression> node : reasoner.classesDAG()) {
  ClassExpression rep = node.getRepresentative();
    (EquivalencesDAGImpl<ClassExpression>)reasoner.classesDAG(), classes);

for(Equivalences<ClassExpression> node : reasoner.classesDAG()) {
  ClassExpression rep = node.getRepresentative();
    (EquivalencesDAGImpl<ClassExpression>)reasoner.classesDAG(), classes);

for (Equivalences<ClassExpression> set : reasonerDag.classesDAG()) {