OWL2Parser.java revision 22dc747cf141912d190ebb9db09a3893dd7fab4d
2N/Aimport org.coode.owlapi.owlxml.renderer.OWLXMLRenderer;
2N/Aimport org.coode.owlapi.rdf.rdfxml.RDFXMLRenderer;
2N/Aimport org.semanticweb.owlapi.apibinding.OWLManager;
2N/Aimport org.semanticweb.owlapi.io.OWLRendererException;
2N/Aimport org.semanticweb.owlapi.io.StreamDocumentSource;
2N/Aimport org.semanticweb.owlapi.model.*;
2N/Aimport org.semanticweb.owlapi.util.OWLOntologyMerger;
2N/Aimport uk.ac.manchester.cs.owl.owlapi.mansyntaxrenderer.ManchesterOWLSyntaxRenderer;
2N/A
2N/Aimport java.io.*;
2N/Aimport java.net.URL;
2N/Aimport java.net.URLConnection;
2N/Aimport java.util.*;
2N/A
2N/Apublic class OWL2Parser {
2N/A private static enum OPTION {OWL_XML, MANCHESTER, RDF_XML}
2N/A
2N/A private static OPTION op;
2N/A private static final List<OWLOntology> loadedImportsList = new ArrayList<OWLOntology>();
2N/A private static final ArrayList<IRI> importsIRI = new ArrayList<IRI>();
2N/A private static final Map<OWLOntology, List<OWLOntology>> m = new HashMap<OWLOntology, List<OWLOntology>>();
2N/A private static final Set<OWLOntology> s = new HashSet<OWLOntology>();
2N/A private static final Set<OWLOntology> expanded = new HashSet<OWLOntology>();
2N/A
2N/A public static void main(String[] args) {
2N/A if (args.length < 1) {
2N/A System.out.println("Usage: processor <URI> [FILENAME] <OPTION>");
2N/A System.exit(1);
2N/A }
2N/A // A simple example of how to load and save an ontology
2N/A try {
2N/A op = OPTION.MANCHESTER;
2N/A BufferedWriter out = new BufferedWriter(new OutputStreamWriter(System.out));
2N/A if (args.length > 1) {
2N/A // args[0]: IRI
2N/A // args[1]: name of output file
2N/A // args[2]: type of output file: xml, rdf, or otherwise assume Manchester syntax
2N/A String filename = args[1];
2N/A if (args.length == 3) {
2N/A out = new BufferedWriter(new FileWriter(filename));
2N/A if (args[2].equals("xml"))
2N/A op = OPTION.OWL_XML;
2N/A else if (args[2].equals("rdf"))
2N/A op = OPTION.RDF_XML;
2N/A } else
2N/A // args[0]: IRI
2N/A // args[1]: type of output (or output file for Manchester syntax)
2N/A // xml (OWL XML),
2N/A // rdf (RDF/XML),
2N/A // or otherwise use argument as file name for Manchester syntax
2N/A // for xml and rdf output goes to standard output, i.e. System.out
2N/A if (args[1].equals("xml"))
2N/A op = OPTION.OWL_XML;
2N/A else if (args[1].equals("rdf"))
2N/A op = OPTION.RDF_XML;
2N/A else
2N/A out = new BufferedWriter(new FileWriter(filename));
2N/A }
2N/A /* Load an ontology from a physical IRI */
2N/A URL physicalUrl = new URL(args[0]);
2N/A URLConnection con = physicalUrl.openConnection();
2N/A con.addRequestProperty("Accept", "text/plain");
2N/A // System.out.println("IRI: " + physicalIRI + "\n");
2N/A // Now do the loading
2N/A OWLOntologyLoaderConfiguration config = new OWLOntologyLoaderConfiguration();
2N/A config = config.setMissingImportHandlingStrategy(MissingImportHandlingStrategy.SILENT);
2N/A OWLOntologyManager manager = OWLManager.createOWLOntologyManager();
2N/A OWLOntology ontology = manager.loadOntologyFromOntologyDocument(new StreamDocumentSource(con.getInputStream()), config);
2N/A getImportsList(ontology, manager);
2N/A if (loadedImportsList.size() == 0)
2N/A parsing_option(ontology, out);
2N/A else {
2N/A IRI ontIri = ontology.getOntologyID().getOntologyIRI();
2N/A if (importsIRI.contains(ontIri)) {
2N/A importsIRI.remove(importsIRI.lastIndexOf(ontIri));
2N/A }
2N/A if (loadedImportsList.contains(ontology)) {
2N/A OWLOntologyMerger merger = new OWLOntologyMerger(manager);
2N/A String str = ontology.getOntologyID().getOntologyIRI().toString();
2N/A loadedImportsList.remove(loadedImportsList.indexOf(ontology));
2N/A String merged_name = "";
2N/A for (OWLOntology aux_ont : loadedImportsList) {
2N/A String mrg = aux_ont.getOntologyID().getOntologyIRI().toString();
2N/A mrg = mrg.replaceAll("[<>\\(\\) ]", "");
2N/A mrg = mrg.replaceAll(".*/", "");
2N/A mrg = mrg.replaceAll("\\[.*]", "");
2N/A merged_name = merged_name + mrg;
2N/A }
2N/A merged_name = str + merged_name;
2N/A // System.out.println("NAME: " + merged_name + "\n");
2N/A IRI mergedOntologyIRI = IRI.create(merged_name);
2N/A // System.out.println("MERGED_IRI " + mergedOntologyIRI + "\n");
2N/A OWLOntology merged = merger.createMergedOntology(manager, mergedOntologyIRI);
2N/A parsing_option(merged, out);
2N/A } else
2N/A parseZeroImports(out, ontology);
2N/A }
} catch (Exception ex) {
System.err.println("OWL parse error: " + ex.getMessage());
ex.printStackTrace();
}
}
private static void getImportsList(OWLOntology ontology, OWLOntologyManager om) {
List<OWLOntology> l = new ArrayList<OWLOntology>();
try {
for (OWLOntology imported : om.getDirectImports(ontology)) {
IRI importIri = imported.getOntologyID().getOntologyIRI();
if (!importsIRI.contains(importIri)) {
loadedImportsList.add(imported);
importsIRI.add(importIri);
l.add(imported);
}
}
m.put(ontology, l);
for (OWLOntology onto : l) {
getImportsList(onto, om);
}
} catch (Exception e) {
System.err.println("Error getImportsList!");
e.printStackTrace();
}
}
private static void parseZeroImports(BufferedWriter out, OWLOntology ontology) {
List all = getKeysByValue();
for (Object anAll : all) {
OWLOntology ontos = (OWLOntology) anAll;
expanded.add(ontos);
parsing_option(ontos, out);
s.add(ontos);
parseImports(out, ontology);
}
}
private static void parseImports(BufferedWriter out, OWLOntology ontology) {
for (Map.Entry<OWLOntology, List<OWLOntology>> pairs : m.entrySet()) {
Set<OWLOntology> values = cnvrt(pairs.getValue());
OWLOntology onto = pairs.getKey();
if (checkset(values)) {
if (!expanded.contains(onto)) {
parsing_option(onto, out);
expanded.add(onto);
s.add(onto);
if (onto.getOntologyID().toString().equals(ontology.getOntologyID().toString()))
System.exit(0);
parseImports(out, ontology);
}
}
}
}
private static Set<OWLOntology> cnvrt(List<OWLOntology> lst) {
Set<OWLOntology> st = new HashSet<OWLOntology>();
for (OWLOntology aux_ont : lst) {
st.add(aux_ont);
}
return st;
}
private static Boolean checkset(Collection<OWLOntology> it) {
if (it.isEmpty()) return false;
Set<OWLOntology> aux = new HashSet<OWLOntology>();
aux.addAll(it);
return equalcollections(aux);
}
private static Boolean equalcollections(Set<OWLOntology> l1) {
Boolean eq = true;
if (l1.isEmpty() || OWL2Parser.s.isEmpty())
eq = false;
for (OWLOntology ont : l1)
if (!OWL2Parser.s.contains(ont))
eq = false;
return eq;
}
private static List<OWLOntology> getKeysByValue() {
List<OWLOntology> keys = new ArrayList<OWLOntology>();
for (Map.Entry<OWLOntology, List<OWLOntology>> pairs : m.entrySet()) {
if (pairs.getValue().isEmpty()) {
keys.add(pairs.getKey());
}
}
return keys;
}
private static void parsing_option(OWLOntology onto, BufferedWriter out) {
switch (op) {
case OWL_XML:
parse2xml(onto, out);
break;
case MANCHESTER:
parse(onto, out);
break;
case RDF_XML:
parse2rdf(onto, out);
break;
}
}
private static void parse(OWLOntology onto, BufferedWriter out) {
try {
ManchesterOWLSyntaxRenderer rendi = new ManchesterOWLSyntaxRenderer(onto.getOWLOntologyManager());
rendi.render(onto, out);
} catch (OWLRendererException ex) {
System.err.println("Error by ManchesterParser!");
ex.printStackTrace();
}
}
private static void parse2xml(OWLOntology onto, BufferedWriter out) {
try {
OWLOntologyManager mngr = onto.getOWLOntologyManager();
OWLXMLRenderer ren = new OWLXMLRenderer(mngr);
ren.render(onto, out);
out.append("<Loaded name=\"" + mngr.getOntologyDocumentIRI(onto)
+ "\" ontiri=\"" + onto.getOntologyID().getOntologyIRI() + "\"/>\n");
} catch (Exception ex) {
System.err.println("Error by XMLParser!");
ex.printStackTrace();
}
}
private static void parse2rdf(OWLOntology onto, BufferedWriter out) {
try {
RDFXMLRenderer rdfrend = new RDFXMLRenderer(onto.getOWLOntologyManager(), onto, out);
rdfrend.render();
} catch (IOException ex) {
System.err.println("Error by RDFParser!");
ex.printStackTrace();
}
}
}