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

private boolean commitDeclarations() {
    // editor.status("Integrating Declaration axioms with Protege ");
    if (declarationAxioms != null && !declarationAxioms.isEmpty()) {
        // declarationAxioms
        List<OWLOntologyChange> declarations = new ArrayList<OWLOntologyChange>();
        for (OWLAxiom declarationAxiom : declarationAxioms) {

            declarations.add(new AddAxiom(activeOntology, declarationAxiom));

        }
        ChangeApplied changeResult = owlOntologyManager.applyChanges(declarations);
        if (changeResult == ChangeApplied.SUCCESSFULLY) {
            editor.status("Declaration axioms integrated with protege successfully.");
            return true;
        } else if (changeResult == ChangeApplied.UNSUCCESSFULLY) {
            editor.status("Declaration integration with Protege unsuccessfull.");
            return false;
        } else if (changeResult == ChangeApplied.NO_OPERATION) {
            editor.status(
                    "Declaration axioms are duplicate. Possible reason: trying to create new OWL Entity which IRI match with existing OWLEntity IRI.");
            return false;
        }
    } else {

        editor.status("");
        return false;
    }

    return false;
}

public List<OWLOntologyChange> applyChanges(List<? extends OWLOntologyChange> changes) {
    ChangeApplied applied = getOWLOntologyManager().applyChanges(changes);
    if (applied == ChangeApplied.SUCCESSFULLY) {
        List<OWLOntologyChange> relevantChanges = new ArrayList<>();
        for (OWLOntologyChange change : changes) {
            if (aboxOntology.equals(change.getOntology())) {
                aboxModified = true;
                relevantChanges.add(change);
            }
        }
        if (relevantChanges.isEmpty() == false) {
            for(ModelChangeListener listener : listeners) {
                listener.handleChange(relevantChanges);
            }
        }
    }
    return new ArrayList<OWLOntologyChange>(changes);
}

/**
 * Save a model to the database.
 * 
 * @param m
 * @param annotations
 * @param metadata
 *
 * @throws OWLOntologyStorageException
 * @throws OWLOntologyCreationException
 * @throws IOException
 * @throws RepositoryException 
 * @throws UnknownIdentifierException 
 */
public void saveModel(ModelContainer m,
        Set<OWLAnnotation> annotations, METADATA metadata)
                throws OWLOntologyStorageException, OWLOntologyCreationException,
                IOException, RepositoryException, UnknownIdentifierException {
    IRI modelId = m.getModelId();
    final OWLOntology ont = m.getAboxOntology();
    final OWLOntologyManager manager = ont.getOWLOntologyManager();
    List<OWLOntologyChange> changes = preSaveFileHandler(ont);
    synchronized(ont) {
        try {
            this.writeModelToDatabase(ont, modelId);
            // reset modified flag for abox after successful save
            m.setAboxModified(false);
        } finally {
            if (changes != null) {
                List<OWLOntologyChange> invertedChanges = ReverseChangeGenerator
                        .invertChanges(changes);
                if (invertedChanges != null && !invertedChanges.isEmpty()) {
                    manager.applyChanges(invertedChanges);
                }
            }
        }
    }
}

@Override
protected void addToHistory(ModelContainer model, List<OWLOntologyChange> appliedChanges, UndoMetadata metadata) {
    if (appliedChanges == null || appliedChanges.isEmpty()) {
        // do nothing
        return;
    }
    UndoRedo undoRedo;
    synchronized (allChanges) {
        IRI modelId = model.getModelId();
        undoRedo = allChanges.get(modelId);
        if (undoRedo == null) {
            undoRedo = new UndoRedo();
            allChanges.put(modelId, undoRedo);
        }
    }
    synchronized (undoRedo) {
        // append to undo
        undoRedo.addUndo(appliedChanges, metadata);
        // clear redo
        undoRedo.clearRedo();
    }
}

