org.semanticweb.owlapi.model.OWLDisjointClassesAxiom Java Examples

@Override
public void visit(OWLDisjointClassesAxiom axiom) {
	// tested for memory release[x]
	Collection<OWLDisjointClassesAxiom> odca= axiom.asPairwiseAxioms();
	for (OWLDisjointClassesAxiom pairwiseAxiom : odca) {
		IRI[] domainRange = new IRI[2];
		int index = 0;
		
		for (OWLClassExpression aClassEX : pairwiseAxiom.classExpressions().collect(Collectors.toSet())){
			OWLClass cls=aClassEX.asOWLClass();
			domainRange[index++] = cls.getIRI();
		}
		if (!vowlData.getSearcher().containsDisjoint(domainRange[0], domainRange[1])) {
			vowlData.getGenerator().generateDisjointProperty(domainRange[0], domainRange[1]);
		}
		domainRange=null;
	}
}
 

@Override
public T visit(OWLDisjointClassesAxiom axiom) {
	throw new IllegalArgumentException(
			OWLDisjointClassesAxiom.class.getSimpleName()
					+ " cannot be converted to "
					+ getTargetClass().getSimpleName());
}
 

/**
 * For every pair X DisjointWith Y, generate an axiom
 * A and Y = Nothing
 * 
 * (may become deprecated after Elk supports disjoints)
 * 
 * @param ont
 * @param manager
 * @param dataFactory
 */
public static void translateDisjointsToEquivalents(OWLOntology ont, OWLOntologyManager manager, OWLDataFactory dataFactory) {
	for (OWLDisjointClassesAxiom dca : ont.getAxioms(AxiomType.DISJOINT_CLASSES, Imports.INCLUDED)) {
		for (OWLClassExpression ce1 : dca.getClassExpressions()) {
			for (OWLClassExpression ce2 : dca.getClassExpressions()) {
				if (ce1.compareTo(ce2) <= 0)
					continue;
				OWLEquivalentClassesAxiom eca = dataFactory.getOWLEquivalentClassesAxiom(dataFactory.getOWLNothing(),
						dataFactory.getOWLObjectIntersectionOf(ce1, ce2));
				manager.addAxiom(ont, eca);
				// TODO - remove if requested
			}
		}
	}
}
 

@Override
public Void visit(OWLDisjointClassesAxiom axiom) {
  List<Long> nodes =
      transform(axiom.getClassExpressionsAsList(), new Function<OWLClassExpression, Long>() {

        @Override
        public Long apply(OWLClassExpression individual) {
          return getOrCreateNode(getIri(individual));
        }
      });

  getOrCreateRelationshipPairwise(nodes, OwlRelationships.OWL_DISJOINT_WITH);
  return null;
}
 

@Test
public void doesNotReason_whenOntologyIsInconsistent() throws Exception{
  OWLClass c0 = dataFactory.getOWLClass(IRI.generateDocumentIRI());
  OWLClass c1 = dataFactory.getOWLClass(IRI.generateDocumentIRI());
  OWLDisjointClassesAxiom disjoint = dataFactory.getOWLDisjointClassesAxiom(c0, c1);
  OWLIndividual i1 = dataFactory.getOWLNamedIndividual(IRI.generateDocumentIRI());
  OWLClassAssertionAxiom a1 = dataFactory.getOWLClassAssertionAxiom(c0, i1);
  OWLClassAssertionAxiom a2 = dataFactory.getOWLClassAssertionAxiom(c1, i1);
  manager.addAxioms(ont, newHashSet(disjoint, a1, a2));
  util.flush();
  assertThat(util.shouldReason(), is(false));
}
 

@Override
public OWLDisjointClassesAxiom visit(ElkDisjointClassesAxiom axiom) {
	return owlFactory_.getOWLDisjointClassesAxiom(
			toClassExpressionSet(axiom.getClassExpressions()));
}
 

@Override
public ElkClassAxiom visit(OWLDisjointClassesAxiom owlDisjointClasses) {
	return CONVERTER.convert(owlDisjointClasses);
}
 

@SuppressWarnings("static-method")
public ElkDisjointClassesAxiom convert(
		OWLDisjointClassesAxiom owlDisjointClassesAxiom) {
	return new ElkDisjointClassesAxiomWrap<OWLDisjointClassesAxiom>(
			owlDisjointClassesAxiom);
}
 

@Override
public ElkAxiom visit(OWLDisjointClassesAxiom owlDisjointClasses) {
	return CONVERTER.convert(owlDisjointClasses);
}
 

@Override
public void visit(OWLDisjointClassesAxiom axiom) {
	defaultVisit(axiom);
}
 

@Override
public OWLAxiom visit(OWLDisjointClassesAxiom axiom) {
	return factory.getOWLDisjointClassesAxiom(axiom.getClassExpressions(), annotations);
}
 

@Override
public void visit(OWLDisjointClassesAxiom axiom) {
}