- added better modelling of ontologies

src/fr/inrialpes/exmo/align/onto/BasicOntology.java

+/*
+ * $Id: Ontology.java 643 2008-02-23 11:16:09Z euzenat $
+ *
+ * Copyright (C) INRIA Rhne-Alpes, 2007-2008
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; either version 2.1 of the License, or
+ * (at your option) any later version.
+ * 
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+ */
+
+package fr.inrialpes.exmo.align.onto;
+
+import java.net.URI;
+
+/**
+ * Store the information regarding ontologies in a specific structure
+ */
+
+public class BasicOntology<O> implements Ontology<O> {
+    protected URI uri = null;
+    protected URI file = null;
+    protected URI formalismURI = null;
+    protected String formalism = null;
+    protected O onto = null;
+
+    public BasicOntology() {};
+
+    public URI getURI() { return uri; }
+    public URI getFile() { return file; }
+    public URI getFormURI() { return formalismURI; }
+    public String getFormalism() { return formalism; }
+    public O getOntology() { return onto; }
+
+    public void setURI( URI uri ) { this.uri = uri; }
+    public void setFile( URI file ) { this.file = file; }
+    public void setFormURI( URI u ) { formalismURI = u; }
+    public void setFormalism( String name ) { formalism = name; }
+    public void setOntology( O o ) { this.onto = o; }
+}

src/fr/inrialpes/exmo/align/onto/ConcreteOntology.java

+/*
+ * $Id$
+ *
+ * Copyright (C) INRIA Rhne-Alpes, 2003-2008
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; either version 2.1 of the License, or
+ * (at your option) any later version.
+ * 
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+ */
+
+package fr.inrialpes.exmo.align.onto;
+
+import java.net.URI;
+import java.util.Iterator;
+import org.xml.sax.SAXException;
+
+import org.semanticweb.owl.align.AlignmentException;
+
+/**
+ * Store the information regarding ontologies in a specific structure
+ */
+
+public abstract class ConcreteOntology<O> extends BasicOntology<O> implements LoadedOntology<O> {
+
+    public abstract Iterator<Object> getObjectProperties() throws AlignmentException;
+    public abstract Iterator<URI> getClassNames() throws AlignmentException;
+    public abstract Iterator<URI> getObjectPropertyNames() throws AlignmentException;
+    public abstract Iterator<URI> getDataPropertyNames() throws AlignmentException;
+    public abstract Iterator<URI> getInstanceNames() throws AlignmentException;
+    public abstract int nbClasses() throws AlignmentException;
+    public abstract int nbDataProperties() throws AlignmentException;
+    public abstract int nbObjectProperties() throws AlignmentException;
+    public abstract int nbInstances() throws AlignmentException;
+    public abstract Object getEntity( URI uri ) throws AlignmentException;
+    //public abstract void loadOntology( URI ref, OntologyCache ontologies ) throws SAXException, AlignmentException;
+}

src/fr/inrialpes/exmo/align/onto/LoadedOntology.java

+/*
+ * $Id$
+ *
+ * Copyright (C) INRIA Rhne-Alpes, 2008
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; either version 2.1 of the License, or
+ * (at your option) any later version.
+ * 
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+ */
+
+package fr.inrialpes.exmo.align.onto;
+
+import java.net.URI;
+import java.util.Set;
+
+
+public interface LoadedOntology<O> extends Ontology<O> {
+
+    public Set<Entity> getEntities();
+    public Set<Entity> getClasses();
+    public Set<Entity> getProperties();
+    public boolean contains(Entity e);
+    public void unload();
+}

src/fr/inrialpes/exmo/align/onto/Ontology.java

+/*
+ * $Id$
+ *
+ * Copyright (C) INRIA Rhne-Alpes, 2008
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; either version 2.1 of the License, or
+ * (at your option) any later version.
+ * 
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+ */
+
+package fr.inrialpes.exmo.align.onto;
+
+import java.net.URI;
+import java.util.Set;
+
+
+public interface Ontology<O> {
+
+    public URI getURI();
+    public URI getFile();
+    public URI getFormURI(); // Can be null
+    public String getFormalism(); // Can be null
+    public O getOntology();
+
+    public void setURI( URI uri );
+    public void setFile( URI file );
+    public void setFormURI( URI u );
+    public void setFormalism( String name );
+    public void setOntology( O o );
+}