private void addAutoGeneratedClassNames(OWLOntologyManager manager,
                                        OWLOntology ontology,
                                        Map<String, OWLClassExpression> nameMap) {

    OWLDataFactory factory = manager.getOWLDataFactory();
    List<OWLOntologyChange> changes = new ArrayList<OWLOntologyChange>();

    for (Map.Entry<String, OWLClassExpression> entry : nameMap.entrySet()) {

        OWLClass subClass = factory.getOWLClass( IRI.create(entry.getKey()) );
        OWLAxiom declAxiom = factory.getOWLEquivalentClassesAxiom( subClass, entry.getValue() );

        changes.addAll( manager.addAxiom( ontology, declAxiom ) );
    }

    manager.applyChanges( changes );
}

private void addAutoGeneratedClassNames(OWLOntologyManager manager,
                                        OWLOntology ontology,
                                        Map<String, OWLClassExpression> nameMap) {

    OWLDataFactory factory = manager.getOWLDataFactory();
    List<OWLOntologyChange> changes = new ArrayList<OWLOntologyChange>();

    for (Map.Entry<String, OWLClassExpression> entry : nameMap.entrySet()) {

        OWLClass subClass = factory.getOWLClass( IRI.create(entry.getKey()) );
        OWLAxiom declAxiom = factory.getOWLEquivalentClassesAxiom( subClass, entry.getValue() );

        changes.addAll( manager.addAxiom( ontology, declAxiom ) );
    }

    manager.applyChanges( changes );
}

/**
 * Necessary toi construct a module for an arbitriary set of axioms
 * @param moduleAxioms
 * @param moduleUri
 * @return
 */
public OWLOntology getModuleFromAxioms(Set<OWLAxiom> moduleAxioms, IRI moduleIri) {

    OWLOntologyManager ontologyManager = OWLManager.createOWLOntologyManager();

    OWLOntology module=null;

    try {
        module = ontologyManager.createOntology(moduleIri);
        List<OWLOntologyChange> ontoChanges = new ArrayList<OWLOntologyChange>();
        for(OWLAxiom axiom : moduleAxioms) {
            ontoChanges.add(new AddAxiom(module, axiom));
        }
        ontologyManager.applyChanges(ontoChanges);
    }

    catch(Exception e) {
        System.out.println("Error creating module ontology from extende set of axioms.");

    }

    //System.out.println("Time create OWLOntology for module (s): " + (double)((double)fin-(double)init)/1000.0);

    return module;
}

@Override
List<OWLOntologyChange> createListAxioms(ReferencedListValueDescriptor descriptor) {
    final ReferencedListNodeGenerator nodeGenerator = new ReferencedListNodeGenerator(
            descriptor.getListOwner(), descriptor.getNodeContent());
    boolean first = true;
    NamedResource previousNode = descriptor.getListOwner();
    nodeGenerator.setIndex(0);
    for (NamedResource value : descriptor.getValues()) {
        if (first) {
            nodeGenerator.setProperty(descriptor.getListProperty());
            previousNode = nodeGenerator.addListNode(previousNode, value);
            first = false;
        } else {
            nodeGenerator.setProperty(descriptor.getNextNode());
            previousNode = nodeGenerator.addListNode(previousNode, value);
        }
    }
    return nodeGenerator.getChanges();
}

@Override
List<OWLOntologyChange> createListAxioms(SimpleListValueDescriptor descriptor) {
    final List<OWLOntologyChange> changes = new ArrayList<>(descriptor.getValues().size());
    NamedResource previous = descriptor.getListOwner();
    boolean first = true;
    for (NamedResource item : descriptor.getValues()) {
        final OWLAxiom axiom;
        if (first) {
            axiom = appendNode(previous, descriptor.getListProperty(), item);
            first = false;
        } else {
            axiom = appendNode(previous, descriptor.getNextNode(), item);
        }
        previous = item;
        changes.add(new MutableAddAxiom(ontology, axiom));
    }
    return changes;
}

