public static Stream<OWLOntology> ontologyStream(OWLOntology o, Imports imports) { Stream<OWLOntology> ontologyStream; if(imports == Imports.INCLUDED) { ontologyStream = o.getImportsClosure().stream(); } else { ontologyStream = Stream.of(o); } return ontologyStream; }
@Override public int getOntologyCount(boolean withClosure) { if (!withClosure) return managedOntologies.keySet().size(); else { Set<OWLOntology> set = new HashSet<OWLOntology>(); for (OWLOntology o : managedOntologies.values()) { set.add(o); set.addAll(o.getImportsClosure()); } return set.size(); } }
@Nonnull @Override public Stream<OWLClass> getTypes(@Nonnull OWLNamedIndividual individual) { return rootOntology.getImportsClosure() .stream() .flatMap(o -> o.getImportsClosure().stream()) .flatMap(o -> o.getClassAssertionAxioms(individual).stream()) .map(OWLClassAssertionAxiom::getClassExpression) .filter(ce -> !ce.isAnonymous()) .map(OWLClassExpression::asOWLClass); }
@Override public Set<OWLAnnotationAssertionAxiom> getAnnotationAssertionAxioms(OWLAnnotationSubject subject) { Set<OWLAnnotationAssertionAxiom> result = new HashSet<>(); for(OWLOntology ontology : rootOntology.getImportsClosure()) { result.addAll(ontology.getAnnotationAssertionAxioms(subject)); } return result; } }
public Stream<OWLOntology> getOntologies() { if(ontologies == null) { ontologies = ImmutableSet.copyOf(ont.getImportsClosure()); } return ontologies.stream(); }
public <S extends OWLObject, I> Multimap<OWLOntology, I> getOntologyObjectPairs2(FrameSectionRenderer<S,I,?> renderer, S subject) { Multimap<OWLOntology, I> result = LinkedHashMultimap.create(); for (OWLOntology ont : rootOntology.getImportsClosure()) { for (I item : renderer.getItemsInOntology(subject, ont, shortFormProvider, null)) { result.put(ont, item); } } return result; }
protected Set<E> getAllEntities(OWLReasoner reasoner) { Set<E> results = new HashSet<E>(); for(OWLOntology ont : reasoner.getRootOntology().getImportsClosure()) { results.addAll(getEntities(ont)); } return results; }
private ImmutableCollection<OWLAnnotationAssertionAxiom> getAxioms(@Nonnull IRI subject) { return axiomsBySubject.get(subject, (iri) -> rootOntology.getImportsClosure().stream() .flatMap(ont -> ont.getAnnotationAssertionAxioms(iri).stream()) .collect(toImmutableList())); }
private void rebuild() { activeLangs.clear(); Stopwatch stopwatch = Stopwatch.createStarted(); rootOntology.getImportsClosure().stream() .flatMap(ont -> ont.getAxioms(ANNOTATION_ASSERTION).stream()) .filter(ActiveLanguagesManager::isLabellingAnnotation) .forEach(this::addAxiom); stopwatch.stop(); logger.info("{} Extracted {} languages in {} ms", projectId, activeLangs.elementSet().size(), stopwatch.elapsed(MILLISECONDS)); rebuildSortedLanguages(); logSortedLanguages(); }
@Override public boolean isDeprecated(OWLEntity entity) { if (!rootOntology.containsAnnotationPropertyInSignature(OWLRDFVocabulary.OWL_DEPRECATED.getIRI(), Imports.INCLUDED)) { return false; } var entityIRI = entity.getIRI(); return rootOntology.getImportsClosure() .stream() .flatMap(ont -> ont.getAnnotationAssertionAxioms(entityIRI).stream()) .anyMatch(OWLAnnotationAssertionAxiom::isDeprecatedIRIAssertion); } }
@Nonnull @Override public Set<? extends OWLEntity> visit(@Nonnull OWLNamedIndividual individual) { Collection<OWLClassExpression> types = EntitySearcher.getTypes(individual, rootOntology.getImportsClosure()); Set<OWLClass> result = new HashSet<>(); for(OWLClassExpression ce : types) { if(!ce.isAnonymous()) { result.addAll(classAncestorsProvider.getAncestors(ce.asOWLClass())); } } return result; }
protected Set<OWLNamedIndividual> getUntypedIndividuals() { Set<OWLNamedIndividual> untypedIndividuals = new HashSet<>(); OWLOntology activeOntology = getOWLModelManager().getActiveOntology(); Set<OWLOntology> importsClosure = activeOntology.getImportsClosure(); for (OWLNamedIndividual individual : activeOntology.getIndividualsInSignature(Imports.INCLUDED)) { Collection<OWLClassExpression> types = EntitySearcher.getTypes(individual, importsClosure); if (types.size() == 0) { untypedIndividuals.add(individual); } } return untypedIndividuals; }
private Set<OntologyDiff> computeDiff(OWLOntology uploadedRootOntology, OWLOntology projectRootOntology) { OntologyDiffCalculator diffCalculator = new OntologyDiffCalculator( new AnnotationDiffCalculator(), new AxiomDiffCalculator() ); ModifiedProjectOntologiesCalculator ontsCalculator = new ModifiedProjectOntologiesCalculator( ImmutableSet.copyOf(projectRootOntology.getImportsClosure()), ImmutableSet.copyOf(uploadedRootOntology.getImportsClosure()), diffCalculator ); return ontsCalculator.getModifiedOntologyDiffs(); }
private void addAnnotations(List<OWLOntologyChange> changes) { for (OWLOntology o : getOWLModelManager().getReasoner().getRootOntology().getImportsClosure()) { for (OWLAnnotation annot : o.getAnnotations()) { changes.add(new AddOntologyAnnotation(exportedOntology, annot)); } for (OWLAnnotationAssertionAxiom axiom : o.getAxioms(AxiomType.ANNOTATION_ASSERTION)) { changes.add(new AddAxiom(exportedOntology, axiom)); } } }
@Override public OntologyChangeList<Boolean> generateChanges(ChangeGenerationContext context) { OntologyChangeList.Builder<Boolean> changeList = new OntologyChangeList.Builder<>(); for (OWLClass entity : entities) { for(OWLOntology ontology : rootOntology.getImportsClosure()) { for(OWLSubClassOfAxiom ax : ontology.getSubClassAxiomsForSubClass(entity)) { processAxiom(ax, entity, ontology, changeList); } } } return changeList.build(true); }
@Override public MetricValue computeValue() { int count = 0; for(OWLOntology ontology : getRootOntology().getImportsClosure()) { count += (ontology.getAxiomCount() - ontology.getLogicalAxiomCount()); } return new IntegerMetricValue("Annotation axioms", count); }
public IncrementalClassifier(PelletReasoner reasoner, ModuleExtractor extractor) { this.reasoner = reasoner; this.extractor = extractor; OWLOntology ontology = reasoner.getRootOntology(); for (OWLOntology ont : ontology.getImportsClosure()) { extractor.addOntology( ont ); } reasoner.getManager().addOntologyChangeListener( this ); }
private void addAsserted(List<OWLOntologyChange> changes) { for (OWLOntology o : getOWLModelManager().getReasoner().getRootOntology().getImportsClosure()) { for (OWLLogicalAxiom ax : o.getLogicalAxioms()) { if (ax.isAnnotated() && exportedOntology.containsAxiom(ax.getAxiomWithoutAnnotations())) { changes.add(new RemoveAxiom(exportedOntology, ax.getAxiomWithoutAnnotations())); } changes.add(new AddAxiom(exportedOntology, ax)); } } }
private void addAsserted(List<OWLOntologyChange> changes) { for (OWLOntology o : getOWLModelManager().getReasoner().getRootOntology().getImportsClosure()) { for (OWLLogicalAxiom ax : o.getLogicalAxioms()) { if (ax.isAnnotated() && exportedOntology.containsAxiom(ax.getAxiomWithoutAnnotations())) { changes.add(new RemoveAxiom(exportedOntology, ax.getAxiomWithoutAnnotations())); } changes.add(new AddAxiom(exportedOntology, ax)); } } }
private void replaceUsage(OntologyChangeList.Builder<OWLEntity> builder) { sourceEntities.forEach(sourceEntity -> { OWLEntityRenamer renamer = new OWLEntityRenamer(rootOntology.getOWLOntologyManager(), rootOntology.getImportsClosure()); List<OWLOntologyChange> renameChanges = renamer.changeIRI(sourceEntity.getIRI(), targetEntity.getIRI()); builder.addAll(renameChanges); }); }