/*
* Created on Dec 12, 2004
*/
package impl.jena;
import java.io.FileNotFoundException;
import java.io.InputStream;
import java.io.Reader;
import java.net.URI;
import java.net.URISyntaxException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.TreeSet;
import org.mindswap.owl.OWLClass;
import org.mindswap.owl.OWLDataProperty;
import org.mindswap.owl.OWLDataValue;
import org.mindswap.owl.OWLFactory;
import org.mindswap.owl.OWLIndividual;
import org.mindswap.owl.OWLIndividualList;
import org.mindswap.owl.OWLKnowledgeBase;
import org.mindswap.owl.OWLObjectProperty;
import org.mindswap.owl.OWLOntology;
import org.mindswap.owl.OWLProperty;
import org.mindswap.owl.OWLReader;
import org.mindswap.owl.OWLValue;
import org.mindswap.owls.OWLSFactory;
import org.mindswap.owls.OWLSVersionTranslator;
import org.mindswap.owls.process.BindingList;
import org.mindswap.owls.process.Parameter;
import org.mindswap.owls.service.Service;
import org.mindswap.owls.vocabulary.OWLS;
import org.mindswap.utils.QNameProvider;
import org.mindswap.utils.URIUtils;
import com.hp.hpl.jena.ontology.OntModel;
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.Property;
import com.hp.hpl.jena.rdf.model.Resource;
/**
* @author Evren Sirin
*/
public class OWLKnowledgeBaseImpl extends OWLModelImpl implements OWLKnowledgeBase, org.mindswap.owls.OWLSKnowledgeBase {
protected Set ontologies;
private Map uriMap;
// private Map modelMap;
private Map importDependencies;
protected Set notImported;
protected OWLReader reader;
private QNameProvider qnames;
private boolean autoConsistency;
private OWLSVersionTranslator translator;
private OWLKnowledgeBase translationSource;
public OWLKnowledgeBaseImpl() {
super( ModelFactory.createDefaultModel() );
setAutoTranslate( false );
translationSource = this;
ontologies = new HashSet();
uriMap = new HashMap();
// modelMap = new HashMap();
importDependencies = new HashMap();
notImported = new HashSet();
reader = OWLFactory.createReader();
qnames = new QNameProvider();
autoConsistency = false;
createBaseOntology();
}
protected void createBaseOntology() {
URI uri = URI.create("urn:owl-s-api:baseOntology");
Model model = getOntModel().getBaseModel();
OWLOntology ontology = createOntologyWithoutLoading( uri, null, model);
ontologies.add(ontology);
setBaseOntology(ontology);
}
public Set getOntologies() {
return getOntologies( true );
}
public Set getOntologies( boolean all ) {
if( all )
return new HashSet( ontologies );
else
return new HashSet( notImported );
}
public OWLOntology getOntology(URI uri) {
return (OWLOntology) uriMap.get(uri);
}
public OWLOntology createOntology(boolean load) {
if( load )
return createOntology();
else
return new OWLOntologyImpl(this, null, null, ModelFactory.createDefaultModel());
}
public OWLOntology createOntology() {
return createOntology(null, null, ModelFactory.createDefaultModel());
}
public OWLOntology createOntology(URI uri) {
return createOntology(uri, null, ModelFactory.createDefaultModel());
}
public OWLOntology createOntology(URI uri, URI fileURI) {
return createOntology(uri, fileURI, ModelFactory.createDefaultModel());
}
public OWLOntology createOntology(URI uri, URI fileURI, Object implementation) {
OWLOntology ont = createOntologyWithoutLoading(uri, fileURI, (Model) implementation);
return load(ont);
}
protected OWLOntology createOntologyWithoutLoading(URI uri, URI fileURI, Model model) {
OWLOntology ont = new OWLOntologyImpl(this, uri, fileURI, model);
return ont;
}
public OWLOntology loadOntology(OWLOntology ont) {
return load(ont);
}
public OWLOntology load(OWLOntology ont) {
return load( ont, true );
}
public OWLOntology load(OWLOntology ont, boolean withImports) {
OWLOntology loadedOnt = internalLoad( ont, withImports );
notImported.add( loadedOnt );
if( getAutoConsistency() ) {
if(!isConsistent()) {
System.err.println(
"WARNING: Rejecting to load " + ont + " " +
"which causes the KB to be inconsistent!");
unload( loadedOnt );
loadedOnt = null;
}
}
// System.out.println( "Loaded " + this + " " + reasoner + " " + ont + " " + ontologies.size());
// ontModel.write(System.out, "RDF/XML-ABBREV");
return loadedOnt;
}
protected OWLOntology internalLoad(OWLOntology ont, boolean withImports) {
OWLOntology loadedOnt = ont;
URI uri = loadedOnt.getURI();
if(uri != null && uriMap.containsKey(uri))
return (OWLOntology) uriMap.get(uri);
if(getAutoTranslate()) {
loadedOnt = translator.translate( ont );
if(translationSource == this) {
translationSource = OWLFactory.createKB();
translationSource.setAutoTranslate(false);
}
translationSource.load( loadedOnt.getTranslationSource() );
}
Model model = ((OntModel) loadedOnt.getImplementation()).getBaseModel();
loadedOnt = createOntologyWithoutLoading(uri, loadedOnt.getFileURI(), model);
if(uri != null)
uriMap.put(uri, loadedOnt);
ontologies.add(loadedOnt);
ontModel.addSubModel(model);
// modelMap.put(model, loadedOnt);
if(withImports) {
for(Iterator i = ont.getImports().iterator(); i.hasNext(); ) {
OWLOntology imported = (OWLOntology) i.next();
OWLOntology loadedImport = internalLoad(imported, withImports);
loadedOnt.addImport(loadedImport);
if( !notImported.contains( loadedImport ) ) {
Set importees = (Set) importDependencies.get( loadedImport );
if( importees == null ) {
importees = new HashSet();
importDependencies.put( loadedImport, importees );
}
importees.add( loadedOnt );
}
}
}
return loadedOnt;
}
public void unload(URI uri) {
uri = URIUtils.standardURI( uri );
OWLOntology ont = getOntology( uri );
if(ont != null) {
unload( ont );
}
else
System.out.println("Ontology " + uri + " not found in KB");
}
public void unload( OWLOntology ontology ) {
URI uri = ontology.getURI();
boolean removed = ontologies.remove( ontology );
if( !removed ) {
String msg = ontology + " is not in the KB";
if( uri != null && uriMap.containsKey( uri ) )
msg += " but there is another ontology with the same URI in the KB";
msg += "!";
throw new IllegalArgumentException( msg );
}
if(uri != null)
uriMap.remove( uri );
notImported.remove( ontology );
Model m = ((OntModel) ontology.getImplementation()).getBaseModel();
ontModel.removeSubModel(m);
// modelMap.remove( m );
for(Iterator i = ontology.getImports().iterator(); i.hasNext(); ) {
OWLOntology importOnt = (OWLOntology) i.next();
Set importees = (Set) importDependencies.get( importOnt );
if( importees != null ) {
importees.remove( ontology );
if( importees.isEmpty() ) {
importDependencies.remove( importOnt );
unload( importOnt );
}
}
}
}
public OWLOntology read(String uri) throws FileNotFoundException, URISyntaxException {
return reader.read(this, new URI(uri));
}
public OWLOntology read(URI uri) throws FileNotFoundException {
return reader.read(this, uri);
}
public OWLOntology read(Reader in, URI baseURI) {
return reader.read(this, in, baseURI);
}
public OWLOntology read(InputStream in, URI baseURI) {
return reader.read(this, in, baseURI);
}
public OWLReader getReader() {
return reader;
}
public QNameProvider getQNames() {
return qnames;
}
protected OWLDataValue wrapDataValue(Literal l, OWLOntology ont) {
return new OWLDataValueImpl(l);
}
protected OWLIndividual wrapIndividual(Resource r, OWLOntology ont) {
if( ont != null && ((OntModel) ont.getImplementation()).containsResource(r))
return new OWLIndividualImpl(ont, r);
for(Iterator i = ontologies.iterator(); i.hasNext(); ) {
ont = (OWLOntology) i.next();
if(((OntModel) ont.getImplementation()).containsResource(r))
return new OWLIndividualImpl(ont, r);
}
return new OWLIndividualImpl(baseOntology, r);
}
protected OWLClass wrapClass(Resource r, OWLOntology ont) {
// OWLOntology ont = (OWLOntology) modelMap.get(r.getModel());
if(ont == null)
ont = baseOntology;
return new OWLClassImpl(ont, r);
}
protected OWLObjectProperty wrapObjectProperty(Property p, OWLOntology ont) {
// OWLOntology ont = (OWLOntology) modelMap.get(p.getModel());
if(ont == null)
ont = baseOntology;
return new OWLObjectPropertyImpl(ont, p);
}
protected OWLDataProperty wrapDataProperty(Property p, OWLOntology ont) {
// OWLOntology ont = (OWLOntology) modelMap.get(p.getModel());
if(ont == null)
ont = baseOntology;
return new OWLDataPropertyImpl(ont, p);
}
public OWLClass createClass(URI uri) {
return baseOntology.createClass(uri);
}
public OWLObjectProperty createObjectProperty(URI uri) {
return baseOntology.createObjectProperty(uri);
}
public OWLDataProperty createDataProperty(URI uri) {
return baseOntology.createDataProperty(uri);
}
public OWLIndividual createIndividual(URI uri) {
return baseOntology.createIndividual(uri);
}
public OWLIndividual createInstance(OWLClass c) {
return baseOntology.createInstance(c);
}
public OWLIndividual createInstance(OWLClass c, URI uri) {
return baseOntology.createInstance(c, uri);
}
public OWLDataValue createDataValue(String value) {
return baseOntology.createDataValue(value);
}
public OWLDataValue createDataValue(String value, String language) {
return baseOntology.createDataValue(value, language);
}
public OWLDataValue createDataValue(Object value, URI datatypeURI) {
return baseOntology.createDataValue(value, datatypeURI);
}
public OWLDataValue createDataValue(Object value) {
return baseOntology.createDataValue(value);
}
public void setReader(OWLReader reader) {
this.reader = reader;
}
public void refresh() {
ontModel.rebind();
}
public void setProperty(OWLIndividual ind, OWLDataProperty prop, String value) {
baseOntology.setProperty(ind, prop, value);
}
public void setProperty(OWLIndividual ind, OWLDataProperty prop, Object value) {
baseOntology.setProperty(ind, prop, value);
}
public void setProperty(OWLIndividual ind, OWLDataProperty prop, OWLDataValue value) {
baseOntology.setProperty(ind, prop, value);
}
public void addProperty(OWLIndividual ind, OWLProperty prop, OWLValue value) {
baseOntology.addProperty(ind, prop, value);
}
public void addProperty(OWLIndividual ind, OWLDataProperty prop, OWLDataValue value) {
baseOntology.addProperty(ind, prop, value);
}
public void addProperty(OWLIndividual ind, OWLDataProperty prop, String value) {
baseOntology.addProperty(ind, prop, value);
}
public void addProperty(OWLIndividual ind, OWLDataProperty prop, Object value) {
baseOntology.addProperty(ind, prop, value);
}
public void removeProperties(OWLIndividual ind, OWLProperty prop) {
baseOntology.removeProperties(ind, prop);
}
public void removeProperty(OWLIndividual theInd, OWLProperty theProp, OWLValue theValue) {
baseOntology.removeProperty(theInd,theProp,theValue);
}
public void addProperty(OWLIndividual ind, OWLObjectProperty prop, OWLIndividual value) {
baseOntology.addProperty(ind, prop, value);
}
public void setProperty(OWLIndividual ind, OWLObjectProperty prop, OWLIndividual value) {
baseOntology.setProperty(ind, prop, value);
}
public void addType(OWLIndividual ind, OWLClass c) {
baseOntology.addType(ind, c);
}
public void removeTypes(OWLIndividual ind) {
baseOntology.removeTypes(ind);
}
public void removeIndividuals(OWLIndividual ind) {
baseOntology.removeIndividuals(ind);
}
public void removeIndividuals(OWLIndividual ind, boolean recursive) {
baseOntology.removeIndividuals(ind, recursive);
}
/* (non-Javadoc)
* @see org.mindswap.owl.OWLKnowledgeBase#getAutoConsistency()
*/
public boolean getAutoConsistency() {
return autoConsistency;
}
/* (non-Javadoc)
* @see org.mindswap.owl.OWLKnowledgeBase#setAutoConsistency(boolean)
*/
public void setAutoConsistency(boolean auto) {
autoConsistency = auto;
}
public boolean getAutoTranslate() {
return (translator != null);
}
public void setAutoTranslate(boolean auto) {
if(auto)
translator = OWLSFactory.createVersionTranslator();
else
translator = null;
}
public OWLKnowledgeBase getTranslationSource() {
return translationSource;
}
public Service readService(String uri) throws FileNotFoundException, URISyntaxException {
return readService(new URI(uri));
}
public Service readService(URI uri) throws FileNotFoundException {
List list = readAllServices(uri);
return (list == null || list.isEmpty()) ? null : getCorrectService(list, uri);
}
public Service readService(Reader in, URI baseURI) {
List list = readAllServices(in, baseURI);
return (list == null || list.isEmpty()) ? null : getCorrectService(list, baseURI);
}
public Service readService(InputStream in, URI baseURI) {
List list = readAllServices(in, baseURI);
return (list == null || list.isEmpty()) ? null : getCorrectService(list, baseURI);
}
public List readAllServices(String uri) throws FileNotFoundException, URISyntaxException {
return readAllServices(new URI(uri));
}
public List readAllServices(URI uri) throws FileNotFoundException {
OWLOntology ont = read(uri);
return (ont == null) ? null : getServices();
}
public List readAllServices(Reader in, URI baseURI) {
OWLOntology ont = read(in, baseURI);
return (ont == null) ? null : getServices();
}
public List readAllServices(InputStream in, URI baseURI) {
OWLOntology ont = read(in, baseURI);
return (ont == null) ? null : getServices();
}
/*
* Michael Daenzer, 03-24-2006
* pulled down from OWLModelImpl and added support for subclasses of Service:service
*/
public List getServices() {
OWLIndividualList inds = OWLFactory.createIndividualList();
inds.addAll(getInstances(OWLS.Service.Service));
Iterator iter = getSubClasses(OWLS.Service.Service, false).iterator();
while (iter.hasNext())
inds.addAll(getInstances((OWLClass) iter.next()));
return OWLSFactory.wrapList(inds, Service.class);
}
/**
* Returns the service from the given List indicated by the given URI. If a concrete
* resource is referenced (i.e. a fragment is given), only this is returned. If no concrete
* resource is referenced by the given URI, the first service matching the given URI in its
* full URI is returned.
*
* @param list A list containing services
* @param uri The URI of the service to return
* @return the service from the given List indicated by the given URI
* @author Michael Daenzer
*/
private Service getCorrectService(List list, URI uri) {
boolean strictSearch = false;
String patternUri = uri.toString();
// search if fragment is available
int fragmentSignPos = uri.toString().lastIndexOf("#");
if (fragmentSignPos > -1) {
if (fragmentSignPos + 1 != patternUri.length())
strictSearch = true;
patternUri = patternUri.substring(0, patternUri.length() - 1);
}
// search now the list
Iterator iter = list.iterator();
while (iter.hasNext()) {
Service service = (Service) iter.next();
if (strictSearch && service.getURI().equals(uri))
return service;
if (!strictSearch && service.getURI().toString().indexOf(patternUri) != -1)
return service;
}
return (Service) list.get(0);
}
/**
* @deprecated Use createOntology() instead
*/
public org.mindswap.owls.OWLSOntology createOWLSOntology() {
return (org.mindswap.owls.OWLSOntology) createOntology();
}
/**
* @deprecated Use createOntology(URI) instead
*/
public org.mindswap.owls.OWLSOntology createOWLSOntology(URI uri) {
return (org.mindswap.owls.OWLSOntology) createOntology(uri);
}
public OWLIndividual parseLiteral(String literal) {
return getBaseOntology().parseLiteral( literal );
}
public List getNonLanguageIndividuals() {
ArrayList list = new ArrayList();
Set ontologies = getOntologies();
Iterator iter = ontologies.iterator();
while (iter.hasNext()) {
OWLOntology ont = (OWLOntology) iter.next();
list.addAll(ont.getNonLanguageIndividuals());
}
return list;
}
public List getNonLanguageClasses() {
ArrayList list = new ArrayList();
Set ontologies = getOntologies();
Iterator iter = ontologies.iterator();
while (iter.hasNext()) {
OWLOntology ont = (OWLOntology) iter.next();
list.addAll(ont.getNonLanguageClasses());
}
return list;
}
public List getNonLanguageDataProperties() {
ArrayList list = new ArrayList();
Set ontologies = getOntologies();
Iterator iter = ontologies.iterator();
while (iter.hasNext()) {
OWLOntology ont = (OWLOntology) iter.next();
list.addAll(ont.getNonLanguageDataProperties());
}
return list;
}
public List getNonLanguageObjectProperties() {
ArrayList list = new ArrayList();
Set ontologies = getOntologies();
Iterator iter = ontologies.iterator();
while (iter.hasNext()) {
OWLOntology ont = (OWLOntology) iter.next();
list.addAll(ont.getNonLanguageObjectProperties());
}
return list;
}
public Set getClasses() {
TreeSet set = new TreeSet();
Set ontologies = getOntologies();
Iterator iter = ontologies.iterator();
while (iter.hasNext()) {
OWLOntology ont = (OWLOntology) iter.next();
set.addAll(ont.getClasses());
}
return set;
}
public BindingList getBindingsFor(Parameter parameter) {
BindingList bindings = OWLSFactory.createBindingList();
Iterator iter = getOntologies().iterator();
while (iter.hasNext())
bindings.addAll( ((OWLOntology) iter.next()).getBindingsFor(parameter));
return bindings;
}
}