@Test
public void removeWithoutReconnectClearsRestOfList() {
    testHelper.persistList(LIST_ITEMS);
    final List<OWLOntologyChange> changes = new ArrayList<>();
    int i = 0;
    while (iterator.hasNext()) {
        iterator.next();
        if (i >= 5) {
            changes.addAll(iterator.removeWithoutReconnect());
        }
        i++;
    }
    snapshot.getOntologyManager().applyChanges(changes);
    final OwlapiListIterator it = iterator();
    int count = 0;
    while (it.hasNext()) {
        it.next();
        count++;
    }
    assertEquals(5, count);
}

@Test
public void testReplaceNodeInsideList() {
    final List<URI> lst = new ArrayList<>(LIST_ITEMS.subList(0, 5));
    testHelper.persistList(lst);
    int replaceIndex = 2;
    lst.set(replaceIndex, LIST_ITEMS.get(8));
    int i = 0;
    while (iterator.hasNext() && i < replaceIndex) {
        iterator.next();
        i++;
    }
    iterator.next();
    final List<OWLOntologyChange> changes =
            new ArrayList<>(iterator.replaceNode(NamedResource.create(lst.get(replaceIndex))));
    snapshot.getOntologyManager().applyChanges(changes);

    final OwlapiListIterator it = iterator();
    verifyIterationContent(it, lst);
}

@Test
public void testReplaceLastNode() {
    final List<URI> lst = new ArrayList<>(LIST_ITEMS.subList(0, 5));
    testHelper.persistList(lst);
    int replaceIndex = lst.size() - 1;
    lst.set(replaceIndex, LIST_ITEMS.get(8));
    int i = 0;
    while (iterator.hasNext() && i < replaceIndex) {
        iterator.next();
        i++;
    }
    iterator.next();
    final List<OWLOntologyChange> changes =
            new ArrayList<>(iterator.replaceNode(NamedResource.create(lst.get(replaceIndex))));
    snapshot.getOntologyManager().applyChanges(changes);

    final OwlapiListIterator it = iterator();
    verifyIterationContent(it, lst);
}

private static List<OWLOntologyChange> handleSupportOntologies(OWLGraphWrapper graph)
{
    OWLOntology ontology = graph.getSourceOntology();
    OWLOntologyManager manager = ontology.getOWLOntologyManager();
    OWLDataFactory factory = manager.getOWLDataFactory();

    List<OWLOntologyChange> removeImportChanges = new ArrayList<OWLOntologyChange>();
    Set<OWLOntology> supportOntologySet = graph.getSupportOntologySet();
    for (OWLOntology support : supportOntologySet) {
        Optional<IRI> supportIRI = support.getOntologyID().getOntologyIRI();
        if(supportIRI.isPresent()) {
            IRI ontologyIRI = supportIRI.get();
            OWLImportsDeclaration importDeclaration = factory.getOWLImportsDeclaration(ontologyIRI);
            ChangeApplied status = manager.applyChange(new AddImport(ontology, importDeclaration));
            if (ChangeApplied.SUCCESSFULLY == status) {
                // the change was successful, create remove import for later
                removeImportChanges.add(new RemoveImport(ontology, importDeclaration));
            }
        }
    }
    return removeImportChanges;
}

private void initializeDataStructure() {
    declarationAxioms = new ArrayList<OWLAxiom>();
    domainAndRangeAxioms = new ArrayList<OWLAxiom>();
    existentialAxioms = new ArrayList<OWLAxiom>();
    cardinalityAxioms = new ArrayList<OWLAxiom>();
    subClassOfAxioms = new ArrayList<OWLAxiom>();
    classAssertionAxioms = new ArrayList<OWLAxiom>();
    disJointOfAxioms = new ArrayList<OWLAxiom>();
    selectedAxioms = new HashSet<OWLAxiom>();

    changes = new ArrayList<OWLOntologyChange>();

}

@Override
public void ontologiesChanged(List<? extends OWLOntologyChange> changes) {
    if (changes == null) {
        throw new IllegalArgumentException("Null argument");
    }

    reset();
}

@Override
public void handleChange(List<OWLOntologyChange> changes) {
    synchronized (model.getAboxOntology()) {
        inferenceCache.remove(model);
        model.unRegisterListener(this);
    }
}

