Java 类org.semanticweb.owlapi.model.OWLSameIndividualAxiom 实例源码

public Node<OWLNamedIndividual> getSameIndividuals(OWLNamedIndividual ind) throws InconsistentOntologyException, FreshEntitiesException, ReasonerInterruptedException, TimeOutException {
    ensurePrepared();
    Set<OWLNamedIndividual> inds = new HashSet<OWLNamedIndividual>();
    Set<OWLSameIndividualAxiom> processed = new HashSet<OWLSameIndividualAxiom>();
    List<OWLNamedIndividual> stack = new ArrayList<OWLNamedIndividual>();
    stack.add(ind);
    while (!stack.isEmpty()) {
        OWLNamedIndividual currentInd = stack.remove(0);
        for (OWLOntology ontology : getRootOntology().getImportsClosure()) {
            for (OWLSameIndividualAxiom axiom : ontology.getSameIndividualAxioms(currentInd)) {
                if (!processed.contains(axiom)) {
                    processed.add(axiom);
                    for (OWLIndividual i : axiom.getIndividuals()) {
                        if (!i.isAnonymous()) {
                            OWLNamedIndividual namedInd = i.asOWLNamedIndividual();
                            if (!inds.contains(namedInd)) {
                                inds.add(namedInd);
                                stack.add(namedInd);
                            }
                        }
                    }
                }
            }
        }
    }

    return new OWLNamedIndividualNode(inds);
}

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

@Override
public Set<ComplexIntegerAxiom> visit(OWLSameIndividualAxiom axiom) {
    Objects.requireNonNull(axiom);
    Set<OWLIndividual> individualSet = axiom.getIndividuals();
    Set<Integer> individualIdSet = new HashSet<>();
    individualSet.forEach(individual -> individualIdSet.add(translateIndividual(individual)));
    ComplexIntegerAxiom ret = getAxiomFactory().createSameIndividualAxiom(individualIdSet,
            translateAnnotations(axiom.getAnnotations()));
    return Collections.singleton(ret);
}

@Override
public Void visit(OWLSameIndividualAxiom axiom) {
  List<Long> nodes = transform(axiom.getIndividualsAsList(), new Function<OWLIndividual, Long>() {
    @Override
    public Long apply(OWLIndividual individual) {
      return getOrCreateNode(getIri(individual));
    }
  });
  getOrCreateRelationshipPairwise(nodes, OwlRelationships.OWL_SAME_AS);
  return null;
}

@Override
public void visit(@Nonnull OWLSameIndividualAxiom axiom) {
    for (OWLIndividual ind : axiom.getIndividuals()) {
        ind.accept(this);
    }
    processAxiomAnnotations(axiom);
}

@Override
public OWLSameIndividualAxiom getAxiomWithoutAnnotations() {
    if (!isAnnotated()) {
        return this;
    }
    return new OWLSameIndividualAxiomImpl(getIndividuals(), NO_ANNOTATIONS);
}

@Override
public Set<OWLSameIndividualAxiom> asPairwiseAxioms() {
    List<OWLIndividual> inds = getIndividualsAsList();
    Set<OWLSameIndividualAxiom> result = new HashSet<>();
    for (int i = 0; i < inds.size() - 1; i++) {
        OWLIndividual indI = inds.get(i);
        OWLIndividual indJ = inds.get(i + 1);
        result.add(new OWLSameIndividualAxiomImpl(new HashSet<>(Arrays
                .asList(indI, indJ)), NO_ANNOTATIONS));
    }
    return result;
}

@Override
public Set<OWLSameIndividualAxiom> splitToAnnotatedPairs() {
    List<OWLIndividual> individuals = getIndividualsAsList();
    if (individuals.size() == 2) {
        return Collections.<OWLSameIndividualAxiom> singleton(this);
    }
    Set<OWLSameIndividualAxiom> result = new HashSet<>();
    for (int i = 0; i < individuals.size() - 1; i++) {
        OWLIndividual indI = individuals.get(i);
        OWLIndividual indJ = individuals.get(i + 1);
        result.add(new OWLSameIndividualAxiomImpl(new HashSet<>(Arrays
                .asList(indI, indJ)), getAnnotations()));
    }
    return result;
}

@Override
public boolean equals(Object obj) {
    if (this == obj) {
        return true;
    }
    if (!super.equals(obj)) {
        return false;
    }
    return obj instanceof OWLSameIndividualAxiom;
}

public void visit(OWLSameIndividualAxiom axiom) {
    notSupported(axiom);
}

public void visit(OWLSameIndividualAxiom object) {
}

public void visit(OWLSameIndividualAxiom axiom) {
    if (axiom.containsAnonymousIndividuals())
        throw new IllegalArgumentException("The axiom "+axiom+" contains anonymous individuals, which is not allowed in OWL 2. ");
    addFact(axiom);
}

public void visit(OWLSameIndividualAxiom object) {
    OWLIndividual[] individuals=new OWLIndividual[object.getIndividuals().size()];
    object.getIndividuals().toArray(individuals);
    for (int i=0;i<individuals.length-1;i++)
        m_positiveFacts.add(Atom.create(Equality.create(),getIndividual(individuals[i]),getIndividual(individuals[i+1])));
}