src/fr/inrialpes/exmo/align/onto/OntologyAdapter.java

+/*
+ * $Id$
+ *
+ * Copyright (C) INRIA Rhne-Alpes, 2008
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; either version 2.1 of the License, or
+ * (at your option) any later version.
+ * 
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+ */
+
+package fr.inrialpes.exmo.align.onto;
+
+
+import java.net.URI;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.IdentityHashMap;
+import java.util.Map;
+import java.util.Set;
+
+public abstract class OntologyAdapter<O> extends ConcreteOntology<O> {
+
+	protected O ontology;
+	protected URI uri;
+
+	protected Set<Entity> classes;
+	protected Set<Entity> properties;
+	protected Set<Entity> entities;
+	public Set<Entity> individuals;
+
+	protected OntologyAdapter() {}
+
+	public OntologyAdapter(O ont, Set<Entity> c, Set<Entity> p, URI uri) {
+		ontology=ont;
+		classes = c;
+		properties = p;
+		entities = new HashSet<Entity>(c);
+		entities.addAll(p);
+		this.uri = uri;
+	}
+
+	public boolean contains(Entity e) {
+		return classes.contains(e) || properties.contains(e);
+	}
+
+	public Set<Entity> getClasses() {
+		return Collections.unmodifiableSet(classes);
+	}
+
+	public Set<Entity> getEntities() {
+		return Collections.unmodifiableSet(entities);
+	}
+
+	public O getOntology() {
+		return ontology;
+	}
+
+	public void setOntology( O o ) {
+		ontology = o;
+	}
+
+	public Set<Entity> getProperties() {
+		return Collections.unmodifiableSet(properties);
+	}
+
+	public URI getURI() {
+		return uri;
+	}
+
+	public String toString() {
+		return uri.toString();
+	}
+
+}

src/fr/inrialpes/exmo/align/onto/OntologyCache.java

+/*
+ * $Id: OntologyCache.java 670 2008-03-02 00:06:16Z euzenat $
+ *
+ * Copyright (C) INRIA Rhne-Alpes, 2007-2008
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; either version 2.1 of
+ * the License, or (at your option) any later version.
+ * 
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
+ * USA.
+ */
+
+package fr.inrialpes.exmo.align.onto; 
+
+// import java classes
+import java.util.Hashtable;
+import java.util.Enumeration;
+import java.net.URI;
+
+/**
+ * This caches the loaded ontologies so that it is possible to share them between alignments
+ * as well as to unload them if necessary.
+ * 
+ * NOTE[3.2]: This class may be obsoleted and its code go to OntolofyFactory
+ *
+ * @author Jrme Euzenat
+ * @version $Id: OntologyCache.java 670 2008-03-02 00:06:16Z euzenat $ 
+ */
+
+public class OntologyCache {
+ 
+  /** The list of currently loaded ontologies as a function:
+   * URI --> Ontology
+   * This is the ontology URI, NOT its filename
+   */
+    Hashtable<URI,LoadedOntology> ontologies = null;
+    
+    public OntologyCache() {
+	ontologies = new Hashtable<URI,LoadedOntology>();
+    }
+  
+    public void recordOntology( URI uri, LoadedOntology ontology ){
+	ontologies.put(uri,ontology);
+    }
+
+    public Ontology getOntology( URI uri ){
+	return ontologies.get( uri );
+    }
+
+    public void unloadOntology( URI uri, LoadedOntology ontology ){
+	LoadedOntology o = ontologies.get(uri);
+	o.unload();
+	ontologies.remove( uri );
+    }
+
+    public void clear(){
+	// JE: Onto [Is this correct ??]
+	//for ( Enumeration e = ontologies.elements() ; e.hasMoreElements();  ){
+	//    Ontology o = (Ontology)e.nextElement();
+	for ( LoadedOntology o : ontologies.values() ){
+	    o.unload();
+	}
+	ontologies.clear();
+    }
+
+}

src/fr/inrialpes/exmo/align/onto/OntologyFactory.java