private List<OWLOntologyChange> preSaveFileHandler(OWLOntology model) throws UnknownIdentifierException {
    List<OWLOntologyChange> allChanges = null;
    for (PreFileSaveHandler handler : preFileSaveHandlers) {
        List<OWLOntologyChange> changes = handler.handle(model);
        if (changes != null && !changes.isEmpty()) {
            if (allChanges == null) {
                allChanges = new ArrayList<OWLOntologyChange>(
                        changes.size());
            }
            allChanges.addAll(changes);
        }
    }
    return allChanges;
}

public void addModelAnnotations(ModelContainer model, Collection<OWLAnnotation> annotations, METADATA metadata) {
    OWLOntology aBox = model.getAboxOntology();
    List<OWLOntologyChange> changes = new ArrayList<OWLOntologyChange>();
    for (OWLAnnotation annotation : annotations) {
        changes.add(new AddOntologyAnnotation(aBox, annotation));
    }
    applyChanges(model, changes, metadata);
}

public void updateAnnotation(ModelContainer model, OWLAnnotation update, METADATA metadata) {
    OWLOntology aBox = model.getAboxOntology();
    List<OWLOntologyChange> changes = new ArrayList<OWLOntologyChange>();
    Set<OWLAnnotation> existing = model.getAboxOntology().getAnnotations();
    OWLAnnotationProperty target = update.getProperty();
    for (OWLAnnotation annotation : existing) {
        if (target.equals(annotation.getProperty())) {
            changes.add(new RemoveOntologyAnnotation(aBox, annotation));
        }
    }
    changes.add(new AddOntologyAnnotation(aBox, update));
    applyChanges(model, changes, metadata);
}

public void removeAnnotations(ModelContainer model, Collection<OWLAnnotation> annotations, METADATA metadata) {
    OWLOntology aBox = model.getAboxOntology();
    List<OWLOntologyChange> changes = new ArrayList<OWLOntologyChange>();
    for (OWLAnnotation annotation : annotations) {
        changes.add(new RemoveOntologyAnnotation(aBox, annotation));
    }
    applyChanges(model, changes, metadata);
}

private OWLObjectPropertyAssertionAxiom modifyAnnotations(OWLObjectPropertyAssertionAxiom axiom, 
        Set<OWLAnnotation> replacement, 
        ModelContainer model, METADATA metadata) {
    OWLOntology ont = model.getAboxOntology();
    OWLDataFactory f = model.getOWLDataFactory();
    List<OWLOntologyChange> changes = new ArrayList<OWLOntologyChange>(2);
    changes.add(new RemoveAxiom(ont, axiom));
    OWLObjectPropertyAssertionAxiom newAxiom = 
            f.getOWLObjectPropertyAssertionAxiom(axiom.getProperty(), axiom.getSubject(), axiom.getObject(), replacement);
    changes.add(new AddAxiom(ont, newAxiom));
    applyChanges(model, changes, metadata);
    return newAxiom;
}

public void addAxiom(ModelContainer model, OWLAxiom axiom, METADATA metadata) {
    OWLOntology ont = model.getAboxOntology();
    List<OWLOntologyChange> changes = Collections.<OWLOntologyChange>singletonList(new AddAxiom(ont, axiom));
    synchronized (ont) {
        /*
         * all changes to the ontology are synchronized via the ontology object
         */
        applyChanges(model, ont.getOWLOntologyManager(), changes, metadata);    
    }
}

void addAxioms(ModelContainer model, Set<? extends OWLAxiom> axioms, METADATA metadata) {
    OWLOntology ont = model.getAboxOntology();
    List<OWLOntologyChange> changes = new ArrayList<OWLOntologyChange>(axioms.size());
    for(OWLAxiom axiom : axioms) {
        changes.add(new AddAxiom(ont, axiom));
    }
    synchronized (ont) {
        /*
         * all changes to the ontology are synchronized via the ontology object
         */
        applyChanges(model, ont.getOWLOntologyManager(), changes, metadata);
    }
}

