How to use

getOWLDifferentIndividualsAxiom

method

in

org.semanticweb.owlapi.model.OWLDataFactory

  @Override
  public OWLDifferentIndividualsAxiom buildObject() {
    return df.getOWLDifferentIndividualsAxiom(items, annotations);
  }
}

static OWLAxiom create(OWLDataFactory d, OWLIndividual s, Set<OWLIndividual> o,
  Collection<OWLAnnotation> anns) {
  Set<OWLIndividual> individuals = new HashSet<>();
  individuals.add(s);
  individuals.addAll(o);
  return d.getOWLDifferentIndividualsAxiom(individuals, anns);
}

static OWLAxiom create(OWLDataFactory d, OWLIndividual s, Set<OWLIndividual> o,
  Collection<OWLAnnotation> anns) {
  Set<OWLIndividual> individuals = new HashSet<>();
  individuals.add(s);
  individuals.addAll(o);
  return d.getOWLDifferentIndividualsAxiom(individuals, anns);
}

static OWLAxiom create(OWLDataFactory d, OWLIndividual s, Set<OWLIndividual> o,
  Collection<OWLAnnotation> anns) {
  Set<OWLIndividual> individuals = new HashSet<>();
  individuals.add(s);
  individuals.addAll(o);
  return d.getOWLDifferentIndividualsAxiom(individuals, anns);
}

  public List<OWLOntologyChange> getChanges() {
    Set<OWLIndividual> individuals = ontologies.stream()
                          .flatMap(o -> o.getIndividualsInSignature().stream())
                          .collect(toSet());
    List<OWLOntologyChange> changes = new ArrayList<>();
    if (!individuals.isEmpty()) {
      changes.add(new AddAxiom(ont, dataFactory.getOWLDifferentIndividualsAxiom(individuals)));
    }
    return changes;
  }
}

  public List<OWLOntologyChange> getChanges() {
    Set<OWLIndividual> individuals = new HashSet<OWLIndividual>();
    for(OWLOntology ont : ontologies) {
      individuals.addAll(ont.getIndividualsInSignature());
    }
    List<OWLOntologyChange> changes = new ArrayList<OWLOntologyChange>();
    if(!individuals.isEmpty()) {
      changes.add(new AddAxiom(ont, dataFactory.getOWLDifferentIndividualsAxiom(individuals)));
    }
    return changes;
  }
}

@Override
public Set<? extends OWLAxiom> visit(OWLDifferentIndividualsAxiom axiom) {
  // Pairwise, or the power set?  It should be pairwise - an optimisation.
  // This means if we have something like  Diff(a, b, c, d) and we only
  // care that Diff(a, b) and Diff(a, c) then we can strike out d
  // from the original checker. In other words, we only need the weakest sets
  Set<OWLAxiom> result = new HashSet<>();
  axiom.walkAllPairwise((a, b) -> result.add(dataFactory.getOWLDifferentIndividualsAxiom(a, b)));
  return log(result);
}

final public void Distinct() throws ParseException, KRSS2OWLParserException {
  OWLIndividual indA, indB;
  Set<OWLIndividual> inds = new HashSet<OWLIndividual>();
  jj_consume_token(OPENPAR);
  jj_consume_token(DISTINCT);
  indA = IndividualName();
  indB = IndividualName();
  jj_consume_token(CLOSEPAR);
  inds.add(indA);
  inds.add(indB);
  addAxiom(dataFactory.getOWLDifferentIndividualsAxiom(inds));
}

  public void handleTriple(IRI subject, IRI predicate, IRI object) throws UnloadableImportException {
    Set<OWLIndividual> inds = new HashSet<OWLIndividual>();
    inds.add(translateIndividual(subject));
    inds.add(translateIndividual(object));
    addAxiom(getDataFactory().getOWLDifferentIndividualsAxiom(inds, getPendingAnnotations()));
    consumeTriple(subject, predicate, object);
  }
}

  @Override
  public void handleTriple(IRI s, IRI p, IRI o) {
    add(df.getOWLDifferentIndividualsAxiom(Sets.newHashSet(ind(s), ind(o)), anns()));
    consume(s, p, o);
  }
}

  @Override
  public void handleTriple(IRI s, IRI p, IRI o) {
    add(df.getOWLDifferentIndividualsAxiom(Sets.newHashSet(ind(s), ind(o)), anns()));
    consume(s, p, o);
  }
}

 final public OWLIndividualAxiom DifferentIndividuals() throws ParseException {Set<OWLIndividual> individuals;
  Set<OWLAnnotation> axiomAnnos;
  jj_consume_token(DIFFERENTINDIVIDUALS);
  jj_consume_token(OPENPAR);
  axiomAnnos = AxiomAnnotationSet();
  individuals = IndividualSet();
  jj_consume_token(CLOSEPAR);
return df.getOWLDifferentIndividualsAxiom(individuals, axiomAnnos);
}

 final public OWLAxiom Distinct() throws ParseException {OWLIndividual indA, indB;
  jj_consume_token(OPENPAR);
  jj_consume_token(DISTINCT);
  indA = IndividualName();
  indB = IndividualName();
  jj_consume_token(CLOSEPAR);
return df.getOWLDifferentIndividualsAxiom(indA, indB);
}

 final public OWLIndividualAxiom DifferentIndividuals() throws ParseException {Set<OWLIndividual> individuals;
  Set<OWLAnnotation> axiomAnnos;
  jj_consume_token(DIFFERENTINDIVIDUALS);
  jj_consume_token(OPENPAR);
  axiomAnnos = AxiomAnnotationSet();
  individuals = IndividualSet();
  jj_consume_token(CLOSEPAR);
return df.getOWLDifferentIndividualsAxiom(individuals, axiomAnnos);
}