+/*
+ * $Id$
+ *
+ * Copyright (C) INRIA Rhne-Alpes, 2008
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; either version 2.1 of the License, or
+ * (at your option) any later version.
+ * 
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+ */
+
+package fr.inrialpes.exmo.align.onto;
+
+import java.net.URI;
+import java.util.HashMap;
+import java.util.Map;
+
+import java.lang.reflect.InvocationTargetException;
+
+public abstract class OntologyFactory {
+
+    protected static OntologyFactory instance;
+    
+    private static String API_NAME="fr.inrialpes.exmo.align.onto.owlapi10.OWLAPIOntologyFactory";
+
+    protected static Map<URI,Ontology> loadedOntos= new HashMap<URI,Ontology>();
+    protected static Map<URI,Ontology> loadedOntosLogical= new HashMap<URI,Ontology>();
+    public static OntologyFactory newInstance() {
+	return newInstance(API_NAME);
+    }
+
+    public static OntologyFactory newInstance(String apiName) {
+	try {
+	    Class ofClass = Class.forName(apiName);
+	    Class[] cparams = {};
+	    java.lang.reflect.Constructor ofConstructor = ofClass.getConstructor(cparams);
+	    Object[] mparams = {};
+	    instance = (OntologyFactory)ofConstructor.newInstance(mparams);
+	} catch (ClassNotFoundException cnfex ) {
+	    cnfex.printStackTrace(); // better raise errors
+	} catch (NoSuchMethodException nsmex) {
+	    nsmex.printStackTrace();
+	} catch (InstantiationException ieex) {
+	    ieex.printStackTrace();
+	} catch (IllegalAccessException iaex) {
+	    iaex.printStackTrace();
+	} catch (InvocationTargetException itex) {
+	    itex.printStackTrace();
+	}
+	return instance;
+    }
+
+    public abstract LoadedOntology loadOntology( URI physicalURI );
+
+    // JE: This is not really usefule since it doubles OntologyCache...
+    // This may be included as well...
+    public Ontology getOntologyFromFile(URI physicalURI) {
+	Ontology onto;
+	if (loadedOntos.containsKey(physicalURI))
+	    onto = loadedOntos.get(physicalURI);
+	else {
+	    onto = loadOntology( physicalURI );
+	    loadedOntos.put(physicalURI, onto);
+	    loadedOntosLogical.put(onto.getURI(), onto);
+		}
+	return onto;
+    }
+
+    public static Ontology getOntologyFromURI(URI logicalURI) {
+	return loadedOntosLogical.get(logicalURI);
+    }
+}

src/fr/inrialpes/exmo/align/onto/owlapi10/OWLAPIOntology.java