void removeAxiom(ModelContainer model, OWLAxiom axiom, METADATA metadata) {
    OWLOntology ont = model.getAboxOntology();
    List<OWLOntologyChange> changes = Collections.<OWLOntologyChange>singletonList(new RemoveAxiom(ont, axiom));
    synchronized (ont) {
        /*
         * all changes to the ontology are synchronized via the ontology object
         */
        applyChanges(model, ont.getOWLOntologyManager(), changes, metadata);
    }
}

void removeAxioms(ModelContainer model, Set<OWLAxiom> axioms, METADATA metadata) {
    OWLOntology ont = model.getAboxOntology();
    List<OWLOntologyChange> changes = new ArrayList<OWLOntologyChange>(axioms.size());
    for(OWLAxiom axiom : axioms) {
        changes.add(new RemoveAxiom(ont, axiom));
    }
    synchronized (ont) {
        /*
         * all changes to the ontology are synchronized via the ontology object
         */
        applyChanges(model, ont.getOWLOntologyManager(), changes, metadata);
    }
}

private void applyChanges(ModelContainer model, List<OWLOntologyChange> changes, METADATA metadata) {
    OWLOntology ont = model.getAboxOntology();
    synchronized (ont) {
        /*
         * all changes to the ontology are synchronized via the ontology object
         */
        applyChanges(model, ont.getOWLOntologyManager(), changes, metadata);
    }
}

@Override
public List<OWLOntologyChange> getPendingChanges() {
    logger.finer("getPendingChanges()");
    List<OWLOntologyChange> ret = this.pendingChanges;
    logger.finer("" + ret);
    return Collections.unmodifiableList(ret);
}

public static List<OWLOntologyChange> invertChanges(List<OWLOntologyChange> originalChanges) {
    final LinkedList<OWLOntologyChange> invertedChanges = new LinkedList<OWLOntologyChange>();
for (OWLOntologyChange originalChange : originalChanges) {
    OWLOntologyChange invertedChange = originalChange.accept(ReverseChangeGenerator.INSTANCE);
    invertedChanges.push(invertedChange);
}
if (invertedChanges.isEmpty()) {
    return null;
}
return invertedChanges;
  }

/**
 * Undo latest change for the given model.
 * 
 * @param model
 * @param userId
 * @return true if the undo was successful
 */
public boolean undo(ModelContainer model, String userId) {
    UndoRedo undoRedo;
    synchronized (allChanges) {
        undoRedo = allChanges.get(model.getModelId());
    }
    if (undoRedo != null) {
        final OWLOntology abox = model.getAboxOntology();
        synchronized (abox) {
            /* 
             * WARNING multiple locks (undoRedo and abox) always lock ontology first
             * to avoid deadlocks!
             */
            synchronized (undoRedo) {
                // pop from undo
                ChangeEvent event = undoRedo.getUndo();
                if (event == null) {
                    return false;
                }

                // invert and apply changes
                List<OWLOntologyChange> invertedChanges = ReverseChangeGenerator.invertChanges(event.getChanges());
                applyChanges(model, invertedChanges);

                // push to redo
                undoRedo.addRedo(event.changes, userId);
                return true;
            }
        }
    }
    return false;
}

/**
 * Applies the specified changes to this ontology snapshot.
 *
 * @param changes The changes to apply
 * @return The applied changes
 */
public List<OWLOntologyChange> applyChanges(List<OWLOntologyChange> changes) {
    final ChangeApplied result = ontologyManager.applyChanges(changes);
    if (result == ChangeApplied.UNSUCCESSFULLY) {
        throw new OntologyChangeApplicationException(
                "At least one of the following changes could not have been applied to this ontology snapshot: " +
                        changes);
    }
    return changes;
}

@Override
public List<OWLOntologyChange> getPendingChanges() {
    logger.finer("getPendingChanges()");
    List<OWLOntologyChange> ret = new ArrayList<>();
    logger.finer("" + ret);
    return Collections.unmodifiableList(ret);
}

private void removeObsoleteNodes(OwlapiListIterator iterator) {
    if (!iterator.hasNext()) {
        return;
    }
    final List<OWLOntologyChange> changes = new ArrayList<>();
    while (iterator.hasNext()) {
        iterator.next();
        changes.addAll(iterator.removeWithoutReconnect());
    }
    owlapiAdapter.addTransactionalChanges(snapshot.applyChanges(changes));
}

