How to use

getClassExpressionsAsList

method

in

org.semanticweb.owlapi.model.OWLEquivalentClassesAxiom

@Override
public Void visit(OWLEquivalentClassesAxiom axiom) {
 logger.fine(axiom.toString());
 List<Long> nodes =
   transform(axiom.getClassExpressionsAsList(), new Function<OWLClassExpression, Long>() {
    @Override
    public Long apply(OWLClassExpression expr) {
     return getOrCreateNode(getIri(expr));
    }
   });
 getOrCreateRelationshipPairwise(nodes, OwlRelationships.OWL_EQUIVALENT_CLASS);
 return null;
}

for (int i=0; i<ax.getClassExpressionsAsList().size()-1; i++){
  for (int j=i+1; j<ax.getClassExpressionsAsList().size(); j++){
            ax.getClassExpressionsAsList().get(i),
            ax.getClassExpressionsAsList().get(j));
            ax.getClassExpressionsAsList().get(j),
            ax.getClassExpressionsAsList().get(i));

@Override
public void visit(OWLEquivalentClassesAxiom axiom) {
  List<OWLClassExpression> classExpressions = axiom.getClassExpressionsAsList();
  List<OWLClassExpression> renamedClassExpressions = new ArrayList<>();
  for (OWLClassExpression expr : classExpressions) {
    renamedClassExpressions.add(expressionRenamer.rename(expr));
  }
  renamedAxiom = df.getOWLEquivalentClassesAxiom(new TreeSet<>(renamedClassExpressions));
}

@Override
public void visit(OWLEquivalentClassesAxiom axiom) {
  if (axiom.getClassExpressions().size() == 2) {
    addPairwiseClassExpressions(axiom, axiom.getClassExpressions(), OWL_EQUIVALENT_CLASS.getIRI());
  }
  else {
    //see http://www.w3.org/TR/2009/REC-owl2-mapping-to-rdf-20091027/
    List<OWLClassExpression> list = axiom.getClassExpressionsAsList();
    int count = list.size();
    for (int i = 0; i + 1 < count; i++) {
      addTriple(list.get(i), OWL_EQUIVALENT_CLASS.getIRI(), list.get(i + 1));
    }
  }
}

public boolean eca(@NonNull List<@NonNull SWRLBuiltInArgument> arguments) throws SWRLBuiltInException
{
 checkNumberOfArgumentsEqualTo(2, arguments.size());
 Set<OWLEquivalentClassesAxiom> axioms = getBuiltInBridge().getOWLOntology()
  .getAxioms(AxiomType.EQUIVALENT_CLASSES, Imports.INCLUDED).stream().flatMap(a -> a.asPairwiseAxioms().stream())
  .collect(Collectors.toSet());
 if (axioms.isEmpty())
  return false;
 else {
  Map<@NonNull Integer, @NonNull OWLObject> inputArgumentValues = getInputArgumentValues(arguments,
   SWRLBuiltInArgumentType.CLASS_EXPRESSION, SWRLBuiltInArgumentType.CLASS_EXPRESSION);
  Map<@NonNull Integer, @NonNull SWRLMultiValueVariableBuiltInArgument> outputMultiValueArguments = createOutputMultiValueArguments(
   arguments);
  for (OWLEquivalentClassesAxiom axiom : axioms) {
   OWLClassExpression candidateValue1 = axiom.getClassExpressionsAsList().get(0);
   OWLClassExpression candidateValue2 = axiom.getClassExpressionsAsList().get(1);
   if (!noBoundArgumentsMismatch(inputArgumentValues, candidateValue1, candidateValue2)) {
    if (outputMultiValueArguments.isEmpty())
     return true; // We have a match and there are no unbound arguments - return immediately
    else { // We have a match so update any unbound arguments with the matched values
     if (outputMultiValueArguments.containsKey(0))
      outputMultiValueArguments.get(0).addArgument(createClassExpressionBuiltInArgument(candidateValue1));
     if (outputMultiValueArguments.containsKey(1))
      outputMultiValueArguments.get(1).addArgument(createClassExpressionBuiltInArgument(candidateValue2));
    }
   }
  }
  return processResultMultiValueArguments(arguments, outputMultiValueArguments);
 }
}