How to use

getClassExpressionType

method

in

org.semanticweb.owlapi.model.OWLClassExpression

PrefixManager pm= new DefaultPrefixManager("http://www.co-ode.org/ontologies/pizza/pizza.owl#");
 OWLClass american=factory.getOWLClass("American", pm);
 Set<OWLClassAxiom> tempAx=localOntology.getAxioms(american);
 for(OWLClassAxiom ax: tempAx){
   for(OWLClassExpression nce:ax.getNestedClassExpressions())
     if(nce.getClassExpressionType()!=ClassExpressionType.OWL_CLASS)
       System.out.println(ax);
 }

  public boolean shouldBracket(OWLObject parentObject, OWLObject childObject) {
    return childObject instanceof OWLClassExpression && ((OWLClassExpression) childObject).getClassExpressionType().equals(classExpressionType);
  }
}

  public boolean shouldBracket(OWLObject parentObject, OWLObject childObject) {
    return childObject instanceof OWLClassExpression && ((OWLClassExpression) childObject).getClassExpressionType().equals(classExpressionType);
  }
}

  public boolean shouldBracket(OWLObject parentObject, OWLObject childObject) {
    return childObject instanceof OWLClassExpression && ((OWLClassExpression) childObject).getClassExpressionType().equals(classExpressionType);
  }
}

protected void retainOnlyExistentialRestrictions(Set<OWLClassExpression>  cs) {
  //Set<OWLClassExpression> add = new HashSet<OWLClassExpression>();
  for (Iterator<OWLClassExpression> it = cs.iterator(); it.hasNext();) {
    OWLClassExpression c = it.next();
    if (!c.getClassExpressionType().equals(ClassExpressionType.OBJECT_SOME_VALUES_FROM)
    && !c.getClassExpressionType().equals(ClassExpressionType.DATA_SOME_VALUES_FROM)) {
      it.remove();
      /*c = aterm2complexAtermEq.get(c);
      if (c!=null && ATermUtils.isSomeValues(c)) {
        add.add(c);
      }*/
    }
    
  }
  //cs.addAll(add);
}
protected Set<OWLClassExpression> getCommunSubsumees(

  public String toString() {
    StringBuilder sb = new StringBuilder();
    sb.append(classExpression.getClassExpressionType().getName());
    sb.append(" class expressions are not allowed in profile: ");
    sb.append(classExpression);
    sb.append("  [");
    sb.append(getAxiom());
    sb.append(" in  ");
    sb.append(getOntologyID());
    sb.append("]");
    return sb.toString();
  }
}

private void convertOWLClassExpressionsToArcs(OWLClass owlClass, Set<OWLClassExpression> expressions, Set<GraphArc> arcs, Icon icon, boolean mustBeVisible) {
  for(OWLClassExpression expression : expressions) {
    if(expression.getClassExpressionType().equals(ClassExpressionType.OBJECT_SOME_VALUES_FROM) 
        || expression.getClassExpressionType().equals(ClassExpressionType.OBJECT_ALL_VALUES_FROM)) {
      convertOWLClassExpressionToArcs(owlClass, expression, arcs, icon, mustBeVisible);
    }
    else if(expression.getClassExpressionType().equals(ClassExpressionType.OBJECT_INTERSECTION_OF)) {
      for(OWLClassExpression e : expression.asConjunctSet()) {
        convertOWLClassExpressionToArcs(owlClass, e, arcs, icon, mustBeVisible);
      }
    }
  }
}
 

  @Override
  public String toString() {
    return toString("Class expressions not allowed in profile: %s",
      getExpression().getClassExpressionType()
        .getName());
  }
}

  @Override
  public String toString() {
    return toString("Class expressions not allowed in profile: %s",
      getExpression().getClassExpressionType()
        .getName());
  }
}

  @Override
  public String toString() {
    return toString("Class expressions not allowed in profile: %s",
      getExpression().getClassExpressionType()
        .getName());
  }
}

  private boolean containsObjectAllRestriction(OWLClassExpression d){
    for(OWLClassExpression child : d.getNestedClassExpressions()){
      if(child.getClassExpressionType() == ClassExpressionType.OBJECT_ALL_VALUES_FROM){
        return true;
      }
    }
    return false;
  }
}

@Override
protected void writeDisjointUnionAxiom(Set<OWLClassExpression> set)
{
  if (set.size() > 1)
  {
    String s = "(disjoint-union ";
    for (OWLClassExpression c : set)
    {
      ClassExpressionType type = c.getClassExpressionType();
      if (type != ClassExpressionType.OWL_CLASS)
        exit("Concept type " + type + " not supported in disjoint union axiom");
      else
        s += getShortName(c.asOWLClass()) + " ";
    }
    s += ")";
    print(s);
  }
}

public static boolean isNegatedOWLQLRHSConcept(OWLClassExpression cl) {
  ClassExpressionType type = cl.getNNF().getClassExpressionType();
  return  type.equals(ClassExpressionType.OBJECT_COMPLEMENT_OF)
    || type.equals(ClassExpressionType.OBJECT_ALL_VALUES_FROM)
    || type.equals(ClassExpressionType.DATA_ALL_VALUES_FROM);
    
}

