@Override public boolean hasOntology(OWLOntologyID ontologyId) { Set<OWLOntologyID> aliases = ontologyProvider.listAliases(ontologyId); if (managedOntologies.contains(ontologyId)) return true; for (OWLOntologyID alias : aliases) if (managedOntologies.contains(alias)) return true; return false; }
protected MGraph getOntologyAsMGraph( OWLOntologyID ontologyId, boolean merge, IRI universalPrefix) { if (merge) throw new UnsupportedOperationException( "Merge not implemented yet for Clerezza triple collections."); /* * TODO manage import rewrites better once the container ID is fully configurable (i.e. instead of * going upOne() add "session" or "ontology" if needed). But only do this if we keep considering * imported ontologies as *not* managed. */ // if (!merge) { // TODO MGraph o = new IndexedMGraph(ontologyProvider.getStoredOntology(ontologyId, MGraph.class, merge)); // Now rewrite import statements // Scan import statements for each owl:Ontology instance (hopefully one). String tid = getID(); // Bit of a hack : since ontology spaces are named like {scopeid}/{core|custom}, in that // particular // case we go back to {scopeid}, whereas for sessions we maintain their original id. if (backwardPathLength > 0) tid = tid.split("/")[0]; Iterator<Triple> it; List<Triple> newImports = new LinkedList<Triple>(); synchronized (o) { it = o.filter(null, OWL.imports, null); // We use this list to avoid concurrent modification exceptions. List<Triple> replaceUs = new LinkedList<Triple>(); while (it.hasNext()) replaceUs.add(it.next()); for (Triple t : replaceUs) { String s = ((UriRef) (t.getObject())).getUnicodeString(); // FIXME note the different import targets in the OWLOntology and TripleColllection objects! // s = s.substring(s.indexOf("::") + 2, s.length()); boolean managed = managedOntologies.contains(IRI.create(s)); UriRef target = new UriRef( (managed ? universalPrefix + "/" + tid + "/" : URIUtils.upOne(universalPrefix) + "/") + s); o.remove(t); newImports.add(new TripleImpl(t.getSubject(), OWL.imports, target)); } } for (Triple t : newImports) o.add(t); // } // TODO else if (merge) return o; }
@Override public void removeOntology(OWLOntologyID publicKey) throws OntologyCollectorModificationException { if (publicKey == null) throw new IllegalArgumentException( "Cannot remove an ontology by providing a null public key."); if (publicKey.getOntologyIRI() == null) throw new IllegalArgumentException( "Cannot remove an ontology whose public key has a null ontology IRI."); if (locked) throw new UnmodifiableOntologyCollectorException(this); Set<OWLOntologyID> aliases = ontologyProvider.listAliases(publicKey); aliases.add(publicKey); boolean removed = false; for (OWLOntologyID alias : aliases) removed |= managedOntologies.remove(alias); // Don't fire if the ontology wasn't there in the first place. if (removed) fireOntologyRemoved(publicKey); else throw new MissingOntologyException(this, publicKey); }
protected OWLOntology getOntologyAsOWLOntology( OWLOntologyID ontologyId, boolean merge, IRI universalPrefix) { // if (merge) throw new UnsupportedOperationException("Merge not implemented yet for // OWLOntology."); // Remove the check below. It might be an unmanaged dependency (TODO remove from collector and // reintroduce check?). // if (!hasOntology(ontologyIri)) return null; OWLOntology o; o = ontologyProvider.getStoredOntology(ontologyId, OWLOntology.class, merge); if (merge) { final Set<OWLOntology> set = new HashSet<OWLOntology>(); log.debug("Merging {} with its imports, if any.", o); set.add(o); // Actually, if the provider already performed the merge, this won't happen for (OWLOntology impo : o.getImportsClosure()) { log.debug("Imported ontology {} will be merged with {}.", impo, o); set.add(impo); } OWLOntologySetProvider provider = new OWLOntologySetProvider() { @Override public Set<OWLOntology> getOntologies() { return set; } }; OWLOntologyMerger merger = new OWLOntologyMerger(provider); try { o = merger.createMergedOntology( OWLManager.createOWLOntologyManager(), ontologyId.getOntologyIRI()); } catch (OWLOntologyCreationException e) { log.error("Failed to merge imports for ontology " + ontologyId, e); // do not reassign the root ontology } } else { // Rewrite import statements List<OWLOntologyChange> changes = new ArrayList<OWLOntologyChange>(); OWLDataFactory df = OWLManager.getOWLDataFactory(); /* * TODO manage import rewrites better once the container ID is fully configurable (i.e. instead of * going upOne() add "session" or "ontology" if needed). But only do this if we keep considering * imported ontologies as *not* managed. */ for (OWLImportsDeclaration oldImp : o.getImportsDeclarations()) { changes.add(new RemoveImport(o, oldImp)); String s = oldImp.getIRI().toString(); // FIXME Ugly way to check, but we'll get through with it if (s.contains("::")) s = s.substring(s.indexOf("::") + 2, s.length()); boolean managed = managedOntologies.contains(oldImp.getIRI()); // For space, always go up at least one String tid = getID(); if (backwardPathLength > 0) tid = tid.split("/")[0]; IRI target = IRI.create( (managed ? universalPrefix + "/" + tid + "/" : URIUtils.upOne(universalPrefix) + "/") + s); changes.add(new AddImport(o, df.getOWLImportsDeclaration(target))); } o.getOWLOntologyManager().applyChanges(changes); } return o; }
@Override public synchronized OWLOntologyID addOntology(OntologyInputSource<?> ontologySource) throws UnmodifiableOntologyCollectorException { // Check for error conditions. if (locked) throw new UnmodifiableOntologyCollectorException(this); if (ontologySource == null) throw new IllegalArgumentException("Ontology source cannot be null."); log.debug("Adding ontology to collector {}", getID()); OWLOntologyID key = null; if (ontologySource.hasRootOntology()) { long before = System.currentTimeMillis(); Object o = ontologySource.getRootOntology(); // // FIXME restore ownership management, but maybe not by directly setting the versionIRI // if (ontologyProvider.hasOntology(id.getOntologyIRI())) if (o instanceof MGraph) // claimOwnership((MGraph) o); // else if (o instanceof OWLOntology) claimOwnership((OWLOntology) o); // Check the origin anyhow, as it may be useful for setting aliases with physical locations // etc. if (ontologySource.hasOrigin()) key = ontologyProvider.loadInStore(o, false, ontologySource.getOrigin()); else key = ontologyProvider.loadInStore(o, false); if (key != null) { managedOntologies.add(key); // Note that imported ontologies are not considered as managed! TODO should we change this? log.info("Add ontology completed in {} ms.", (System.currentTimeMillis() - before)); // Fire the event fireOntologyAdded(key); } } else if (ontologySource.hasOrigin()) { // Just the origin : see if it is satisfiable log.debug("Checking origin satisfiability..."); Origin<?> origin = ontologySource.getOrigin(); Object ref = origin.getReference(); log.debug("Origin wraps a {}", ref.getClass().getCanonicalName()); if (ref instanceof IRI) try { log.debug("Deferring addition to physical IRI {} (if available).", ref); key = addOntology(new RootOntologySource((IRI) ref)); } catch (OWLOntologyCreationException e) { throw new RuntimeException(e); } else if (ref instanceof UriRef) { log.debug("Deferring addition to stored Clerezza graph {} (if available).", ref); key = addOntology(new GraphSource((UriRef) ref)); } else if (ref instanceof OWLOntologyID) { OWLOntologyID idref = (OWLOntologyID) ref; log.debug("Deferring addition to stored ontology with public key {} (if available).", ref); if (!ontologyProvider.hasOntology(idref)) throw new MissingOntologyException(this, idref); key = idref; if (managedOntologies.add(idref)) fireOntologyAdded(idref); } else throw new IllegalArgumentException("Invalid origin " + origin); } else throw new IllegalArgumentException( "Ontology source must provide either an ontology object, or a way to reference one (i.e. an origin)."); log.info("Public key : {}", key); return key; }