@Override
public Object visit(OWLDifferentIndividualsAxiom axiom) {
  return visitAxiom(axiom,
    () -> df.getOWLDifferentIndividualsAxiom(t(axiom.individuals()), t(axiom
      .annotations())));
}

 final public void Distinct() throws ParseException, KRSS2OWLParserException {OWLIndividual indA, indB;
  jj_consume_token(OPENPAR);
  jj_consume_token(DISTINCT);
  indA = IndividualName();
  indB = IndividualName();
  jj_consume_token(CLOSEPAR);
addAxiom( df.getOWLDifferentIndividualsAxiom(indA, indB));
}

 final public void Distinct() throws ParseException, KRSS2OWLParserException {OWLIndividual indA, indB;
  jj_consume_token(OPENPAR);
  jj_consume_token(DISTINCT);
  indA = IndividualName();
  indB = IndividualName();
  jj_consume_token(CLOSEPAR);
addAxiom( df.getOWLDifferentIndividualsAxiom(indA, indB));
}

 final public void Distinct() throws ParseException, KRSS2OWLParserException {OWLIndividual indA, indB;
  jj_consume_token(OPENPAR);
  jj_consume_token(DISTINCT);
  indA = IndividualName();
  indB = IndividualName();
  jj_consume_token(CLOSEPAR);
addAxiom( df.getOWLDifferentIndividualsAxiom(indA, indB));
}

private void initialiseIndividualFrameSections() {
  //@formatter:off
  initialiseSection(new AnnAxiom<OWLIndividual, OWLAnnotation>(x -> parseAnnotation(), ANNOTATIONS, (s, o, anns) -> create(df, s, o, anns)), individualFrameSections);
  initialiseSection(new AnnAxiom<OWLIndividual, OWLClassExpression>(x -> parseUnion(), TYPES, (s, o, anns) -> df.getOWLClassAssertionAxiom(o, s, anns)), individualFrameSections);
  initialiseSection(new AnnAxiom<>(this::parseFact, FACTS, (s, o, anns) -> o.getAnnotatedAxiom(anns)), individualFrameSections);
  initialiseSection(new AnnAxiom<OWLIndividual, OWLIndividual>(x -> parseIndividual(), SAME_AS, (s, o, anns) -> df.getOWLSameIndividualAxiom(s, o, anns)), individualFrameSections);
  initialiseSection(new AnnAxiom<OWLIndividual, OWLIndividual>(x -> parseIndividual(), DIFFERENT_FROM, (s, o, anns) -> df.getOWLDifferentIndividualsAxiom(s, o, anns)), individualFrameSections);
  // Extensions
  initialiseSection(new AnnAxiom<OWLIndividual, Set<OWLIndividual>>(x -> parseIndividualList(), DIFFERENT_INDIVIDUALS, (s, o, anns) -> create(df, s, o, anns)), individualFrameSections);
  //@formatter:on
}

private void initialiseIndividualFrameSections() {
  //@formatter:off
  initialiseSection(new AnnAxiom<OWLIndividual, OWLAnnotation>(x -> parseAnnotation(), ANNOTATIONS, (s, o, anns) -> create(df, s, o, anns)), individualFrameSections);
  initialiseSection(new AnnAxiom<OWLIndividual, OWLClassExpression>(x -> parseUnion(), TYPES, (s, o, anns) -> df.getOWLClassAssertionAxiom(o, s, anns)), individualFrameSections);
  initialiseSection(new AnnAxiom<>(this::parseFact, FACTS, (s, o, anns) -> o.getAnnotatedAxiom(anns)), individualFrameSections);
  initialiseSection(new AnnAxiom<OWLIndividual, OWLIndividual>(x -> parseIndividual(), SAME_AS, (s, o, anns) -> df.getOWLSameIndividualAxiom(s, o, anns)), individualFrameSections);
  initialiseSection(new AnnAxiom<OWLIndividual, OWLIndividual>(x -> parseIndividual(), DIFFERENT_FROM, (s, o, anns) -> df.getOWLDifferentIndividualsAxiom(s, o, anns)), individualFrameSections);
  // Extensions
  initialiseSection(new AnnAxiom<OWLIndividual, Set<OWLIndividual>>(x -> parseIndividualList(), DIFFERENT_INDIVIDUALS, (s, o, anns) -> create(df, s, o, anns)), individualFrameSections);
  //@formatter:on
}