public Set<OWLClass> getUnsatisfiableNamedClasses() {
  if (unsatisfiableClasses == null) {
    unsatisfiableClasses = new HashSet<OWLClass>();
    // unsatisfiabe named classes C are in the negative closure in the form
    // subclass( C, not(C)) 
    for (OWLSubClassOfAxiom ax: getNegativeInclInNegClosure()) {
      OWLClassExpression sub = ax.getSubClass();
      OWLClassExpression sup = ax.getSuperClass();
      if (!sub.isAnonymous()
      && sup.getClassExpressionType().equals(ClassExpressionType.OBJECT_COMPLEMENT_OF)
      && ((OWLObjectComplementOf) sup).getOperand().equals(sub)) {
        unsatisfiableClasses.add(sub.asOWLClass());
      }
    }
  }
  return Collections.unmodifiableSet(unsatisfiableClasses);
  //return new HashSet<OWLClass>();
}
public Set<OWLProperty> getUnsatisfiableProperties() {

protected boolean isValidOWLQLLeftConcept(OWLClassExpression owlclass) {
  // check that subclass is either atomic or someValuesFrom(R, Top)
  if (!owlclass.isAnonymous()) {
    return true;
  }
  if (!owlclass.getClassExpressionType().equals(ClassExpressionType.DATA_SOME_VALUES_FROM)
  && !owlclass.getClassExpressionType().equals(ClassExpressionType.OBJECT_SOME_VALUES_FROM)) {
    return false;
  }
  OWLQuantifiedRestriction quant = (OWLQuantifiedRestriction) owlclass;
  OWLPropertyRange cl= quant.getFiller();
  if (cl instanceof OWLClassExpression) {
    OWLClassExpression clexp = (OWLClassExpression) cl;
    return clexp.isOWLThing();
  } else if (cl instanceof OWLDataRange) {
    OWLDataRange dr = (OWLDataRange) cl;
    //TODO handle qualified data existential restriction
    return dr.isTopDatatype();
  } else {
    assert false: "Unknown OWLPropertyRange: " +cl;
    return false;
  }
}

/**
 * returns the key associated with a class expression
 * @param lhsConcept
 * @return
 */
public static String getKey(OWLClassExpression lhsConcept) {
  if (!lhsConcept.isAnonymous()) {
    return lhsConcept.asOWLClass().getIRI().toString();
  } else if (lhsConcept.getClassExpressionType().equals(ClassExpressionType.OBJECT_SOME_VALUES_FROM)
      || lhsConcept.getClassExpressionType().equals(ClassExpressionType.DATA_SOME_VALUES_FROM)) {
    OWLQuantifiedRestriction rest =  (OWLQuantifiedRestriction) lhsConcept;
    OWLPropertyExpression pe = rest.getProperty();
    return getKey(pe);
  } else {
    assert false : "Invalid left hand side concept: "+lhsConcept;
    return null;
  }
}

/**
 * return named properties p such that c \subseteq \some inv(p) T
 * @param c
 * @return
 */
protected Set<URI> getNamedInverseSuperPropertiesOrSelf(OWLClassExpression c) {
  Set<OWLClassExpression> subs = taxo.getAllSubsumers(c);
  Set<URI> ret = new HashSet<URI>();
  for (OWLClassExpression ex: subs) {
    if (ex.getClassExpressionType().equals(ClassExpressionType.OBJECT_SOME_VALUES_FROM)) {
      OWLObjectSomeValuesFrom rest = (OWLObjectSomeValuesFrom) ex;
      OWLObjectPropertyExpression prop = rest.getProperty().getSimplified();
      if (prop.isAnonymous()) {
        OWLObjectProperty namedProp = prop.getNamedProperty();
        ret.add(namedProp.getIRI().toURI());
      }
      
    }
  }
  return ret;
  
}
/**

@Override
protected void writeEquivalentClassesAxiom(Set<OWLClassExpression> set)
{
  String name = null;
  OWLClassExpression leftClass = null;
  for (OWLClassExpression c : set)
    if (c.getClassExpressionType() == ClassExpressionType.OWL_CLASS)
    {
      name = getShortName(c.asOWLClass());
      leftClass = c;
      break;
    }
  if (name == null)
    exit("Equivalent classes axiom " + set + " require at least one atomic class");
  for (OWLClassExpression c : set)
    if (c != leftClass)
      print("(define-concept " + name + " " + getClassName(c) + " )");
}

  @Override
  protected void writeSubclassOfAxiom(OWLClassExpression subclass, OWLClassExpression superclass, double d)
  {
//        if (superclass.isOWLThing() != false)
    {
      ClassExpressionType type = subclass.getClassExpressionType();
      if ((type == ClassExpressionType.OWL_CLASS) && (d == 1))
        print("(define-primitive-concept " + getShortName(subclass.asOWLClass()) + " " + getClassName(superclass) + ")");
      else
        print("(implies " + getClassName(subclass) + " " + getClassName(superclass) + " " + d + ")");
    }
  }

public static RDFResourceTree materializePropertyDomains(RDFResourceTree tree, AbstractReasonerComponent reasoner) {
  RDFResourceTree newTree = new RDFResourceTree(tree.getData());
  Consumer<OWLClass> addTypeChild = (cls) -> newTree.addChild(new RDFResourceTree(OwlApiJenaUtils.asNode(cls)), RDF.type.asNode());
  tree.getEdges().forEach(edge -> {
    List<RDFResourceTree> children = tree.getChildren(edge);
    // add existing children
    children.forEach(child -> {
      RDFResourceTree newChild = materializePropertyDomains(child, reasoner);
      newTree.addChild(newChild, edge);
    });
    // add the rdf:type statements for the property domain(s)
    OWLClassExpression dom = reasoner.getDomain(OwlApiJenaUtils.asOWLEntity(edge, EntityType.OBJECT_PROPERTY));
    if(!dom.isAnonymous() && !dom.isOWLThing()) {
      addTypeChild.accept(dom.asOWLClass());
    } else {
      if(dom.getClassExpressionType() == ClassExpressionType.OBJECT_INTERSECTION_OF) {
        dom.getNestedClassExpressions().stream()
            .filter(ce -> !ce.isAnonymous())
            .map(OWLClassExpression::asOWLClass)
            .forEach(addTypeChild);
      }
    }
  });
  return newTree;
}