You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@stanbol.apache.org by ci...@apache.org on 2011/03/30 15:44:01 UTC
svn commit: r1086954 [5/16] - in
/incubator/stanbol/trunk/kres/ontologymanager/store: ./ api/ api/src/
api/src/main/ api/src/main/java/ api/src/main/java/org/
api/src/main/java/org/apache/ api/src/main/java/org/apache/stanbol/
api/src/main/java/org/apa...
Added: incubator/stanbol/trunk/kres/ontologymanager/store/jena/src/main/java/org/apache/stanbol/ontologymanager/store/jena/JenaPersistenceStore.java
URL: http://svn.apache.org/viewvc/incubator/stanbol/trunk/kres/ontologymanager/store/jena/src/main/java/org/apache/stanbol/ontologymanager/store/jena/JenaPersistenceStore.java?rev=1086954&view=auto
==============================================================================
--- incubator/stanbol/trunk/kres/ontologymanager/store/jena/src/main/java/org/apache/stanbol/ontologymanager/store/jena/JenaPersistenceStore.java (added)
+++ incubator/stanbol/trunk/kres/ontologymanager/store/jena/src/main/java/org/apache/stanbol/ontologymanager/store/jena/JenaPersistenceStore.java Wed Mar 30 13:43:53 2011
@@ -0,0 +1,3102 @@
+package org.apache.stanbol.ontologymanager.store.jena;
+
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.InputStream;
+import java.io.StringWriter;
+import java.io.UnsupportedEncodingException;
+import java.io.Writer;
+import java.net.MalformedURLException;
+import java.net.URL;
+import java.sql.SQLException;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Dictionary;
+import java.util.HashSet;
+import java.util.Hashtable;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Set;
+import java.util.Vector;
+
+import org.apache.felix.scr.annotations.Activate;
+import org.apache.felix.scr.annotations.Component;
+import org.apache.felix.scr.annotations.Deactivate;
+import org.apache.felix.scr.annotations.PropertyOption;
+import org.apache.felix.scr.annotations.Reference;
+import org.apache.felix.scr.annotations.ReferenceCardinality;
+import org.apache.felix.scr.annotations.Service;
+import org.apache.stanbol.ontologymanager.store.api.JenaPersistenceProvider;
+import org.apache.stanbol.ontologymanager.store.api.PersistenceStore;
+import org.apache.stanbol.ontologymanager.store.api.ResourceManager;
+import org.apache.stanbol.ontologymanager.store.api.StoreSynchronizer;
+import org.apache.stanbol.ontologymanager.store.jena.util.JenaUtil;
+import org.apache.stanbol.ontologymanager.store.model.AdministeredOntologies;
+import org.apache.stanbol.ontologymanager.store.model.BuiltInResource;
+import org.apache.stanbol.ontologymanager.store.model.ClassConstraint;
+import org.apache.stanbol.ontologymanager.store.model.ClassContext;
+import org.apache.stanbol.ontologymanager.store.model.ClassMetaInformation;
+import org.apache.stanbol.ontologymanager.store.model.ClassesForOntology;
+import org.apache.stanbol.ontologymanager.store.model.ConstraintType;
+import org.apache.stanbol.ontologymanager.store.model.ContainerClasses;
+import org.apache.stanbol.ontologymanager.store.model.DatatypePropertiesForOntology;
+import org.apache.stanbol.ontologymanager.store.model.DatatypePropertyContext;
+import org.apache.stanbol.ontologymanager.store.model.DisjointClasses;
+import org.apache.stanbol.ontologymanager.store.model.Domain;
+import org.apache.stanbol.ontologymanager.store.model.EquivalentClasses;
+import org.apache.stanbol.ontologymanager.store.model.EquivalentProperties;
+import org.apache.stanbol.ontologymanager.store.model.IndividualContext;
+import org.apache.stanbol.ontologymanager.store.model.IndividualMetaInformation;
+import org.apache.stanbol.ontologymanager.store.model.IndividualsForOntology;
+import org.apache.stanbol.ontologymanager.store.model.ObjectFactory;
+import org.apache.stanbol.ontologymanager.store.model.ObjectPropertiesForOntology;
+import org.apache.stanbol.ontologymanager.store.model.ObjectPropertyContext;
+import org.apache.stanbol.ontologymanager.store.model.OntologyMetaInformation;
+import org.apache.stanbol.ontologymanager.store.model.PropertyAssertions;
+import org.apache.stanbol.ontologymanager.store.model.PropertyMetaInformation;
+import org.apache.stanbol.ontologymanager.store.model.Range;
+import org.apache.stanbol.ontologymanager.store.model.ResourceMetaInformationType;
+import org.apache.stanbol.ontologymanager.store.model.SuperProperties;
+import org.apache.stanbol.ontologymanager.store.model.Superclasses;
+import org.apache.stanbol.ontologymanager.store.model.PropertyAssertions.PropertyAssertion;
+import org.osgi.service.component.ComponentContext;
+import org.osgi.service.component.ComponentFactory;
+import org.semanticweb.owlapi.apibinding.OWLManager;
+import org.semanticweb.owlapi.io.RDFXMLOntologyFormat;
+import org.semanticweb.owlapi.model.AddAxiom;
+import org.semanticweb.owlapi.model.IRI;
+import org.semanticweb.owlapi.model.OWLAxiom;
+import org.semanticweb.owlapi.model.OWLClass;
+import org.semanticweb.owlapi.model.OWLDataFactory;
+import org.semanticweb.owlapi.model.OWLDataProperty;
+import org.semanticweb.owlapi.model.OWLLiteral;
+import org.semanticweb.owlapi.model.OWLNamedIndividual;
+import org.semanticweb.owlapi.model.OWLObjectProperty;
+import org.semanticweb.owlapi.model.OWLOntology;
+import org.semanticweb.owlapi.model.OWLOntologyChange;
+import org.semanticweb.owlapi.model.OWLOntologyCreationException;
+import org.semanticweb.owlapi.model.OWLOntologyID;
+import org.semanticweb.owlapi.model.OWLOntologyManager;
+import org.semanticweb.owlapi.model.OWLOntologyStorageException;
+import org.semanticweb.owlapi.owllink.OWLlinkHTTPXMLReasoner;
+import org.semanticweb.owlapi.owllink.OWLlinkHTTPXMLReasonerFactory;
+import org.semanticweb.owlapi.owllink.OWLlinkReasonerConfiguration;
+import org.semanticweb.owlapi.owllink.OWLlinkReasonerRuntimeException;
+import org.semanticweb.owlapi.owllink.builtin.requests.ReleaseKB;
+import org.semanticweb.owlapi.reasoner.ConsoleProgressMonitor;
+import org.semanticweb.owlapi.reasoner.IndividualNodeSetPolicy;
+import org.semanticweb.owlapi.reasoner.OWLReasoner;
+import org.semanticweb.owlapi.util.InferredAxiomGenerator;
+import org.semanticweb.owlapi.util.InferredClassAssertionAxiomGenerator;
+import org.semanticweb.owlapi.util.InferredDataPropertyCharacteristicAxiomGenerator;
+import org.semanticweb.owlapi.util.InferredDisjointClassesAxiomGenerator;
+import org.semanticweb.owlapi.util.InferredEquivalentClassAxiomGenerator;
+import org.semanticweb.owlapi.util.InferredEquivalentDataPropertiesAxiomGenerator;
+import org.semanticweb.owlapi.util.InferredEquivalentObjectPropertyAxiomGenerator;
+import org.semanticweb.owlapi.util.InferredInverseObjectPropertiesAxiomGenerator;
+import org.semanticweb.owlapi.util.InferredObjectPropertyCharacteristicAxiomGenerator;
+import org.semanticweb.owlapi.util.InferredPropertyAssertionGenerator;
+import org.semanticweb.owlapi.util.InferredSubClassAxiomGenerator;
+import org.semanticweb.owlapi.util.InferredSubDataPropertyAxiomGenerator;
+import org.semanticweb.owlapi.util.InferredSubObjectPropertyAxiomGenerator;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import com.hp.hpl.jena.ontology.AllValuesFromRestriction;
+import com.hp.hpl.jena.ontology.ComplementClass;
+import com.hp.hpl.jena.ontology.ConversionException;
+import com.hp.hpl.jena.ontology.DataRange;
+import com.hp.hpl.jena.ontology.DatatypeProperty;
+import com.hp.hpl.jena.ontology.EnumeratedClass;
+import com.hp.hpl.jena.ontology.HasValueRestriction;
+import com.hp.hpl.jena.ontology.Individual;
+import com.hp.hpl.jena.ontology.IntersectionClass;
+import com.hp.hpl.jena.ontology.ObjectProperty;
+import com.hp.hpl.jena.ontology.OntClass;
+import com.hp.hpl.jena.ontology.OntModel;
+import com.hp.hpl.jena.ontology.OntModelSpec;
+import com.hp.hpl.jena.ontology.OntProperty;
+import com.hp.hpl.jena.ontology.OntResource;
+import com.hp.hpl.jena.ontology.Restriction;
+import com.hp.hpl.jena.ontology.SomeValuesFromRestriction;
+import com.hp.hpl.jena.ontology.UnionClass;
+import com.hp.hpl.jena.query.Query;
+import com.hp.hpl.jena.query.QueryExecution;
+import com.hp.hpl.jena.query.QueryExecutionFactory;
+import com.hp.hpl.jena.query.QueryFactory;
+import com.hp.hpl.jena.query.ResultSet;
+import com.hp.hpl.jena.query.ResultSetFormatter;
+import com.hp.hpl.jena.rdf.model.Literal;
+import com.hp.hpl.jena.rdf.model.Model;
+import com.hp.hpl.jena.rdf.model.ModelFactory;
+import com.hp.hpl.jena.rdf.model.ModelMaker;
+import com.hp.hpl.jena.rdf.model.NodeIterator;
+import com.hp.hpl.jena.rdf.model.Property;
+import com.hp.hpl.jena.rdf.model.RDFList;
+import com.hp.hpl.jena.rdf.model.RDFNode;
+import com.hp.hpl.jena.rdf.model.RDFWriter;
+import com.hp.hpl.jena.rdf.model.Resource;
+import com.hp.hpl.jena.rdf.model.Statement;
+import com.hp.hpl.jena.rdf.model.StmtIterator;
+import com.hp.hpl.jena.shared.ReificationStyle;
+import com.hp.hpl.jena.util.iterator.ExtendedIterator;
+import com.hp.hpl.jena.vocabulary.OWL;
+import com.hp.hpl.jena.vocabulary.RDF;
+
+@Component(immediate = true, metatype = true)
+@Service
+public class JenaPersistenceStore implements PersistenceStore {
+
+ @org.apache.felix.scr.annotations.Property(value = "")
+ private static final String REASONER_URL_PROP = "org.apache.stanbol.ontologymanager.store.reasonerURL";
+
+ @org.apache.felix.scr.annotations.Property(name = JenaPersistenceStore.REASONER_INFERRED_AXIOM_GENERATOR, cardinality = 1000, value = {"InferredClassAssertionAxiomGenerator"}, options = {
+ @PropertyOption(name = "InferredClassAssertionAxiomGenerator", value = "InferredClassAssertionAxiomGenerator"),
+ @PropertyOption(name = "InferredObjectPropertyCharacteristicAxiomGenerator", value = "InferredObjectPropertyCharacteristicAxiomGenerator"),
+ @PropertyOption(name = "InferredDataPropertyCharacteristicAxiomGenerator", value = "InferredDataPropertyCharacteristicAxiomGenerator"),
+ @PropertyOption(name = "InferredDisjointClassesAxiomGenerator", value = "InferredDisjointClassesAxiomGenerator"),
+ @PropertyOption(name = "InferredEquivalentClassesAxiomGenerator", value = "InferredEquivalentClassesAxiomGenerator"),
+ @PropertyOption(name = "InferredEquivalentDataPropertiesAxiomGenerator", value = "InferredEquivalentDataPropertiesAxiomGenerator"),
+ @PropertyOption(name = "InferredEquivalentObjectPropertyAxiomGenerator", value = "InferredEquivalentObjectPropertyAxiomGenerator"),
+ @PropertyOption(name = "InferredInverseObjectPropertiesGenerator", value = "InferredInverseObjectPropertiesGenerator"),
+ @PropertyOption(name = "InferredObjectPropertyCharacteristicAxiomGenerator", value = "InferredObjectPropertyCharacteristicAxiomGenerator"),
+ @PropertyOption(name = "InferredPropertyAssertionGenerator", value = "InferredPropertyAssertionGenerator"),
+ @PropertyOption(name = "InferredSubClassAxiomGenerator", value = "InferredSubClassAxiomGenerator"),
+ @PropertyOption(name = "InferredSubDataPropertyAxiomGenerator", value = "InferredSubDataPropertyAxiomGenerator"),
+ @PropertyOption(name = "InferredSubObjectPropertyAssertionAxiomGenerator", value = "InferredSubObjectPropertyAssertionAxiomGenerator")})
+ private static final String REASONER_INFERRED_AXIOM_GENERATOR = "org.apache.stanbol.ontologymanager.store.reasonerInferredAxiomGenerators";
+
+ @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
+ private JenaPersistenceProvider persistenceProvider;
+
+ @Reference
+ private ResourceManager resourceManager;
+
+ @Reference(cardinality = ReferenceCardinality.OPTIONAL_UNARY, target = "(component.factory=org.apache.stanbol.ontologymanager.store.StoreSynchronizerFactory)")
+ private ComponentFactory componentFactory;
+
+ private SynchronizerThread synchronizerThread;
+
+ private URL REASONER_URL;
+
+ private boolean useReasoner;
+
+ private List<InferredAxiomGenerator> inferredAxiomGenerators;
+
+ /** Logger instance **/
+ private static Logger logger = LoggerFactory.getLogger(JenaPersistenceStore.class);
+
+ /** Singleton instance **/
+ private static JenaPersistenceStore persistenceStoreInstance = null;
+
+ static {
+ JenaUtil.initialConf();
+ }
+
+ @Deactivate
+ public void deactivate(ComponentContext cc) {
+ this.synchronizerThread.done();
+
+ }
+
+ @Activate
+ @SuppressWarnings("unchecked")
+ public void activate(ComponentContext ce) throws Exception {
+
+ Dictionary<String,Object> properties = ce.getProperties();
+ String reasonerUrl = properties.get(REASONER_URL_PROP).toString();
+ Object axiomGenerators = properties.get(REASONER_INFERRED_AXIOM_GENERATOR);
+ List<String> inferenceGenerators;
+ if (axiomGenerators instanceof String) {
+ inferenceGenerators = new ArrayList<String>();
+ inferenceGenerators.add((String) axiomGenerators);
+ } else {
+ inferenceGenerators = Arrays.asList((String[]) properties.get(REASONER_INFERRED_AXIOM_GENERATOR));
+ }
+ inferredAxiomGenerators = createAxiomGenerators(inferenceGenerators);
+ if (reasonerUrl == null || "".equals(reasonerUrl)) {
+ logger.error("Reasoner URL not found, If inferred axioms are requested "
+ + OntModelSpec.OWL_DL_MEM_TRANS_INF + " will be used");
+ } else {
+ try {
+ REASONER_URL = new URL(reasonerUrl);
+ this.useReasoner = true;
+ } catch (MalformedURLException e) {
+ logger.warn("Invalid URL for reasoner : " + reasonerUrl);
+ }
+ }
+ // Get IStoreSycnhronizer from component factory
+ if (this.componentFactory != null) {
+ final Dictionary props = new Hashtable();
+ props.put(ResourceManager.class.getName(), resourceManager);
+ StoreSynchronizer storeSynchronizer = (StoreSynchronizer) this.componentFactory.newInstance(
+ props).getInstance();
+ this.synchronizerThread = new SynchronizerThread(storeSynchronizer);
+ synchronizerThread.start();
+ } else {
+ logger.info("No synchronizer factory found");
+ }
+
+ persistenceStoreInstance = this;
+
+ }
+
+ private List<InferredAxiomGenerator> createAxiomGenerators(List<String> inferenceGenerators) {
+ List<InferredAxiomGenerator> generators = new ArrayList<InferredAxiomGenerator>();
+ for (String generator : inferenceGenerators) {
+ if (generator.equalsIgnoreCase(InferredClassAssertionAxiomGenerator.class.getSimpleName())) {
+ generators.add(new InferredClassAssertionAxiomGenerator());
+ } else if (generator.equalsIgnoreCase(InferredDataPropertyCharacteristicAxiomGenerator.class
+ .getSimpleName())) {
+ generators.add(new InferredDataPropertyCharacteristicAxiomGenerator());
+ } else if (generator
+ .equalsIgnoreCase(InferredDisjointClassesAxiomGenerator.class.getSimpleName())) {
+ generators.add(new InferredDisjointClassesAxiomGenerator());
+ } else if (generator
+ .equalsIgnoreCase(InferredEquivalentClassAxiomGenerator.class.getSimpleName())) {
+ generators.add(new InferredEquivalentClassAxiomGenerator());
+ } else if (generator.equalsIgnoreCase(InferredEquivalentDataPropertiesAxiomGenerator.class
+ .getSimpleName())) {
+ generators.add(new InferredEquivalentDataPropertiesAxiomGenerator());
+ } else if (generator.equalsIgnoreCase(InferredEquivalentObjectPropertyAxiomGenerator.class
+ .getSimpleName())) {
+ generators.add(new InferredEquivalentDataPropertiesAxiomGenerator());
+ } else if (generator.equalsIgnoreCase(InferredInverseObjectPropertiesAxiomGenerator.class
+ .getSimpleName())) {
+ generators.add(new InferredInverseObjectPropertiesAxiomGenerator());
+ } else if (generator.equalsIgnoreCase(InferredObjectPropertyCharacteristicAxiomGenerator.class
+ .getSimpleName())) {
+ generators.add(new InferredObjectPropertyCharacteristicAxiomGenerator());
+ } else if (generator.equalsIgnoreCase(InferredDataPropertyCharacteristicAxiomGenerator.class
+ .getSimpleName())) {
+ generators.add(new InferredDataPropertyCharacteristicAxiomGenerator());
+ } else if (generator.equalsIgnoreCase(InferredPropertyAssertionGenerator.class.getSimpleName())) {
+ generators.add(new InferredPropertyAssertionGenerator());
+ } else if (generator.equalsIgnoreCase(InferredSubClassAxiomGenerator.class.getSimpleName())) {
+ generators.add(new InferredClassAssertionAxiomGenerator());
+ } else if (generator
+ .equalsIgnoreCase(InferredSubDataPropertyAxiomGenerator.class.getSimpleName())) {
+ generators.add(new InferredClassAssertionAxiomGenerator());
+ } else if (generator.equalsIgnoreCase(InferredSubObjectPropertyAxiomGenerator.class
+ .getSimpleName())) {
+ generators.add(new InferredClassAssertionAxiomGenerator());
+ }
+ }
+ return generators;
+
+ }
+
+ public void bindComponentFactory(ComponentFactory componentFactory) {
+ this.componentFactory = componentFactory;
+ }
+
+ public void unbindComponentFactory(ComponentFactory componentFactory) {
+ this.synchronizerThread.done();
+ this.componentFactory = null;
+ }
+
+ public void bindPersistenceProvider(JenaPersistenceProvider persistenceProvider) {
+ this.persistenceProvider = persistenceProvider;
+ }
+
+ public void unbindPersistenceProvider(JenaPersistenceProvider persistenceProvider) {
+ this.synchronizerThread.done();
+ this.persistenceProvider = null;
+ }
+
+ public URL getREASONER_URL() {
+ return REASONER_URL;
+ }
+
+ public ModelMaker getModelMaker() {
+ ModelMaker m_maker = ModelFactory.createMemModelMaker(ReificationStyle.Minimal);
+ return m_maker;
+ }
+
+ public OntModelSpec getOntModelSpec(boolean attachReasoner) {
+ OntModelSpec oms;
+ if (attachReasoner) {
+ oms = new OntModelSpec(OntModelSpec.OWL_DL_MEM_TRANS_INF);
+ } else {
+ oms = new OntModelSpec(OntModelSpec.OWL_DL_MEM);
+ }
+ return oms;
+ }
+
+ public static JenaPersistenceStore getInstance() {
+ if (persistenceStoreInstance == null) {
+ persistenceStoreInstance = new JenaPersistenceStore();
+ }
+ return persistenceStoreInstance;
+ }
+
+ /** Interface Functions **/
+
+ public boolean clearPersistenceStore() {
+ resourceManager.clearResourceManager();
+ return persistenceProvider.clear();
+ }
+
+ public AdministeredOntologies retrieveAdministeredOntologies() {
+ ObjectFactory objectFactory = new ObjectFactory();
+ AdministeredOntologies administeredOntologies = objectFactory.createAdministeredOntologies();
+ List<String> ontologyURIs = getSavedOntologyURIs();
+ Iterator<String> ontologyURIsItr = ontologyURIs.iterator();
+ while (ontologyURIsItr.hasNext()) {
+ String curOntologyURI = ontologyURIsItr.next();
+ String curOntologyPath = resourceManager.getOntologyPath(curOntologyURI);
+ if (curOntologyPath != null) {
+ OntologyMetaInformation ontologyMetaInformation = retrieveOntologyMetaInformation(curOntologyURI);
+ administeredOntologies.getOntologyMetaInformation().add(ontologyMetaInformation);
+ }
+ }
+ return administeredOntologies;
+ }
+
+ public OntologyMetaInformation saveOntology(String ontologyContent, String ontologyURI, String encoding) throws UnsupportedEncodingException {
+ long t1 = System.currentTimeMillis();
+ OntologyMetaInformation ontMetaInformation = null;
+ OntModel om = null;
+ long t2 = System.currentTimeMillis();
+ try {
+ if (persistenceProvider.hasModel(ontologyURI)) {
+ logger.info("Ontology store for: " + ontologyURI + " already exists: Updating ontology");
+ deleteOntology(ontologyURI);
+ }
+ long st1 = System.currentTimeMillis();
+ logger.info("Creating a new ontology store for: " + ontologyURI);
+ InputStream is = new ByteArrayInputStream(ontologyContent.getBytes(encoding));
+ long st2 = System.currentTimeMillis();
+ // ModelMaker modelMaker = getModelMaker();
+ OntModelSpec oms = getOntModelSpec(true);
+ long st3 = System.currentTimeMillis();
+ // oms.setDocumentManager(new DbAwareDocumentManager(modelMaker));
+ long st4 = System.currentTimeMillis();
+ Model base = persistenceProvider.createModel(ontologyURI);
+ long st5 = System.currentTimeMillis();
+ om = ModelFactory.createOntologyModel(oms, base);
+ long st6 = System.currentTimeMillis();
+ /** FIXME:: instead of try/catch, use a parameter **/
+ Model createdModel = null;
+ resourceManager.registerOntology(ontologyURI);
+ try {
+ createdModel = om.read(is, ontologyURI, "RDF/XML");
+ } catch (Exception e) {
+ resourceManager.registerOntology(ontologyURI);
+ logger.warn("Unable to read ontology {} ", ontologyURI);
+ }
+ logger.info(ontologyURI + "model read as RDF/XML");
+ long st7 = System.currentTimeMillis();
+ logger.info(" Create input stream: " + (st2 - st1));
+ logger.info(" Get Model Spec: " + (st3 - st2));
+
+ logger.info(" Create Base Model: " + (st5 - st4));
+ logger.info(" Create Ont Model: " + (st6 - st5));
+ logger.info(" Read Model: " + (st7 - st6));
+ logger.info(" Total Creation: " + (st7 - st1));
+
+ long t3 = System.currentTimeMillis();
+
+ long t4 = System.currentTimeMillis();
+
+ if (createdModel != null) {
+ ExtendedIterator ontClassesItr = om.listClasses();
+ while (ontClassesItr.hasNext()) {
+ OntClass curOntClass = (OntClass) ontClassesItr.next();
+ String curOntClassURI = curOntClass.getURI();
+ if (curOntClassURI != null) {
+ resourceManager.registerClass(ontologyURI, curOntClassURI);
+ }
+ }
+ long t5 = System.currentTimeMillis();
+
+ ExtendedIterator ontDatatypePropertiesItr = om.listDatatypeProperties();
+ while (ontDatatypePropertiesItr.hasNext()) {
+ DatatypeProperty curDatatypeProperty = (DatatypeProperty) ontDatatypePropertiesItr.next();
+ String curDatatypePropertyURI = curDatatypeProperty.getURI();
+ if (curDatatypePropertyURI != null) {
+ resourceManager.registerDatatypeProperty(ontologyURI, curDatatypePropertyURI);
+ }
+ }
+
+ // XXX Get referenced properties from OWL.Restrictions
+ // StmtIterator stmts = om.listStatements(null, OWL.onProperty,
+ // (RDFNode) null);
+ // List<Statement> stmtsToBeAdded = new ArrayList<Statement>();
+ // while (stmts.hasNext()) {
+ // RDFNode node = stmts.next().getObject();
+ // if (node.isURIResource()) {
+ // stmtsToBeAdded.add(new StatementImpl(node.asResource(),
+ // RDF.type, RDF.Property));
+ // }
+ // }
+
+ long t6 = System.currentTimeMillis();
+ ExtendedIterator ontObjectPropertiesItr = om.listObjectProperties();
+ while (ontObjectPropertiesItr.hasNext()) {
+ ObjectProperty curObjectProperty = (ObjectProperty) ontObjectPropertiesItr.next();
+ String curObjectPropertyURI = curObjectProperty.getURI();
+ if (curObjectPropertyURI != null) {
+ resourceManager.registerObjectProperty(ontologyURI, curObjectPropertyURI);
+ }
+ }
+ long t7 = System.currentTimeMillis();
+ ExtendedIterator ontIndividualsItr = om.listIndividuals();
+ while (ontIndividualsItr.hasNext()) {
+ Individual curIndividual = (Individual) ontIndividualsItr.next();
+ String curIndividualURI = curIndividual.getURI();
+ if (curIndividualURI != null) {
+ resourceManager.registerIndividual(ontologyURI, curIndividualURI);
+ }
+ }
+
+ long t8 = System.currentTimeMillis();
+ Set imports = om.listImportedOntologyURIs();
+ Iterator importsItr = imports.iterator();
+ while (importsItr.hasNext()) {
+ String importedOntologyURI = (String) importsItr.next();
+ resourceManager.registerOntology(importedOntologyURI);
+ Model baseModel = persistenceProvider.createModel(importedOntologyURI);
+
+ // Model baseModel =
+ // modelMaker.getModel(importedOntologyURI);
+ OntModel imported_om = ModelFactory
+ .createOntologyModel(getOntModelSpec(false), baseModel);
+ // FIXME Test this case
+ imported_om.read(importedOntologyURI);
+ ExtendedIterator importedOntClassesItr = imported_om.listClasses();
+ while (importedOntClassesItr.hasNext()) {
+ OntClass curOntClass = (OntClass) importedOntClassesItr.next();
+ String curOntClassURI = curOntClass.getURI();
+ if (curOntClassURI != null) {
+ resourceManager.registerClass(importedOntologyURI, curOntClassURI);
+ }
+ }
+ ExtendedIterator importedDatatypePropertiesItr = imported_om.listDatatypeProperties();
+ while (importedDatatypePropertiesItr.hasNext()) {
+ DatatypeProperty curDatatypeProperty = (DatatypeProperty) importedDatatypePropertiesItr
+ .next();
+ String curDatatypePropertyURI = curDatatypeProperty.getURI();
+ if (curDatatypePropertyURI != null) {
+ resourceManager.registerDatatypeProperty(importedOntologyURI,
+ curDatatypePropertyURI);
+ }
+ }
+ ExtendedIterator importedObjectPropertiesItr = imported_om.listObjectProperties();
+ while (importedObjectPropertiesItr.hasNext()) {
+ ObjectProperty curObjectProperty = (ObjectProperty) importedObjectPropertiesItr
+ .next();
+ String curObjectPropertyURI = curObjectProperty.getURI();
+ if (curObjectPropertyURI != null) {
+ resourceManager.registerObjectProperty(importedOntologyURI, curObjectPropertyURI);
+ }
+ }
+ ExtendedIterator importedOntIndividualsItr = imported_om.listIndividuals();
+ while (importedOntIndividualsItr.hasNext()) {
+ Individual curIndividual = (Individual) importedOntIndividualsItr.next();
+ String curIndividualURI = curIndividual.getURI();
+ if (curIndividualURI != null) {
+ resourceManager.registerIndividual(importedOntologyURI, curIndividualURI);
+ }
+ }
+ persistenceProvider.commit(imported_om);
+ }
+ long t9 = System.currentTimeMillis();
+ ontMetaInformation = retrieveOntologyMetaInformation(ontologyURI);
+ long t10 = System.currentTimeMillis();
+ logger.info(" Get Connection: " + (t2 - t1) + " miliseconds");
+ logger.info(" Create Ontology Model : " + (t3 - t2) + " miliseconds");
+
+ logger.info(" Classes : " + (t5 - t4) + " miliseconds");
+ logger.info(" Datatype Properties : " + (t6 - t5) + " miliseconds");
+ logger.info(" Object Props : " + (t7 - t6) + " miliseconds");
+ logger.info(" Individuals : " + (t8 - t7) + " miliseconds");
+ logger.info(" Imports : " + (t9 - t8) + " miliseconds");
+ logger.info(" MetaInf : " + (t10 - t9) + " miliseconds");
+ logger.info(" Total Save Time " + (t10 - t1) + " miliseconds");
+
+ }
+ } catch (Exception e) {
+ logger.error("Error ", e);
+ } finally {
+ persistenceProvider.commit(om);
+ }
+ return ontMetaInformation;
+ }
+
+ public String retrieveOntology(String ontologyURI, String language, boolean withInferredAxioms) {
+
+ try {
+ if (persistenceProvider.hasModel(ontologyURI)) {
+ Model baseModel = persistenceProvider.getModel(ontologyURI);
+ OntModel ontModel = ModelFactory.createOntologyModel(getOntModelSpec(withInferredAxioms),
+ baseModel);
+ if (this.useReasoner && withInferredAxioms) {
+ ontModel = addInferencesToModel(ontModel, ontologyURI, InferenceScope.Class);
+ }
+ ByteArrayOutputStream bos = new ByteArrayOutputStream();
+ RDFWriter rdfWriter = ontModel.getWriter("RDF/XML");
+ rdfWriter.setProperty("xmlbase", ontologyURI);
+ rdfWriter.write(ontModel.getBaseModel(), bos, ontologyURI);
+
+ byte[] ontologyContentAsByteArray = bos.toByteArray();
+ String ontologyContentAsString = new String(ontologyContentAsByteArray);
+ return ontologyContentAsString;
+ }
+ } catch (Exception e) {
+ logger.error("Error ", e);
+ }
+ return null;
+ }
+
+ @Override
+ public String mergeOntology(String ontologyURI,
+ String targetOntology,
+ String targetOntologyURI,
+ boolean withInferredAxioms) throws Exception {
+ try {
+ if (persistenceProvider.hasModel(ontologyURI)) {
+ Model baseModel = persistenceProvider.getModel(ontologyURI);
+ OntModel ontModel = ModelFactory.createOntologyModel(getOntModelSpec(withInferredAxioms),
+ baseModel);
+ if (this.useReasoner && withInferredAxioms) {
+ ontModel = addInferencesToModel(ontModel, ontologyURI, InferenceScope.Class);
+ }
+
+ InputStream is = new ByteArrayInputStream(targetOntology.getBytes());
+ ontModel.read(is, targetOntologyURI);
+
+ ByteArrayOutputStream bos = new ByteArrayOutputStream();
+ RDFWriter rdfWriter = ontModel.getWriter("RDF/XML");
+ rdfWriter.setProperty("xmlbase", ontologyURI);
+ rdfWriter.write(ontModel.getBaseModel(), bos, ontologyURI);
+
+ byte[] ontologyContentAsByteArray = bos.toByteArray();
+ String ontologyContentAsString = new String(ontologyContentAsByteArray);
+ return ontologyContentAsString;
+ }
+ } catch (Exception e) {
+ logger.error("Error ", e);
+ }
+ return null;
+ }
+
+ public ClassMetaInformation generateClassForOntology(String ontologyURI, String classURI) {
+ OntModel ontModel = null;
+ try {
+ // System.out.println(ontologyURI);
+ // System.out.println(classURI);
+
+ if (persistenceProvider.hasModel(ontologyURI)) {
+ Model baseModel = persistenceProvider.getModel(ontologyURI);
+ ontModel = ModelFactory.createOntologyModel(getOntModelSpec(false), baseModel);
+ OntClass classForURI = ontModel.getOntClass(ontologyURI);
+ if (classForURI == null) {
+ // the class does not exist, this is what we desire
+ ontModel.createClass(classURI);
+ resourceManager.registerClass(ontologyURI, classURI);
+ return generateClassMetaInformation(classURI);
+ }
+ }
+ } catch (Exception e) {
+ logger.error("Error ", e);
+ } finally {
+ persistenceProvider.commit(ontModel);
+ }
+ return null;
+ }
+
+ public PropertyMetaInformation generateDatatypePropertyForOntology(String ontologyURI,
+ String datatypePropertyURI) {
+
+ try {
+
+ if (persistenceProvider.hasModel(ontologyURI)) {
+ Model baseModel = persistenceProvider.getModel(ontologyURI);
+ OntModel ontModel = ModelFactory.createOntologyModel(getOntModelSpec(false), baseModel);
+
+ OntProperty ontPropertyForURI = ontModel.getOntProperty(datatypePropertyURI);
+ if (ontPropertyForURI == null) {
+ // the datatypeProperty does not exist, this is what we
+ // desire
+ ontModel.createDatatypeProperty(datatypePropertyURI);
+ resourceManager.registerDatatypeProperty(ontologyURI, datatypePropertyURI);
+ persistenceProvider.commit(ontModel);
+ return generatePropertyMetaInformation(datatypePropertyURI);
+ }
+ }
+ } catch (Exception e) {
+ logger.error("Error ", e);
+ }
+ return null;
+ }
+
+ public PropertyMetaInformation generateObjectPropertyForOntology(String ontologyURI,
+ String objectPropertyURI) {
+
+ try {
+ if (persistenceProvider.hasModel(ontologyURI)) {
+ Model baseModel = persistenceProvider.getModel(ontologyURI);
+ OntModel ontModel = ModelFactory.createOntologyModel(getOntModelSpec(false), baseModel);
+ OntProperty ontPropertyForURI = ontModel.getOntProperty(objectPropertyURI);
+ if (ontPropertyForURI == null) {
+ // the objectProperty does not exist, this is what we desire
+ ontModel.createObjectProperty(objectPropertyURI);
+ resourceManager.registerObjectProperty(ontologyURI, objectPropertyURI);
+ persistenceProvider.commit(ontModel);
+ return generatePropertyMetaInformation(objectPropertyURI);
+ }
+ }
+ } catch (Exception e) {
+ logger.error("Error ", e);
+ }
+ return null;
+ }
+
+ public boolean makeSubClassOf(String subClassURI, String superClassURI) {
+
+ try {
+ // FIXME:: What happens when the superClassURI does not exist?
+ String subClassOntologyURI = resourceManager.resolveOntologyURIFromResourceURI(subClassURI);
+ String superClassOntologyURI = resourceManager.resolveOntologyURIFromResourceURI(superClassURI);
+ if (subClassOntologyURI != null && superClassOntologyURI != null) {
+ Model subClassModel = persistenceProvider.getModel(subClassOntologyURI);
+ OntModel subClassOntModel = ModelFactory.createOntologyModel(getOntModelSpec(false),
+ subClassModel);
+ OntClass subClass = subClassOntModel.getOntClass(subClassURI);
+
+ Model superClassModel = persistenceProvider.getModel(superClassOntologyURI);
+ OntModel superClassOntModel = ModelFactory.createOntologyModel(getOntModelSpec(false),
+ superClassModel);
+ OntClass superClass = superClassOntModel.getOntClass(superClassURI);
+
+ if (subClass != null && superClass != null) {
+ subClass.addSuperClass(superClass);
+ superClass.addSubClass(subClass);
+ persistenceProvider.commit(subClassOntModel);
+ persistenceProvider.commit(superClassOntModel);
+ return true;
+ }
+ }
+ } catch (Exception e) {
+ logger.error("Error ", e);
+ }
+ return false;
+ }
+
+ public boolean deleteSuperClass(String subClassURI, String superClassURI) {
+
+ try {
+ // FIXME:: What happens when the superClassURI does not exist?
+ String subClassOntologyURI = resourceManager.resolveOntologyURIFromResourceURI(subClassURI);
+ String superClassOntologyURI = resourceManager.resolveOntologyURIFromResourceURI(superClassURI);
+ if (subClassOntologyURI != null && superClassOntologyURI != null) {
+ Model subClassModel = persistenceProvider.getModel(subClassOntologyURI);
+ OntModel subClassOntModel = ModelFactory.createOntologyModel(getOntModelSpec(false),
+ subClassModel);
+ OntClass subClass = subClassOntModel.getOntClass(subClassURI);
+
+ Model superClassModel = persistenceProvider.getModel(superClassOntologyURI);
+ OntModel superClassOntModel = ModelFactory.createOntologyModel(getOntModelSpec(false),
+ superClassModel);
+ OntClass superClass = superClassOntModel.getOntClass(superClassURI);
+
+ if (subClass != null && superClass != null) {
+ subClass.removeSuperClass(superClass);
+ superClass.removeSubClass(subClass);
+ persistenceProvider.commit(subClassOntModel);
+ persistenceProvider.commit(superClassOntModel);
+ return true;
+ }
+ }
+ } catch (Exception e) {
+ logger.error("Error ", e);
+ }
+ return false;
+ }
+
+ public boolean setDomain(String propertyURI, List<String> domainURIs) {
+
+ try {
+ String ontologyForPropertyURI = resourceManager.resolveOntologyURIFromResourceURI(propertyURI);
+ Model modelForProperty = persistenceProvider.getModel(ontologyForPropertyURI);
+ OntModel ontModelForProperty = ModelFactory.createOntologyModel(getOntModelSpec(false),
+ modelForProperty);
+ OntProperty ontProperty = ontModelForProperty.getOntProperty(propertyURI);
+ for (OntResource domainResource : ontProperty.listDomain().toList()) {
+ ontProperty.removeDomain(domainResource);
+ }
+ for (String domainURI : domainURIs) {
+ String ontologyForDomainURI = resourceManager.resolveOntologyURIFromResourceURI(domainURI);
+ if (ontologyForPropertyURI != null && ontologyForDomainURI != null) {
+ Model modelForDomain = persistenceProvider.getModel(ontologyForDomainURI);
+ OntModel ontModelForDomain = ModelFactory.createOntologyModel(getOntModelSpec(false),
+ modelForDomain);
+ OntClass ontClassForDomain = ontModelForDomain.getOntClass(domainURI);
+ if (ontProperty != null && ontClassForDomain != null) {
+ ontProperty.addDomain(ontClassForDomain);
+ persistenceProvider.commit(ontModelForProperty);
+ persistenceProvider.commit(ontModelForDomain);
+ }
+ }
+ }
+ return true;
+ } catch (Exception e) {
+ logger.error("Error ", e);
+ }
+ return false;
+ }
+
+ public boolean addDomain(String propertyURI, String domainURI) {
+
+ try {
+ String ontologyForPropertyURI = resourceManager.resolveOntologyURIFromResourceURI(propertyURI);
+ Model modelForProperty = persistenceProvider.getModel(ontologyForPropertyURI);
+ OntModel ontModelForProperty = ModelFactory.createOntologyModel(getOntModelSpec(false),
+ modelForProperty);
+ OntProperty ontProperty = ontModelForProperty.getOntProperty(propertyURI);
+ String ontologyForDomainURI = resourceManager.resolveOntologyURIFromResourceURI(domainURI);
+ if (ontologyForPropertyURI != null && ontologyForDomainURI != null) {
+ Model modelForDomain = persistenceProvider.getModel(ontologyForDomainURI);
+ OntModel ontModelForDomain = ModelFactory.createOntologyModel(getOntModelSpec(false),
+ modelForDomain);
+ OntClass ontClassForDomain = ontModelForDomain.getOntClass(domainURI);
+ if (ontProperty != null && ontClassForDomain != null) {
+ ontProperty.addDomain(ontClassForDomain);
+ persistenceProvider.commit(ontModelForProperty);
+ persistenceProvider.commit(ontModelForDomain);
+ }
+ }
+ return true;
+ } catch (Exception e) {
+ logger.error("Error ", e);
+ }
+ return false;
+ }
+
+ public boolean deleteDomain(String propertyURI, String domainURI) {
+
+ try {
+ String ontologyForPropertyURI = resourceManager.resolveOntologyURIFromResourceURI(propertyURI);
+ Model modelForProperty = persistenceProvider.getModel(ontologyForPropertyURI);
+ OntModel ontModelForProperty = ModelFactory.createOntologyModel(getOntModelSpec(false),
+ modelForProperty);
+ OntProperty ontProperty = ontModelForProperty.getOntProperty(propertyURI);
+ String ontologyForDomainURI = resourceManager.resolveOntologyURIFromResourceURI(domainURI);
+ if (ontologyForPropertyURI != null && ontologyForDomainURI != null) {
+ Model modelForDomain = persistenceProvider.getModel(ontologyForDomainURI);
+ OntModel ontModelForDomain = ModelFactory.createOntologyModel(getOntModelSpec(false),
+ modelForDomain);
+ OntClass ontClassForDomain = ontModelForDomain.getOntClass(domainURI);
+ if (ontProperty != null && ontClassForDomain != null) {
+ ontProperty.removeDomain(ontClassForDomain);
+ persistenceProvider.commit(ontModelForProperty);
+ persistenceProvider.commit(ontModelForDomain);
+ }
+ }
+ return true;
+ } catch (Exception e) {
+ logger.error("Error ", e);
+ }
+ return false;
+ }
+
+ public boolean setRange(String propertyURI, List<String> rangeURIs) {
+ try {
+ String ontologyForPropertyURI = resourceManager.resolveOntologyURIFromResourceURI(propertyURI);
+ Model modelForProperty = persistenceProvider.getModel(ontologyForPropertyURI);
+ OntModel ontModelForProperty = ModelFactory.createOntologyModel(getOntModelSpec(false),
+ modelForProperty);
+ OntProperty ontProperty = ontModelForProperty.getOntProperty(propertyURI);
+ for (OntResource rangeResource : ontProperty.listRange().toList()) {
+ ontProperty.removeRange(rangeResource);
+ }
+ for (String rangeURI : rangeURIs) {
+ String ontologyForRangeURI = resourceManager.resolveOntologyURIFromResourceURI(rangeURI);
+ if (ontologyForPropertyURI != null) {
+ if (JenaUtil.isBuiltInType(rangeURI)) {
+ Resource rangeResource = JenaUtil.getResourceForBuiltInType(rangeURI);
+ if (ontProperty != null && rangeResource != null) {
+ ontProperty.addRange(rangeResource);
+ persistenceProvider.commit(ontModelForProperty);
+ }
+ } else if (ontologyForRangeURI != null) {
+ Model modelForRange = persistenceProvider.getModel(ontologyForRangeURI);
+ OntModel ontModelForRange = ModelFactory.createOntologyModel(getOntModelSpec(false),
+ modelForRange);
+ OntClass ontClassForRange = ontModelForRange.getOntClass(rangeURI);
+
+ if (ontProperty != null && ontClassForRange != null) {
+ ontProperty.addRange(ontClassForRange);
+ persistenceProvider.commit(ontModelForProperty);
+ persistenceProvider.commit(ontModelForRange);
+ }
+ }
+ }
+ }
+ return true;
+ } catch (Exception e) {
+ logger.error("Error ", e);
+ }
+ return false;
+ }
+
+ public boolean addRange(String propertyURI, String rangeURI) {
+ try {
+ String ontologyForPropertyURI = resourceManager.resolveOntologyURIFromResourceURI(propertyURI);
+ Model modelForProperty = persistenceProvider.getModel(ontologyForPropertyURI);
+ OntModel ontModelForProperty = ModelFactory.createOntologyModel(getOntModelSpec(false),
+ modelForProperty);
+ OntProperty ontProperty = ontModelForProperty.getOntProperty(propertyURI);
+
+ String ontologyForRangeURI = resourceManager.resolveOntologyURIFromResourceURI(rangeURI);
+ if (ontologyForPropertyURI != null) {
+ if (JenaUtil.isBuiltInType(rangeURI)) {
+ Resource rangeResource = JenaUtil.getResourceForBuiltInType(rangeURI);
+ if (ontProperty != null && rangeResource != null) {
+ ontProperty.addRange(rangeResource);
+ persistenceProvider.commit(ontModelForProperty);
+ }
+ } else if (ontologyForRangeURI != null) {
+ Model modelForRange = persistenceProvider.getModel(ontologyForRangeURI);
+ OntModel ontModelForRange = ModelFactory.createOntologyModel(getOntModelSpec(false),
+ modelForRange);
+ OntClass ontClassForRange = ontModelForRange.getOntClass(rangeURI);
+
+ if (ontProperty != null && ontClassForRange != null) {
+ ontProperty.addRange(ontClassForRange);
+ persistenceProvider.commit(ontModelForProperty);
+ persistenceProvider.commit(ontModelForRange);
+ }
+ }
+ }
+ return true;
+ } catch (Exception e) {
+ logger.error("Error ", e);
+ }
+ return false;
+ }
+
+ public boolean deleteRange(String propertyURI, String rangeURI) {
+ try {
+ String ontologyForPropertyURI = resourceManager.resolveOntologyURIFromResourceURI(propertyURI);
+ Model modelForProperty = persistenceProvider.getModel(ontologyForPropertyURI);
+ OntModel ontModelForProperty = ModelFactory.createOntologyModel(getOntModelSpec(false),
+ modelForProperty);
+ OntProperty ontProperty = ontModelForProperty.getOntProperty(propertyURI);
+
+ String ontologyForRangeURI = resourceManager.resolveOntologyURIFromResourceURI(rangeURI);
+ if (ontologyForPropertyURI != null) {
+ if (JenaUtil.isBuiltInType(rangeURI)) {
+ Resource rangeResource = JenaUtil.getResourceForBuiltInType(rangeURI);
+ if (ontProperty != null && rangeResource != null) {
+ ontProperty.removeRange(rangeResource);
+ persistenceProvider.commit(ontModelForProperty);
+ }
+ } else if (ontologyForRangeURI != null) {
+ Model modelForRange = persistenceProvider.getModel(ontologyForRangeURI);
+ OntModel ontModelForRange = ModelFactory.createOntologyModel(getOntModelSpec(false),
+ modelForRange);
+ OntClass ontClassForRange = ontModelForRange.getOntClass(rangeURI);
+
+ if (ontProperty != null && ontClassForRange != null) {
+ ontProperty.removeRange(ontClassForRange);
+ persistenceProvider.commit(ontModelForProperty);
+ persistenceProvider.commit(ontModelForRange);
+ }
+ }
+ }
+ return true;
+ } catch (Exception e) {
+ logger.error("Error ", e);
+ }
+ return false;
+ }
+
+ public boolean makeSubPropertyOf(String subPropertyURI, String superPropertyURI) {
+ try {
+ String ontologyForSubPropertyURI = resourceManager
+ .resolveOntologyURIFromResourceURI(subPropertyURI);
+ String ontologyForSuperClassURI = resourceManager
+ .resolveOntologyURIFromResourceURI(superPropertyURI);
+ if (ontologyForSubPropertyURI != null && ontologyForSuperClassURI != null) {
+ Model modelForSubProperty = persistenceProvider.getModel(ontologyForSubPropertyURI);
+ OntModel ontModelForSubProperty = ModelFactory.createOntologyModel(getOntModelSpec(false),
+ modelForSubProperty);
+ OntProperty subProperty = ontModelForSubProperty.getOntProperty(subPropertyURI);
+
+ Model modelForSuperProperty = persistenceProvider.getModel(ontologyForSuperClassURI);
+ OntModel ontModelForSuperProperty = ModelFactory.createOntologyModel(getOntModelSpec(false),
+ modelForSuperProperty);
+ OntProperty superProperty = ontModelForSuperProperty.getOntProperty(superPropertyURI);
+
+ if (subProperty != null && superProperty != null) {
+ subProperty.addSuperProperty(superProperty);
+ superProperty.addSubProperty(subProperty);
+ persistenceProvider.commit(ontModelForSubProperty);
+ persistenceProvider.commit(ontModelForSuperProperty);
+ return true;
+ }
+ }
+ } catch (Exception e) {
+ logger.error("Error ", e);
+ }
+ return false;
+ }
+
+ public boolean deleteSuperPropertyAssertion(String subPropertyURI, String superPropertyURI) {
+ try {
+ String ontologyForSubPropertyURI = resourceManager
+ .resolveOntologyURIFromResourceURI(subPropertyURI);
+ String ontologyForSuperClassURI = resourceManager
+ .resolveOntologyURIFromResourceURI(superPropertyURI);
+ if (ontologyForSubPropertyURI != null && ontologyForSuperClassURI != null) {
+ Model modelForSubProperty = persistenceProvider.getModel(ontologyForSubPropertyURI);
+ OntModel ontModelForSubProperty = ModelFactory.createOntologyModel(getOntModelSpec(false),
+ modelForSubProperty);
+ OntProperty subProperty = ontModelForSubProperty.getOntProperty(subPropertyURI);
+
+ Model modelForSuperProperty = persistenceProvider.getModel(ontologyForSuperClassURI);
+ OntModel ontModelForSuperProperty = ModelFactory.createOntologyModel(getOntModelSpec(false),
+ modelForSuperProperty);
+ OntProperty superProperty = ontModelForSuperProperty.getOntProperty(superPropertyURI);
+
+ if (subProperty != null && superProperty != null) {
+ subProperty.removeSuperProperty(superProperty);
+ superProperty.removeSubProperty(subProperty);
+ persistenceProvider.commit(ontModelForSubProperty);
+ persistenceProvider.commit(ontModelForSuperProperty);
+ return true;
+ }
+ }
+ } catch (Exception e) {
+ logger.error("Error ", e);
+ }
+ return false;
+ }
+
+ public boolean setPropertyAttributes(String propertyURI,
+ Boolean isFunctional,
+ Boolean isTransitive,
+ Boolean isSymmetric,
+ Boolean isInverseFunctional) throws SQLException {
+ OntModel ontModelForProperty = null;
+ try {
+ String ontologyForPropertyURI = resourceManager.resolveOntologyURIFromResourceURI(propertyURI);
+ if (ontologyForPropertyURI != null) {
+ Model modelForProperty = persistenceProvider.getModel(ontologyForPropertyURI);
+ ontModelForProperty = ModelFactory.createOntologyModel(getOntModelSpec(false),
+ modelForProperty);
+ OntProperty property = ontModelForProperty.getOntProperty(propertyURI);
+ if (isFunctional != null && isFunctional.booleanValue()) {
+ property.convertToFunctionalProperty();
+ } else {
+ // FIXME:: check if fix works
+ List<Statement> stmts = ontModelForProperty.listStatements(property, RDF.type,
+ OWL.FunctionalProperty).toList();
+ ontModelForProperty.remove(stmts);
+ }
+ if (isTransitive != null && isTransitive.booleanValue()) {
+ property.convertToTransitiveProperty();
+ } else {
+ // FIXME:: check if fix works
+ List<Statement> stmts = ontModelForProperty.listStatements(property, RDF.type,
+ OWL.TransitiveProperty).toList();
+ ontModelForProperty.remove(stmts);
+
+ }
+ if (isSymmetric != null && isSymmetric.booleanValue()) {
+ property.convertToSymmetricProperty();
+ } else {
+ // FIXME:: check if fix works
+ List<Statement> stmts = ontModelForProperty.listStatements(property, RDF.type,
+ OWL.SymmetricProperty).toList();
+ ontModelForProperty.remove(stmts);
+ }
+ if (isInverseFunctional != null && isInverseFunctional.booleanValue()) {
+ property.convertToInverseFunctionalProperty();
+ } else {
+ // FIXME:: check if fix works
+ List<Statement> stmts = ontModelForProperty.listStatements(property, RDF.type,
+ OWL.InverseFunctionalProperty).toList();
+ ontModelForProperty.remove(stmts);
+ }
+ persistenceProvider.commit(ontModelForProperty);
+ return true;
+ }
+ } catch (Exception e) {
+ logger.error("Error ", e);
+ }
+ return false;
+
+ }
+
+ public boolean assertPropertyValue(String individualURI,
+ String propertyURI,
+ String individualAsValueURI,
+ String literalAsValue) {
+ try {
+ String ontologyFor_arg0 = resourceManager.resolveOntologyURIFromResourceURI(individualURI);
+ String ontologyFor_arg1 = resourceManager.resolveOntologyURIFromResourceURI(propertyURI);
+
+ if (ontologyFor_arg0 != null && ontologyFor_arg1 != null) {
+ Model modelForIndividual = persistenceProvider.getModel(ontologyFor_arg0);
+ OntModel ontModelForIndividual = ModelFactory.createOntologyModel(getOntModelSpec(false),
+ modelForIndividual);
+ Individual individual = ontModelForIndividual.getIndividual(individualURI);
+
+ Model modelForProperty = persistenceProvider.getModel(ontologyFor_arg1);
+ OntModel ontModelForProperty = ModelFactory.createOntologyModel(getOntModelSpec(false),
+ modelForProperty);
+ OntProperty ontProperty = ontModelForProperty.getOntProperty(propertyURI);
+
+ if (individualAsValueURI != null) {
+ // System.out.println("individualAsValueURI==="
+ // + individualAsValueURI);
+ String ontologyFor_arg2 = resourceManager
+ .resolveOntologyURIFromResourceURI(individualAsValueURI);
+ if (ontologyFor_arg2 != null) {
+ Model modelForValue = persistenceProvider.getModel(ontologyFor_arg2);
+ OntModel ontModelForValue = ModelFactory.createOntologyModel(getOntModelSpec(false),
+ modelForValue);
+ Individual value = ontModelForValue.getIndividual(individualAsValueURI);
+ individual.addProperty(ontProperty, value);
+ persistenceProvider.commit(ontModelForIndividual);
+ persistenceProvider.commit(ontModelForProperty);
+ persistenceProvider.commit(ontModelForValue);
+ return true;
+ }
+ } else if (literalAsValue != null) {
+ Literal literal = ontModelForIndividual.createLiteral(literalAsValue);
+ individual.addProperty(ontProperty, literal);
+ persistenceProvider.commit(ontModelForIndividual);
+ persistenceProvider.commit(ontModelForProperty);
+ return true;
+ }
+ }
+ } catch (Exception e) {
+ logger.error("Error ", e);
+ }
+ return false;
+ }
+
+ public boolean deletePropertyAssertion(String individualURI,
+ String propertyURI,
+ String individualAsValueURI,
+ String literalAsValue) {
+ try {
+ String ontologyFor_arg0 = resourceManager.resolveOntologyURIFromResourceURI(individualURI);
+ String ontologyFor_arg1 = resourceManager.resolveOntologyURIFromResourceURI(propertyURI);
+
+ if (ontologyFor_arg0 != null && ontologyFor_arg1 != null) {
+ Model modelForIndividual = persistenceProvider.getModel(ontologyFor_arg0);
+ OntModel ontModelForIndividual = ModelFactory.createOntologyModel(getOntModelSpec(false),
+ modelForIndividual);
+ Individual individual = ontModelForIndividual.getIndividual(individualURI);
+
+ Model modelForProperty = persistenceProvider.getModel(ontologyFor_arg1);
+ OntModel ontModelForProperty = ModelFactory.createOntologyModel(getOntModelSpec(false),
+ modelForProperty);
+ OntProperty ontProperty = ontModelForProperty.getOntProperty(propertyURI);
+
+ if (individualAsValueURI != null) {
+ String ontologyFor_arg2 = resourceManager
+ .resolveOntologyURIFromResourceURI(individualAsValueURI);
+ if (ontologyFor_arg2 != null) {
+ Model modelForValue = persistenceProvider.getModel(ontologyFor_arg2);
+ OntModel ontModelForValue = ModelFactory.createOntologyModel(getOntModelSpec(false),
+ modelForValue);
+ Individual value = ontModelForValue.getIndividual(individualAsValueURI);
+ individual.removeProperty(ontProperty, value);
+ persistenceProvider.commit(ontModelForIndividual);
+ persistenceProvider.commit(ontModelForProperty);
+ persistenceProvider.commit(ontModelForValue);
+ return true;
+ }
+ } else if (literalAsValue != null) {
+ Literal literal = ontModelForIndividual.createLiteral(literalAsValue);
+ individual.removeProperty(ontProperty, literal);
+ persistenceProvider.commit(ontModelForIndividual);
+ persistenceProvider.commit(ontModelForProperty);
+ return true;
+ }
+ }
+ } catch (Exception e) {
+ logger.error("Error ", e);
+ }
+ return false;
+ }
+
+ public boolean addContainerClassForIndividual(String individualURI, String classURI) {
+ try {
+
+ String ontologyForIndividual = resourceManager.resolveOntologyURIFromResourceURI(individualURI);
+ String ontologyForClass = resourceManager.resolveOntologyURIFromResourceURI(classURI);
+
+ if (ontologyForIndividual != null && ontologyForClass != null) {
+ Model modelForIndividual = persistenceProvider.getModel(ontologyForIndividual);
+ OntModel ontModelForIndividual = ModelFactory.createOntologyModel(getOntModelSpec(false),
+ modelForIndividual);
+ Individual individual = ontModelForIndividual.getIndividual(individualURI);
+
+ Model modelForClass = persistenceProvider.getModel(ontologyForClass);
+ OntModel ontModelForClass = ModelFactory.createOntologyModel(getOntModelSpec(false),
+ modelForClass);
+ OntClass ontClass = ontModelForClass.getOntClass(classURI);
+
+ individual.addOntClass(ontClass);
+ persistenceProvider.commit(ontModelForClass);
+ persistenceProvider.commit(ontModelForIndividual);
+ return true;
+ }
+ } catch (Exception e) {
+ logger.error("Error ", e);
+ }
+ return false;
+ }
+
+ public boolean deleteContainerClassForIndividual(String individualURI, String classURI) {
+ try {
+ String ontologyForIndividual = resourceManager.resolveOntologyURIFromResourceURI(individualURI);
+ String ontologyForClass = resourceManager.resolveOntologyURIFromResourceURI(classURI);
+ if (ontologyForIndividual != null && ontologyForClass != null) {
+ Model modelForIndividual = persistenceProvider.getModel(ontologyForIndividual);
+ OntModel ontModelForIndividual = ModelFactory.createOntologyModel(getOntModelSpec(false),
+ modelForIndividual);
+ Individual individual = ontModelForIndividual.getIndividual(individualURI);
+
+ Model modelForClass = persistenceProvider.getModel(ontologyForClass);
+ OntModel ontModelForClass = ModelFactory.createOntologyModel(getOntModelSpec(false),
+ modelForClass);
+ OntClass ontClass = ontModelForClass.getOntClass(classURI);
+
+ individual.removeOntClass(ontClass);
+ persistenceProvider.commit(ontModelForClass);
+ persistenceProvider.commit(ontModelForIndividual);
+ return true;
+ }
+ } catch (Exception e) {
+ logger.error("Error ", e);
+ }
+ return false;
+ }
+
+ public IndividualMetaInformation generateIndividualForOntology(String ontologyURI,
+ String classURI,
+ String individualURI) {
+ try {
+
+ if (persistenceProvider.hasModel(ontologyURI)) {
+ Model baseModel = persistenceProvider.getModel(ontologyURI);
+ OntModel ontModel = ModelFactory.createOntologyModel(getOntModelSpec(false), baseModel);
+ Individual individualForURI = ontModel.getIndividual(individualURI);
+ OntClass ontClassForURI = ontModel.getOntClass(classURI);
+ if (individualForURI == null && ontClassForURI != null) {
+
+ ontModel.createIndividual(individualURI, ontClassForURI);
+ resourceManager.registerIndividual(ontologyURI, individualURI);
+ persistenceProvider.commit(ontModel);
+ return generateIndividualMetaInformation(individualURI);
+ }
+ }
+ } catch (Exception e) {
+ logger.error("Error ", e);
+ }
+ return null;
+ }
+
+ public OntologyMetaInformation retrieveOntologyMetaInformation(String ontologyURI) {
+
+ if (ontologyURI != null) {
+ ObjectFactory objectFactory = new ObjectFactory();
+ OntologyMetaInformation ontologyMetaInformation = objectFactory.createOntologyMetaInformation();
+ ontologyMetaInformation.setURI(ontologyURI);
+ ontologyMetaInformation.setHref(resourceManager.getOntologyFullPath(ontologyURI));
+ /** FIXME: Descriptions have to be administerable **/
+ ontologyMetaInformation.setDescription("");
+ return ontologyMetaInformation;
+ } else {
+ return null;
+ }
+ }
+
+ public ClassesForOntology retrieveClassesOfOntology(String ontologyURI) {
+
+ try {
+ if (persistenceProvider.hasModel(ontologyURI)) {
+ ObjectFactory objectFactory = new ObjectFactory();
+
+ ClassesForOntology classesForOntology = objectFactory.createClassesForOntology();
+ classesForOntology.setOntologyMetaInformation(retrieveOntologyMetaInformation(ontologyURI));
+
+ Model baseModel = persistenceProvider.getModel(ontologyURI);
+ OntModel ontModel = ModelFactory.createOntologyModel(getOntModelSpec(false), baseModel);
+ ExtendedIterator ontClassesItr = ontModel.listClasses();
+ while (ontClassesItr.hasNext()) {
+ OntClass curOntClass = (OntClass) ontClassesItr.next();
+ if (curOntClass.getURI() != null) {
+ ClassMetaInformation classMetaInformation = generateClassMetaInformation(curOntClass
+ .getURI());
+ if (classMetaInformation != null) classesForOntology.getClassMetaInformation().add(
+ classMetaInformation);
+ } else {
+
+ }
+ }
+ return classesForOntology;
+ }
+ } catch (Exception e) {
+ logger.error("Error ", e);
+ } finally {
+
+ }
+ return null;
+ }
+
+ public DatatypePropertiesForOntology retrieveDatatypePropertiesOfOntology(String ontologyURI) {
+
+ try {
+ if (persistenceProvider.hasModel(ontologyURI)) {
+ ObjectFactory objectFactory = new ObjectFactory();
+
+ DatatypePropertiesForOntology datatypePropertiesForOntology = objectFactory
+ .createDatatypePropertiesForOntology();
+ datatypePropertiesForOntology
+ .setOntologyMetaInformation(retrieveOntologyMetaInformation(ontologyURI));
+
+ Model baseModel = persistenceProvider.getModel(ontologyURI);
+ OntModel ontModel = ModelFactory.createOntologyModel(getOntModelSpec(false), baseModel);
+ ExtendedIterator ontDatatypePropertiesItr = ontModel.listDatatypeProperties();
+ while (ontDatatypePropertiesItr.hasNext()) {
+ DatatypeProperty curDatatypeProperty = (DatatypeProperty) ontDatatypePropertiesItr.next();
+ if (curDatatypeProperty.getURI() != null) {
+ PropertyMetaInformation datatypePropertyMetaInformation = generatePropertyMetaInformation(curDatatypeProperty
+ .getURI());
+ datatypePropertiesForOntology.getPropertyMetaInformation().add(
+ datatypePropertyMetaInformation);
+ }
+ }
+ return datatypePropertiesForOntology;
+ }
+ } catch (Exception e) {
+ logger.error("Error ", e);
+ } finally {
+
+ }
+ return null;
+ }
+
+ public ObjectPropertiesForOntology retrieveObjectPropertiesOfOntology(String ontologyURI) {
+
+ try {
+ if (persistenceProvider.hasModel(ontologyURI)) {
+ ObjectFactory objectFactory = new ObjectFactory();
+
+ ObjectPropertiesForOntology objectPropertiesForOntology = objectFactory
+ .createObjectPropertiesForOntology();
+ objectPropertiesForOntology
+ .setOntologyMetaInformation(retrieveOntologyMetaInformation(ontologyURI));
+
+ Model baseModel = persistenceProvider.getModel(ontologyURI);
+ OntModel ontModel = ModelFactory.createOntologyModel(getOntModelSpec(false), baseModel);
+ ExtendedIterator ontObjectPropertiesItr = ontModel.listObjectProperties();
+ while (ontObjectPropertiesItr.hasNext()) {
+ ObjectProperty curObjectProperty = (ObjectProperty) ontObjectPropertiesItr.next();
+ if (curObjectProperty.getURI() != null) {
+ PropertyMetaInformation propertyMetaInformation = generatePropertyMetaInformation(curObjectProperty
+ .getURI());
+ if (propertyMetaInformation != null) {
+ objectPropertiesForOntology.getPropertyMetaInformation().add(
+ propertyMetaInformation);
+ }
+ }
+ }
+ return objectPropertiesForOntology;
+ }
+ } catch (Exception e) {
+ logger.error("Error ", e);
+ } finally {
+
+ }
+ return null;
+ }
+
+ public IndividualsForOntology retrieveIndividualsOfOntology(String ontologyURI) {
+
+ try {
+ if (persistenceProvider.hasModel(ontologyURI)) {
+ ObjectFactory objectFactory = new ObjectFactory();
+
+ IndividualsForOntology individualsForOntology = objectFactory.createIndividualsForOntology();
+ individualsForOntology
+ .setOntologyMetaInformation(retrieveOntologyMetaInformation(ontologyURI));
+
+ Model baseModel = persistenceProvider.getModel(ontologyURI);
+ OntModel ontModel = ModelFactory.createOntologyModel(getOntModelSpec(false), baseModel);
+ ExtendedIterator ontIndividualsItr = ontModel.listIndividuals();
+ while (ontIndividualsItr.hasNext()) {
+ Individual individual = (Individual) ontIndividualsItr.next();
+ if (individual.getURI() != null) {
+ IndividualMetaInformation individualMetaInformation = generateIndividualMetaInformation(individual
+ .getURI());
+ individualsForOntology.getIndividualMetaInformation().add(individualMetaInformation);
+ }
+ }
+ return individualsForOntology;
+ }
+ } catch (Exception e) {
+ logger.error("Error ", e);
+ } finally {
+
+ }
+ return null;
+ }
+
+ public boolean deleteOntology(String ontologyURI) {
+
+ try {
+ if (resourceManager.hasOntology(ontologyURI)) {
+ persistenceProvider.removeModel(ontologyURI);
+ resourceManager.removeOntology(ontologyURI);
+
+ return true;
+ }
+ } catch (Exception e) {
+ logger.error("Error ", e);
+ } finally {
+
+ }
+ return false;
+ }
+
+ public boolean deleteResource(String resourceURI) {
+ OntModel ontModel = null;
+ try {
+ String ontologyURI = resourceManager.resolveOntologyURIFromResourceURI(resourceURI);
+ if (resourceURI != null && ontologyURI != null) {
+ Model baseModel = persistenceProvider.getModel(ontologyURI);
+ ontModel = ModelFactory.createOntologyModel(getOntModelSpec(false), baseModel);
+ OntResource ontResource = ontModel.getOntResource(resourceURI);
+ if (ontResource != null) {
+ ontResource.remove();
+ OntResource xCheck = ontModel.getOntResource(resourceURI);
+ if (xCheck == null) {
+ resourceManager.removeResource(resourceURI);
+ return true;
+ }
+ }
+ }
+ } catch (Exception e) {
+ logger.error("Error ", e);
+ } finally {
+ persistenceProvider.commit(ontModel);
+ }
+ return false;
+ }
+
+ public ClassContext generateClassContext(String classURI, boolean withInferredAxioms) {
+
+ try {
+ ObjectFactory objectFactory = new ObjectFactory();
+ String ontologyURI = resourceManager.resolveOntologyURIFromResourceURI(classURI);
+ Model baseModel = persistenceProvider.getModel(ontologyURI);
+ OntModel ontModel = ModelFactory.createOntologyModel(getOntModelSpec(withInferredAxioms),
+ baseModel);
+ OntClass ontClass = ontModel.getOntClass(classURI);
+ if (this.useReasoner && withInferredAxioms) {
+ OWLOntology ontology = jenaToOWlApi(ontModel);
+ OWLlinkHTTPXMLReasoner reasoner = getOWLLinkReasoner(ontology);
+ OWLDataFactory factory = ontology.getOWLOntologyManager().getOWLDataFactory();
+ IRI classIRI = IRI.create(classURI);
+ OWLClass owlClass = factory.getOWLClass(classIRI);
+ if (ontology.containsClassInSignature(classIRI)) {
+ ClassContext classContext = objectFactory.createClassContext();
+ classContext.setClassMetaInformation(generateClassMetaInformation(classURI));
+
+ // EquivalentClasses
+ EquivalentClasses equivalentClasses = generateEquivalentClasses(objectFactory, owlClass,
+ reasoner);
+ classContext.setEquivalentClasses(equivalentClasses);
+
+ // Superclasses
+ Superclasses superclasses = generateSuperClasses(objectFactory, owlClass, reasoner);
+ classContext.setSuperclasses(superclasses);
+
+ // Disjoint Classes
+ DisjointClasses disjointClasses = generateDisjointClasses(objectFactory, owlClass,
+ reasoner);
+ classContext.setDisjointClasses(disjointClasses);
+ classContext.getClassConstraint().addAll(resolveOntClass(ontClass));
+
+ // Class Constraints
+ reasoner.answer(new ReleaseKB(reasoner.getDefaultKB()));
+ return classContext;
+ }
+ } else {
+ if (ontClass.getURI() != null) {
+ ClassContext classContext = objectFactory.createClassContext();
+ classContext.setClassMetaInformation(generateClassMetaInformation(classURI));
+
+ // EquivalentClasses
+ EquivalentClasses equivalentClasses = generateEquivalentClasses(objectFactory, ontClass);
+ classContext.setEquivalentClasses(equivalentClasses);
+
+ // Superclasses
+ Superclasses superclasses = generateSuperClasses(objectFactory, ontClass);
+ classContext.setSuperclasses(superclasses);
+
+ // DisjointClasses
+ DisjointClasses disjointClasses = generateDisjointClasses(objectFactory, ontClass);
+
+ classContext.setDisjointClasses(disjointClasses);
+ classContext.getClassConstraint().addAll(resolveOntClass(ontClass));
+ return classContext;
+ }
+ }
+ } catch (Exception e) {
+ logger.error("Error ", e);
+ }
+ return null;
+ }
+
+ private Superclasses generateSuperClasses(ObjectFactory objectFactory,
+ OWLClass owlClass,
+ OWLReasoner reasoner) {
+ Superclasses superclasses = objectFactory.createSuperclasses();
+ Set<OWLClass> supClases = reasoner.getSuperClasses(owlClass, false).getFlattened();
+ for (OWLClass klazz : supClases) {
+ ClassMetaInformation classMetaInformation = generateClassMetaInformation(klazz.getIRI()
+ .toString());
+ if (classMetaInformation != null) superclasses.getClassMetaInformation()
+ .add(classMetaInformation);
+ }
+ return superclasses;
+ }
+
+ private Superclasses generateSuperClasses(ObjectFactory objectFactory, OntClass ontClass) {
+ Superclasses superclasses = objectFactory.createSuperclasses();
+ ExtendedIterator superClassesItr = ontClass.listSuperClasses();
+ while (superClassesItr.hasNext()) {
+ OntClass curClass = (OntClass) superClassesItr.next();
+ String curClass_classURI = curClass.getURI();
+ if (curClass_classURI != null) {
+ ClassMetaInformation classMetaInformation = generateClassMetaInformation(curClass_classURI);
+ if (classMetaInformation != null) {
+ superclasses.getClassMetaInformation().add(classMetaInformation);
+ }
+ } else {
+ logger.debug("super class without uri, localName=" + curClass.getLocalName());
+ }
+ }
+ return superclasses;
+ }
+
+ private EquivalentClasses generateEquivalentClasses(ObjectFactory objectFactory, OntClass ontClass) {
+ EquivalentClasses equivalentClasses = objectFactory.createEquivalentClasses();
+ ExtendedIterator equivalentClassesItr = ontClass.listEquivalentClasses();
+ while (equivalentClassesItr.hasNext()) {
+ OntClass curClass = (OntClass) equivalentClassesItr.next();
+ String curClass_classURI = curClass.getURI();
+ if (curClass_classURI != null) {
+ ClassMetaInformation classMetaInformation = generateClassMetaInformation(curClass_classURI);
+ equivalentClasses.getClassMetaInformation().add(classMetaInformation);
+ } else {
+ logger.debug("equivalent class without uri, localName=" + curClass.getLocalName());
+ }
+ }
+ return equivalentClasses;
+ }
+
+ private EquivalentClasses generateEquivalentClasses(ObjectFactory objectFactory,
+ OWLClass owlClass,
+ OWLReasoner reasoner) {
+ EquivalentClasses equivalentClasses = objectFactory.createEquivalentClasses();
+ Set<OWLClass> eqClasses = reasoner.getEquivalentClasses(owlClass).getEntities();
+ for (OWLClass klazz : eqClasses) {
+ ClassMetaInformation classMetaInformation = generateClassMetaInformation(klazz.getIRI()
+ .toString());
+ if (classMetaInformation != null) {
+ equivalentClasses.getClassMetaInformation().add(classMetaInformation);
+ }
+ }
+ return equivalentClasses;
+ }
+
+ private DisjointClasses generateDisjointClasses(ObjectFactory objectFactory, OntClass ontClass) {
+ DisjointClasses disjointClasses = objectFactory.createDisjointClasses();
+ ExtendedIterator disjointClassesItr = ontClass.listDisjointWith();
+ while (disjointClassesItr.hasNext()) {
+ OntClass curClass = (OntClass) disjointClassesItr.next();
+ String curClass_classURI = curClass.getURI();
+ if (curClass_classURI != null) {
+ ClassMetaInformation classMetaInformation = generateClassMetaInformation(curClass_classURI);
+ if (classMetaInformation != null) {
+ disjointClasses.getClassMetaInformation().add(classMetaInformation);
+ }
+ } else {
+ logger.debug("disjoint class without uri, localName=" + curClass.getLocalName());
+ }
+ }
+ return disjointClasses;
+ }
+
+ private DisjointClasses generateDisjointClasses(ObjectFactory objectFactory,
+ OWLClass owlClass,
+ OWLReasoner reasoner) {
+ DisjointClasses disjointClasses = objectFactory.createDisjointClasses();
+ Set<OWLClass> disjClasses = reasoner.getDisjointClasses(owlClass, false).getFlattened();
+ for (OWLClass klazz : disjClasses) {
+ ClassMetaInformation classMetaInformation = generateClassMetaInformation(klazz.getIRI()
+ .toString());
+ // FIXME URI of OWLNothing is not resolved to any ontologyURI
+ if (classMetaInformation != null) {
+ disjointClasses.getClassMetaInformation().add(classMetaInformation);
+ }
+ }
+ return disjointClasses;
+ }
+
+ public IndividualContext generateIndividualContext(String individualURI, boolean withInferredAxioms) {
+
+ try {
+ ObjectFactory objectFactory = new ObjectFactory();
+ String ontologyURI = resourceManager.resolveOntologyURIFromResourceURI(individualURI);
+ Model baseModel = persistenceProvider.getModel(ontologyURI);
+ OntModel ontModel = ModelFactory.createOntologyModel(getOntModelSpec(withInferredAxioms),
+ baseModel);
+
+ Individual individual = ontModel.getIndividual(individualURI);
+ IndividualContext individualContext = objectFactory.createIndividualContext();
+ if (this.useReasoner && withInferredAxioms) {
+ OWLOntology ontology = jenaToOWlApi(ontModel);
+ OWLlinkHTTPXMLReasoner reasoner = getOWLLinkReasoner(ontology);
+ OWLDataFactory factory = ontology.getOWLOntologyManager().getOWLDataFactory();
+ IRI individualIRI = IRI.create(individualURI);
+ if (ontology.containsIndividualInSignature(individualIRI)) {
+ OWLNamedIndividual owlIndividual = factory.getOWLNamedIndividual(individualIRI);
+ // Container Classes
+ ContainerClasses containerClasses = generateContainerClasses(objectFactory,
+ owlIndividual, reasoner);
+ individualContext.setContainerClasses(containerClasses);
+
+ // Property Assertions
+ PropertyAssertions propertyAssertions = generatePropertyAssertions(objectFactory,
+ ontology, owlIndividual, reasoner);
+ individualContext.setPropertyAssertions(propertyAssertions);
+ reasoner.answer(new ReleaseKB(reasoner.getDefaultKB()));
+ reasoner = null;
+ return individualContext;
+ }
+ reasoner.answer(new ReleaseKB(reasoner.getDefaultKB()));
+ reasoner = null;
+ }
+ if (individual.getURI() != null) {
+
+ individualContext
+ .setIndividualMetaInformation(generateIndividualMetaInformation(individualURI));
+
+ // Container Classes
+ ContainerClasses containerClasses = generateContainerClasses(objectFactory, individual);
+ individualContext.setContainerClasses(containerClasses);
+
+ // Property Assertions
+ PropertyAssertions propertyAssertions = generatePropertyAssertions(objectFactory, individual);
+ individualContext.setPropertyAssertions(propertyAssertions);
+ return individualContext;
+ }
+ } catch (Exception e) {
+ logger.error("Error ", e);
+ } finally {
+
+ }
+ return null;
+ }
+
+ private ContainerClasses generateContainerClasses(ObjectFactory objectFactory, Individual individual) {
+ ContainerClasses containerClasses = objectFactory.createContainerClasses();
+ ExtendedIterator containerOntClassesItr = individual.listOntClasses(false);
+ while (containerOntClassesItr.hasNext()) {
+ try {
+ Object obj = containerOntClassesItr.next();
+ OntClass curClass = (OntClass) obj;
+ String curClass_classURI = curClass.getURI();
+ if (curClass_classURI != null) {
[... 1480 lines stripped ...]