@Override
void addNewNodes(SimpleListValueDescriptor descriptor, int index, NamedResource lastNode) {
    if (index >= descriptor.getValues().size()) {
        return;
    }
    final List<OWLOntologyChange> changes = new ArrayList<>(descriptor.getValues().size() - index);
    for (; index < descriptor.getValues().size(); index++) {
        final NamedResource next = descriptor.getValues().get(index);
        changes.add(new MutableAddAxiom(ontology, appendNode(lastNode, descriptor.getNextNode(), next)));
        lastNode = next;
    }
    owlapiAdapter.addTransactionalChanges(snapshot.applyChanges(changes));
}

@Test
public void removeWithoutReconnectOnAllElementsClearsTheWholeList() {
    testHelper.persistList(LIST_ITEMS);
    final List<OWLOntologyChange> changes = new ArrayList<>();
    while (iterator.hasNext()) {
        iterator.next();
        changes.addAll(iterator.removeWithoutReconnect());
    }
    snapshot.getOntologyManager().applyChanges(changes);
    final OwlapiListIterator it = iterator();
    assertFalse(it.hasNext());
}

@Test
public void testReplaceHead() {
    final List<URI> lst = new ArrayList<>(LIST_ITEMS.subList(0, 5));
    testHelper.persistList(lst);
    lst.set(0, LIST_ITEMS.get(8));
    iterator.next();
    final List<OWLOntologyChange> changes = new ArrayList<>(iterator.replaceNode(NamedResource.create(lst.get(0))));
    snapshot.getOntologyManager().applyChanges(changes);

    final OwlapiListIterator it = iterator();
    verifyIterationContent(it, lst);
}

public Set<OWLAxiom> getPendingAxiomAdditions() {
    Set<OWLAxiom> added = new HashSet<OWLAxiom>();
    for (OWLOntologyChange change : m_pendingChanges)
        if (change instanceof AddAxiom)
            added.add(change.getAxiom());
    return added;
}

public Set<OWLAxiom> getPendingAxiomRemovals() {
    Set<OWLAxiom> removed = new HashSet<OWLAxiom>();
    for (OWLOntologyChange change : m_pendingChanges)
        if (change instanceof RemoveAxiom)
            removed.add(change.getAxiom());
    return removed;
}

@Override
public void ontologiesChanged(List<? extends OWLOntologyChange> changes) {
    Set<OWLOntology> importClosure = null;
    for (OWLOntologyChange change : changes) {
        OWLOntology changedOntology = change.getOntology();
        if (!changedOntology.equals(owlOntology_)) {
            if (importClosure == null) {
                importClosure = owlOntology_.getImportsClosure();
            }
            if (!importClosure.contains(changedOntology)) {
                LOGGER_.trace(
                        "Ignoring the change not applicable to the current ontology: {}"
                                + change);
                continue;
            }
        }

        if (!change.isAxiomChange()) {
            LOGGER_.trace(
                    "Non-axiom change: {}\n The ontology will be reloaded.",
                    change);
            // cannot handle non-axiom changes incrementally
            ontologyReloadRequired_ = true;
        } else {
            bufferedChangesLoader_.registerChange(change);
        }
    }
    if (!isBufferingMode_)
        flush();
}

Set<OWLAxiom> getPendingAxiomAdditions() {
    Set<OWLAxiom> added = new HashSet<OWLAxiom>();
    for (OWLOntologyChange change : pendingChanges_) {
        if (change instanceof AddAxiom) {
            added.add(change.getAxiom());
        }
    }
    return added;
}

Set<OWLAxiom> getPendingAxiomRemovals() {
    Set<OWLAxiom> removed = new HashSet<OWLAxiom>();
    for (OWLOntologyChange change : pendingChanges_) {
        if (change instanceof RemoveAxiom) {
            removed.add(change.getAxiom());
        }
    }
    return removed;
}