+/*
+ * $Id$
+ *
+ * Copyright (C) INRIA Rhne-Alpes, 2007-2008
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; either version 2.1 of the License, or
+ * (at your option) any later version.
+ * 
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+ */
+
+package fr.inrialpes.exmo.align.onto.owlapi10;
+
+import java.net.URI;
+import java.util.Set;
+import java.util.Iterator;
+import java.util.NoSuchElementException;
+import java.lang.UnsupportedOperationException;
+
+import org.semanticweb.owl.align.AlignmentException;
+
+import fr.inrialpes.exmo.align.onto.ConcreteOntology;
+import fr.inrialpes.exmo.align.onto.LoadedOntology;
+import fr.inrialpes.exmo.align.onto.Entity;
+
+import org.semanticweb.owl.model.OWLOntology;
+import org.semanticweb.owl.model.OWLProperty;
+import org.semanticweb.owl.model.OWLClass;
+import org.semanticweb.owl.model.OWLObjectProperty;
+import org.semanticweb.owl.model.OWLDataProperty;
+import org.semanticweb.owl.model.OWLIndividual;
+import org.semanticweb.owl.model.OWLEntity;
+import org.semanticweb.owl.model.OWLException;
+
+/**
+ * Store the information regarding ontologies in a specific structure
+ * Acts as an interface with regard to an ontology APY
+ */
+
+//private class OWLAPIOntology extends OntologyAdapter<OWLOntology> {
+//    private OWLAPIOntology() {super();}
+//}
+
+
+public class OWLAPIOntology extends ConcreteOntology<OWLOntology> implements LoadedOntology<OWLOntology> {
+    public OWLAPIOntology() {
+	setFormalism( "OWL1.0" );
+	try {
+	    setFormURI( new URI("http://www.w3.org/2002/07/owl#") );
+	} catch (Exception e) {}; // does not happen
+    };
+
+    public OWLOntology getOntology() { return onto; }
+
+    public void setOntology( OWLOntology o ) { this.onto = o; }
+
+    // Here it shoud be better to report exception
+    // JE: Onto this does not work at all, of course...
+    public Set<Entity> getEntities() {
+	try {
+	    return (Set<Entity>)((OWLOntology)onto).getClasses(); // [W:unchecked]
+	} catch (OWLException ex) {
+	    return null;
+	}
+    }
+
+    public Set<Entity> getClasses() {
+	try {
+	    return (Set<Entity>)((OWLOntology)onto).getClasses(); // [W:unchecked]
+	} catch (OWLException ex) {
+	    return null;
+	}
+    }
+
+    public Set<Entity> getProperties() {
+	try {
+	    return (Set<Entity>)((OWLOntology)onto).getClasses(); // [W:unchecked]
+	} catch (OWLException ex) {
+	    return null;
+	}
+    }
+
+    public Set<Entity> getIndividuals() {
+	try {
+	    return (Set<Entity>)((OWLOntology)onto).getIndividuals(); // [W:unchecked]
+	} catch (OWLException ex) {
+	    return null;
+	}
+    }
+
+    // The only point is if I should return OWLProperties or names...
+    // I guess that I will return names (ns+name) because otherwise I will need a full
+    // Abstract ontology interface and this is not the rule...
+    public Iterator<Object> getObjectProperties() throws AlignmentException {
+	try {
+	    // [Warning:unchecked] due to OWL API not serving generic types
+	    return ((OWLOntology)onto).getObjectProperties().iterator(); // [W:unchecked]
+	} catch (OWLException ex) {
+	    throw new AlignmentException( "Cannot get object properties", ex );
+	}
+    }
+
+    // JE: these are really specific methods I guess
+    public Iterator<URI> getObjectPropertyNames() throws AlignmentException {
+	try {
+	    return new URIIterator(((OWLOntology)onto).getObjectProperties().iterator());
+	} catch (OWLException ex) {
+	    throw new AlignmentException( "Cannot get object properties", ex );
+	}
+    }
+
+    public Iterator<URI> getDataPropertyNames() throws AlignmentException {
+	try {
+	    return new URIIterator(((OWLOntology)onto).getDataProperties().iterator());
+	} catch (OWLException ex) {
+	    throw new AlignmentException( "Cannot get object properties", ex );
+	}
+    }
+
+    public Iterator<URI> getClassNames() throws AlignmentException {
+	try {
+	    return new URIIterator(((OWLOntology)onto).getClasses().iterator());
+	} catch (OWLException ex) {
+	    throw new AlignmentException( "Cannot get object properties", ex );
+	}
+    }
+
+    public Iterator<URI> getInstanceNames() throws AlignmentException {
+	try {
+	    return new URIIterator(((OWLOntology)onto).getIndividuals().iterator());
+	} catch (OWLException ex) {
+	    throw new AlignmentException( "Cannot get object properties", ex );
+	}
+    }
+
+    public int nbClasses() throws AlignmentException {
+	try {
+	    return ((OWLOntology)onto).getClasses().size();
+	} catch (OWLException ex) {
+	    throw new AlignmentException( "Cannot get class number" );
+	}
+    }
+
+    public int nbObjectProperties() throws AlignmentException {
+	try {
+	    return ((OWLOntology)onto).getObjectProperties().size();
+	} catch (OWLException ex) {
+	    throw new AlignmentException( "Cannot get object property number" );
+	}
+    }
+
+    public int nbDataProperties() throws AlignmentException {
+	try {
+	    return ((OWLOntology)onto).getDataProperties().size();
+	} catch (OWLException ex) {
+	    throw new AlignmentException( "Cannot get data property number" );
+	}
+    }
+
+    public int nbInstances() throws AlignmentException {
+	try {
+	    return ((OWLOntology)onto).getIndividuals().size();
+	} catch (OWLException ex) {
+	    throw new AlignmentException( "Cannot get individual number" );
+	}
+    }
+
+    public boolean contains(Entity e) {
+	if ( e instanceof OWLEntity ){
+	    if ( e instanceof OWLClass ) {
+		for ( Object o : getClasses() ){
+		    if ( o == e ) return true;
+		}
+	    } else if ( e instanceof OWLDataProperty ) {
+		for ( Object o : getProperties() ){
+		    if ( o == e ) return true;
+		}
+	    } else if ( e instanceof OWLIndividual ) {
+		for ( Object o : getIndividuals() ){
+		    if ( o == e ) return true;
+		}
+	    }
+	};
+	return false;
+    }
+
+    public void unload() {
+	try {
+	    ((OWLOntology)onto).getOWLConnection().notifyOntologyDeleted( ((OWLOntology)onto) );
+	} catch (OWLException ex) { System.err.println(ex); };
+    }
+
+    public Object getEntity( URI uri ) throws AlignmentException {
+	try {
+	    OWLEntity result = ((OWLOntology)onto).getClass( uri );
+	    if ( result == null ) result = ((OWLOntology)onto).getDataProperty( uri );
+	    if ( result == null ) result = ((OWLOntology)onto).getObjectProperty( uri );
+	    if ( result == null ) result = ((OWLOntology)onto).getIndividual( uri );
+	    return result;
+	} catch (OWLException ex) {
+	    throw new AlignmentException( "Cannot dereference URI : "+uri );
+	}
+    }
+
+}
+
+final class URIIterator implements Iterator<URI> {
+    private Iterator it = null;
+
+    public URIIterator ( Iterator i ){
+	it = i;
+    }
+    public boolean hasNext() { return it.hasNext(); }
+    public URI next() throws NoSuchElementException {
+	try{ 
+	    return ((OWLEntity)it.next()).getURI();
+	} catch (OWLException ex) {
+	    throw new NoSuchElementException(ex.toString()); // cannot encapsulate!
+	}
+    }
+    public void remove() throws UnsupportedOperationException {
+	throw new UnsupportedOperationException();
+    }
+}