public void visit(OWLSameIndividualAxiom object) {
    OWLIndividual[] individuals=new OWLIndividual[object.getIndividuals().size()];
    object.getIndividuals().toArray(individuals);
    for (int i=0;i<individuals.length-1;i++)
        m_positiveFacts.add(Atom.create(Equality.create(),getIndividual(individuals[i]),getIndividual(individuals[i+1])));
}

public void visit(OWLSameIndividualAxiom axiom) {
}

@Override
public OWLSameIndividualAxiom visit(ElkSameIndividualAxiom axiom) {
    return owlFactory_.getOWLSameIndividualAxiom(
            toIndividualSet(axiom.getIndividuals()));
}

@SuppressWarnings("static-method")
public ElkSameIndividualAxiom convert(
        OWLSameIndividualAxiom owlSameIndividualAxiom) {
    return new ElkSameIndividualAxiomWrap<OWLSameIndividualAxiom>(
            owlSameIndividualAxiom);
}

@Override
public ElkAxiom visit(OWLSameIndividualAxiom axiom) {
    return CONVERTER.convert(axiom);
}

@Override
public ElkAssertionAxiom visit(OWLSameIndividualAxiom axiom) {
    return CONVERTER.convert(axiom);
}

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

public void visit(OWLSameIndividualAxiom object) {
}

public void visit(OWLSameIndividualAxiom axiom) {
    if (axiom.containsAnonymousIndividuals())
        throw new IllegalArgumentException("The axiom "+axiom+" contains anonymous individuals, which is not allowed in OWL 2. ");
    addFact(axiom);
}

public void visit(OWLSameIndividualAxiom object) {
    OWLIndividual[] individuals=new OWLIndividual[object.getIndividuals().size()];
    object.getIndividuals().toArray(individuals);
    for (int i=0;i<individuals.length-1;i++)
        m_positiveFacts.add(Atom.create(Equality.create(),getIndividual(individuals[i]),getIndividual(individuals[i+1])));
}

public void visit(OWLSameIndividualAxiom object) {
    OWLIndividual[] individuals=new OWLIndividual[object.getIndividuals().size()];
    object.getIndividuals().toArray(individuals);
    for (int i=0;i<individuals.length-1;i++)
        m_positiveFacts.add(Atom.create(Equality.create(),getIndividual(individuals[i]),getIndividual(individuals[i+1])));
}

public void visit(OWLSameIndividualAxiom axiom) {
}

@Override
public OWLAxiom visit(OWLSameIndividualAxiom axiom) {
    return factory.getOWLSameIndividualAxiom(axiom.getIndividuals(), annotations);
}

@Override
public void visit(OWLSameIndividualAxiom axiom) {
}

public void visit(OWLSameIndividualAxiom axiom) {
    if (axiom.containsAnonymousIndividuals())
        throw new IllegalArgumentException("The axiom "+axiom+" contains anonymous individuals, which is not allowed in OWL 2. ");
    addFact(axiom);
}

@Override
public Boolean visit(OWLSameIndividualAxiom axiom) {
    return true;
}

@Override
public Boolean visit(OWLSameIndividualAxiom axiom) {
    return false;
}

@Override
public Boolean visit(OWLSameIndividualAxiom axiom) {
    Objects.requireNonNull(axiom);
    return add(this.df.getOWLSameIndividualAxiom(axiom.getIndividuals(), reg(axiom.getAnnotations())));
}

@Override
public Boolean visit(OWLSameIndividualAxiom axiom) {
    Objects.requireNonNull(axiom);
    return add(this.df.getOWLSameIndividualAxiom(axiom.getIndividuals(), empty()));
}

@Override
public void visit(OWLSameIndividualAxiom axiom)
{
   ignoreOwlAxiom("SameIndividual", axiom);
}

@Override
public void visit(OWLSameIndividualAxiom axiom) {
    aBoxAxiomsNotSupportedWarning(axiom);
}

@Override
public O visit(OWLSameIndividualAxiom axiom) {
    return doDefault(axiom);
}

@Override
public void visit(OWLSameIndividualAxiom axiom) {
    type = AXIOM_TYPE_INDEX_BASE + axiom.getAxiomType().getIndex();
}

@Override
public OWLAxiom visit(OWLSameIndividualAxiom axiom) {
    return axiom;
}

@Override
public void visit(OWLSameIndividualAxiom axiom) {
    hashCode = primes[29];
    hashCode = hashCode * MULT + axiom.getIndividuals().hashCode();
    hashCode = hashCode * MULT + axiom.getAnnotations().hashCode();
}

@Override
public void visit(OWLSameIndividualAxiom axiom) {
    handleDefault(axiom);
}

@Override
public OWLSameIndividualAxiom getAnnotatedAxiom(
        Set<OWLAnnotation> annotations) {
    return new OWLSameIndividualAxiomImpl(getIndividuals(),
            mergeAnnos(annotations));
}