public void flush() { if (reasoner != null) { reasoner.flush(); } }
@Override public void flush() { reasoner.flush(); }
@Override public synchronized void flush() { r.flush(); }
@Override public void flush() { delegate_.flush(); }
@Override public void flush() { delegate_.flush(); }
@Override public void flush() { delegate_.flush(); }
void flush() { reasoner.flush(); }
public synchronized void addOntology(IOntology o) { if (overall != null) { overall.addImport(o); if (reasoner != null && synchronizing) { reasoner.flush(); } } }
/*** * Remove all axioms that would generate extra unsatisfiable classes for the reasoner */ Collection<OWLOntologyChange> removeUnsatisfiableClasses() { Collection<OWLOntologyChange> removals = new HashSet<>(); removals.addAll(removeAxioms(AxiomType.DISJOINT_CLASSES)); removals.addAll(removeAxioms(AxiomType.DATA_PROPERTY_DOMAIN)); removals.addAll(removeAxioms(AxiomType.DATA_PROPERTY_RANGE)); if (removals.size() > 0) { reasoner.flush(); } logger.info("Removed " + removals.size() + " axioms to prevent unsatisfiable classes"); return removals; }
@Override public OWLReasoner getReasoner() { if (!_reasoner.isPresent()) try { final OWLReasoner reasoner = _reasonerFactory.apply(getOntology()); reasoner.isConsistent(); _reasoner = Optional.of(reasoner); } catch (final Exception e) { Log.error(_logger, e); throw new OpenError(e); } _reasoner.get().flush(); return _reasoner.get(); }
private void precompute() { Set<InferenceType> precomputeNow = EnumSet.copyOf(precompute); OWLReasoner reasoner = getOWLModelManager().getReasoner(); if (!reasoner.getPendingChanges().isEmpty()) { reasoner.flush(); } precomputeNow.retainAll(reasoner.getPrecomputableInferenceTypes()); for (InferenceType inference : precompute) { if (reasoner.isPrecomputed(inference)) { precomputeNow.remove(inference); } } if (!precomputeNow.isEmpty()) { reasoner.precomputeInferences(precomputeNow.toArray(new InferenceType[precomputeNow.size()])); } }
@Override public OWLReasoner getReasoner() { if (!_reasoner.isPresent()) try { final OWLReasoner reasoner = _reasonerFactory.apply(getOntology()); reasoner.isConsistent(); _reasoner = Optional.of(reasoner); } catch (final Exception e) { Log.error(_logger, e); throw new OpenError(e); } _reasoner.get().flush(); return _reasoner.get(); }
@Override public OWLReasoner getReasoner() { if (!_reasoner.isPresent()) try { final OWLReasoner reasoner = _reasonerFactory.apply(getOntology()); reasoner.isConsistent(); _reasoner = Optional.of(reasoner); } catch (final Exception e) { Log.error(_logger, e); throw new OpenError(e); } _reasoner.get().flush(); return _reasoner.get(); }
private void precompute() { Set<InferenceType> precomputeNow = EnumSet.copyOf(precompute); OWLReasoner reasoner = getOWLModelManager().getReasoner(); if (!reasoner.getPendingChanges().isEmpty()) { reasoner.flush(); } precomputeNow.retainAll(reasoner.getPrecomputableInferenceTypes()); for (InferenceType inference : precompute) { if (reasoner.isPrecomputed(inference)) { precomputeNow.remove(inference); } } if (!precomputeNow.isEmpty()) { reasoner.precomputeInferences(precomputeNow.toArray(new InferenceType[precomputeNow.size()])); } }
private void precompute() { Set<InferenceType> precomputeNow = EnumSet.copyOf(precompute); OWLReasoner reasoner = getOWLModelManager().getReasoner(); if (!reasoner.getPendingChanges().isEmpty()) { reasoner.flush(); } precomputeNow.retainAll(reasoner.getPrecomputableInferenceTypes()); for (InferenceType inference : precompute) { if (reasoner.isPrecomputed(inference)) { precomputeNow.remove(inference); } } if (!precomputeNow.isEmpty()) { reasoner.precomputeInferences(precomputeNow.toArray(new InferenceType[0])); } }
private void precompute() { Set<InferenceType> precomputeNow = EnumSet.copyOf(precompute); OWLReasoner reasoner = getOWLModelManager().getReasoner(); if (!reasoner.getPendingChanges().isEmpty()) { reasoner.flush(); } precomputeNow.retainAll(reasoner.getPrecomputableInferenceTypes()); for (InferenceType inference : precompute) { if (reasoner.isPrecomputed(inference)) { precomputeNow.remove(inference); } } if (!precomputeNow.isEmpty()) { reasoner.precomputeInferences(precomputeNow.toArray(new InferenceType[0])); } }
public boolean ensureRunningReasonerInitialized() { boolean reasonerChanged = false; if (runningReasoner instanceof NoOpReasoner) { runningReasoner = null; } if (runningReasoner != null && !runningReasoner.getPendingChanges().isEmpty()) { if (runningReasoner.getBufferingMode() == null || runningReasoner.getBufferingMode() == BufferingMode.NON_BUFFERING) { runningReasoner.dispose(); runningReasoner = null; } else { runningReasoner.flush(); } } if (runningReasoner == null) { runningReasoner = ReasonerUtilities.createReasoner(applyReasonerFilters(ontology), currentReasonerFactory, reasonerProgressMonitor); reasonerChanged = true; } if (runningReasoner == null) { classificationInProgress = false; logger.warn("An error occurred during reasoner initialisation"); } return reasonerChanged; }
public boolean ensureRunningReasonerInitialized() { boolean reasonerChanged = false; if (runningReasoner instanceof NoOpReasoner) { runningReasoner = null; } if (runningReasoner != null && !runningReasoner.getPendingChanges().isEmpty()) { if (runningReasoner.getBufferingMode() == null || runningReasoner.getBufferingMode() == BufferingMode.NON_BUFFERING) { runningReasoner.dispose(); runningReasoner = null; } else { runningReasoner.flush(); } } if (runningReasoner == null) { runningReasoner = ReasonerUtilities.createReasoner(ontology, currentReasonerFactory, reasonerProgressMonitor); reasonerChanged = true; } return reasonerChanged; }
public boolean ensureRunningReasonerInitialized() { boolean reasonerChanged = false; if (runningReasoner instanceof NoOpReasoner) { runningReasoner = null; } if (runningReasoner != null && !runningReasoner.getPendingChanges().isEmpty()) { if (runningReasoner.getBufferingMode() == null || runningReasoner.getBufferingMode() == BufferingMode.NON_BUFFERING) { runningReasoner.dispose(); runningReasoner = null; } else { runningReasoner.flush(); } } if (runningReasoner == null) { runningReasoner = ReasonerUtilities.createReasoner(applyReasonerFilters(ontology), currentReasonerFactory, reasonerProgressMonitor); reasonerChanged = true; } if (runningReasoner == null) { classificationInProgress = false; ProtegeApplication.getErrorLog().logError(new Exception("Reasoner Initialization failed (ontology is probably inconsistent)")); } return reasonerChanged; }
reasoner.flush();