src/fr/inrialpes/exmo/align/onto/owlapi10/OWLAPIOntologyFactory.java

+/*
+ * $Id$
+ *
+ * Copyright (C) INRIA Rhne-Alpes, 2008
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; either version 2.1 of the License, or
+ * (at your option) any later version.
+ * 
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+ */
+
+package fr.inrialpes.exmo.align.onto.owlapi10;
+
+import java.net.URI;
+import java.net.URISyntaxException;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
+
+import org.apache.log4j.Logger;
+import org.apache.log4j.Level;
+
+import org.xml.sax.SAXException;
+
+import org.semanticweb.owl.align.AlignmentException;
+
+import fr.inrialpes.exmo.align.onto.OntologyCache;
+import fr.inrialpes.exmo.align.onto.OntologyFactory;
+import fr.inrialpes.exmo.align.onto.EntityAdapter;
+import fr.inrialpes.exmo.align.onto.Entity;
+import fr.inrialpes.exmo.align.onto.EntityAdapter.TYPE;
+import fr.inrialpes.exmo.align.onto.Ontology;
+import fr.inrialpes.exmo.align.onto.ConcreteOntology;
+import fr.inrialpes.exmo.align.onto.LoadedOntology;
+
+import org.semanticweb.owl.io.vocabulary.RDFSVocabularyAdapter;
+import org.semanticweb.owl.model.OWLAnnotationInstance;
+import org.semanticweb.owl.model.OWLClass;
+import org.semanticweb.owl.model.OWLDataValue;
+import org.semanticweb.owl.model.OWLEntity;
+import org.semanticweb.owl.model.OWLException;
+import org.semanticweb.owl.model.OWLIndividual;
+import org.semanticweb.owl.model.OWLOntology;
+import org.semanticweb.owl.model.OWLProperty;
+import org.semanticweb.owl.model.helper.OWLEntityCollector;
+import org.semanticweb.owl.util.OWLConnection;
+import org.semanticweb.owl.util.OWLManager;
+import org.semanticweb.owl.io.owl_rdf.OWLRDFParser;
+import org.semanticweb.owl.io.owl_rdf.OWLRDFErrorHandler;
+
+public class OWLAPIOntologyFactory extends OntologyFactory {
+
+    private URI formalismUri = null;
+    private String formalismId = "OWL1.0";
+
+    public OWLAPIOntologyFactory() {
+	try {
+	    formalismUri = new URI("http://www.w3.org/2002/07/owl#");
+	} catch (URISyntaxException ex) { ex.printStackTrace(); } // should not happen
+    };
+
+    public static OntologyFactory getInstance() {
+	if (instance == null || !(instance instanceof OWLAPIOntologyFactory))
+	    instance = new OWLAPIOntologyFactory();
+	return instance;
+    }
+
+    public LoadedOntology loadOntology( URI physicalURI ) {
+	OWLConnection connection = null;
+	Map parameters = new HashMap();
+	parameters.put(OWLManager.OWL_CONNECTION,
+		       "org.semanticweb.owl.impl.model.OWLConnectionImpl");
+	try {
+	    connection = OWLManager.getOWLConnection(parameters);
+	    Level lev = Logger.getLogger("org.semanticweb.owl").getLevel();
+	    Logger.getLogger("org.semanticweb.owl").setLevel(Level.ERROR);
+	    OWLOntology ontology = connection.loadOntologyPhysical(physicalURI);
+	    Logger.getLogger("org.semanticweb.owl").setLevel(lev);
+	    OWLAPIOntology onto = new OWLAPIOntology();
+	    // It may be possible to fill this as final in OWLAPIOntology...
+	    onto.setFormalism( formalismId );
+	    onto.setFormURI( formalismUri );
+	    onto.setOntology( ontology );
+	    onto.setFile( physicalURI );
+	    try {
+		onto.setURI( ontology.getLogicalURI() );//getURI();
+	    } catch (OWLException e) {
+		// Better put in the AlignmentException of loaded
+		e.printStackTrace();
+	    }
+	    return onto;
+	} catch (OWLException e) {
+	    e.printStackTrace();
+	}
+	return null;
+    }
+
+    /** Can be used for loading the ontology if it is not available **/
+    // JE: Onto: check that the structure is properly filled (see build...)
+    public Ontology loadOntology( URI ref, OntologyCache ontologies ) throws SAXException, AlignmentException {
+	Ontology onto = null;
+	if ( (ontologies != null) && ( ontologies.getOntology( ref ) != null ) ) {
+	} else if ( onto != null ) {
+	} else {
+	    OWLOntology parsedOnt = null;
+	    try {
+		OWLRDFParser parser = new OWLRDFParser();
+		OWLRDFErrorHandler handler = new OWLRDFErrorHandler(){
+			public void owlFullConstruct( int code, String message ) 
+			    throws SAXException {
+			}
+			public void owlFullConstruct(int code, String message, Object o)
+			    throws SAXException {
+			}
+			public void error( String message ) throws SAXException {
+			    throw new SAXException( message.toString() );
+			}
+			public void warning( String message ) throws SAXException {
+			    System.err.println("WARNING: " + message);
+			}
+		    };
+		Level lev = Logger.getLogger("org.semanticweb.owl").getLevel();
+		Logger.getLogger("org.semanticweb.owl").setLevel(Level.ERROR);
+		parser.setOWLRDFErrorHandler( handler );
+		parser.setConnection( OWLManager.getOWLConnection() );
+		parsedOnt = parser.parseOntology( ref );
+		Logger.getLogger("org.semanticweb.owl").setLevel(lev);
+	    } catch (OWLException ex) {
+		throw new AlignmentException( "Cannot load ontology "+ref, ex );
+	    }
+	    // THIS SHOULD NOW BE DONE WHEN CREATING THE ONTOLOGY
+	    //setOntology( parsedOnt );
+	    //if ( ontologies != null ) ontologies.recordOntology( ref, this );
+	    //onto = parsedOnt;
+	}
+	return onto;
+    }
+
+    // JE: Onto: I am not sure of the meaning of this "get"
+    /*
+	private Ontology getOntology(OWLOntology ont) {
+	    // JE: Onto
+	    //OntologyAdapter<OWLOntology> oModel = new  OWLAPIOntology();
+	    Ontology oModel = new  OWLAPIOntology();
+	    oModel.ontology=ont;
+	    try {
+		oModel.uri=ont.getLogicalURI();//getURI();
+	    } catch (OWLException e) {
+		// TODO Auto-generated catch block
+		e.printStackTrace();
+	    }
+	    oModel.classes = getEntities(oModel,OWLClass.class);
+	    oModel.properties = getEntities(oModel,OWLProperty.class);
+	    //oModel.individuals = getEntities(oModel,OWLIndividual.class);
+	    oModel.entities = new HashSet<Entity>(oModel.properties);
+	    oModel.entities.addAll(oModel.classes);
+	    //oModel.entities.addAll(oModel.individuals);
+
+	    //oModel.classes = getEntities(oModel,OWLEntity.class);
+	    return oModel;
+	}
+    */
+
+    private Set<Entity> getEntities(LoadedOntology<OWLOntology> ont, Class<? extends OWLEntity> c){
+	OWLEntityCollector ec = new OWLEntityCollector();
+	try {
+	    ont.getOntology().accept(ec);
+	    Set<Entity> entities = new HashSet<Entity>();
+	    for (Object obj : ec.entities()) {
+		if (c.isInstance(obj) && (((OWLEntity) obj).getURI() != null) &&
+		    ((OWLEntity) obj).getURI().getSchemeSpecificPart().equals(ont.getURI().getSchemeSpecificPart())){
+		    //System.out.println(((OWLEntity) obj).getURI().getSchemeSpecificPart()+" - "+ont.getURI().getSchemeSpecificPart());
+		    //System.out.println(((OWLEntity) obj).getURI()+" : "+ont.getOntology().contains(obj));
+		    entities.add(new OWLAPIEntity((OWLEntity)obj, ont, ((OWLEntity)obj).getURI() ));
+		}
+	    }
+	    return entities;
+	} catch (OWLException e) {
+	    // TODO Auto-generated catch block
+	    e.printStackTrace();
+	}
+	return null;
+    }
+
+    private void addAnnotations(OWLAPIEntity ent) {
+	for (String[] a : getAnnotations(ent.getObject(),(OWLOntology)ent.getOntology().getOntology())) {
+	    ent.getAnnotations().add(a[0]);
+	    if (a[1]!=null) {
+		ent.getLangToAnnot(EntityAdapter.LANGUAGES.valueOf(a[1])).add(a[0]);
+	    }
+	    if (a[2].equals(RDFSVocabularyAdapter.INSTANCE.getComment())) {
+		ent.getTypeToAnnot(EntityAdapter.TYPE.comment).add(a[0]);
+	    }
+	    else if (a[2].equals(RDFSVocabularyAdapter.INSTANCE.getLabel())) {
+		ent.getTypeToAnnot(EntityAdapter.TYPE.comment).add(a[0]);
+	    }
+	}
+    }
+
+
+	private Set<String[]> getAnnotations(OWLEntity e, OWLOntology o)  {
+		Set<String[]> res = new HashSet<String[]>();
+		Set annots;
+		try {
+			annots = e.getAnnotations(o);
+			for (Object annot : annots) {
+				OWLAnnotationInstance annInst = ((OWLAnnotationInstance) annot);
+				String val;
+				String lang=null;
+				String annotUri = annInst.getProperty().getURI().toString();
+				if ( annInst.getContent() instanceof OWLDataValue ) {
+				    OWLDataValue odv = (OWLDataValue) annInst.getContent();
+				    val = odv.toString();
+				    lang = odv.getLang();
+				}
+				else
+					val= (String) annInst.getContent();
+				res.add(new String[]{val,lang,annotUri});
+			}
+		}
+		catch (OWLException oe) {
+			oe.printStackTrace();
+		}
+		return Collections.unmodifiableSet(res);
+	}
+
+
+    private class OWLAPIEntity extends EntityAdapter<OWLEntity> {
+	//private boolean toLoad=true;
+
+	private OWLAPIEntity() { super(false); }
+	private OWLAPIEntity(OWLEntity e, Ontology o, URI u ) {
+	    super( e, o, u, false);
+	}
+
+	public Set<String> getAnnotations(String lang, TYPE type) {
+	    if (this.annotations==null) {
+		init();
+		addAnnotations(this);
+		//toLoad=false;
+	    }
+	    return super.getAnnotations(lang, type);
+	}
+    }
+
+}