public void dispose() { try { reset(); } catch (OWLException e) { logger.severe(e.getMessage()); } }
/** * Returns <code>true</code> if the ontology obtained by parsing the URI is in OWL Full. Will * report findings to the reporter as it goes. Note that the inner workings of the validator * assume that the ontology has <strong>not</strong> already been parsed. * * @param uri an <code>URI</code> value * @return a <code>boolean</code> value */ public boolean isOWLFull(URI uri) { /* * An ontology is OWL Full if: * * 1) There are OWL Full constructs used in the syntax, e.g. things have * not been explicitly typed * * or * * 2) The expressivity is Full. * */ boolean result = false; try { /* Handler that doesn't care about OWLFullExceptions */ syntaxLevel = LITE; OWLRDFErrorHandler handler = new OWLRDFErrorHandler() { public void owlFullConstruct(int code, String message) throws SAXException { /* * We know that there's some syntactic Full stuff going on, * but we don't necessarily want to throw an exception as * there may be stuff that comes up later that pushed us out * of Full, e.g. malformed RDF. */ setSyntaxLevel(FULL); explain(FULL, code, message); } public void error(String message) throws SAXException { throw new SAXException(message); } public void warning(String message) throws SAXException { message(message.toString()); } public void owlFullConstruct(int code, String message, Object obj) throws SAXException { // TODO Auto-generated method stub } }; OWLOntology o = parseFromURI(handler, uri); int species = species(o, true) | syntaxLevel; result = (species == DL || species == LITE || species == FULL); // releaseOntology( o ); } catch (ParserException ex) { explain(OTHER, UNKNOWN, ex.getMessage()); } catch (OWLException ex) { explain(OTHER, UNKNOWN, ex.getMessage()); } return result; }
/** * Returns <code>true</code> if the ontology obtained by parsing the URI is in OWL DL. Will report * findings to the reporter as it goes. Note that the inner workings of the validator assume that * the ontology has <strong>not</strong> already been parsed. * * @param uri an <code>URI</code> value * @return a <code>boolean</code> value */ public boolean isOWLDL(URI uri) { boolean result = false; try { /* Handler that's strict about OWLFullExceptions */ syntaxLevel = LITE; OWLRDFErrorHandler handler = new OWLRDFErrorHandler() { public void owlFullConstruct(int code, String message) throws SAXException { /* Doesn't throw an error, but keeps going.... */ setSyntaxLevel(FULL); explain(FULL, code, message); // throw new OWLFullConstructRDFException( message ); } public void error(String message) throws SAXException { throw new SAXException(message.toString()); } public void warning(String message) throws SAXException { message(message.toString()); } public void owlFullConstruct(int code, String message, Object obj) throws SAXException { // TODO Auto-generated method stub } }; OWLOntology o = parseFromURI(handler, uri); int species = species(o, true) | syntaxLevel; result = (species == DL || species == LITE); // releaseOntology( o ); } catch (ParserException ex) { explain(OTHER, UNKNOWN, ex.getMessage()); } catch (OWLException ex) { explain(OTHER, UNKNOWN, ex.getMessage()); } return result; }
public void renderOntology(OWLOntology ontology, Writer writer) throws RendererException { try { this.pw = new PrintWriter(writer); this.allURIs = OntologyHelper.allURIs(ontology); this.allOntologies = OntologyHelper.importClosure(ontology); this.visitor = new RenderingVisitor(this); this.definedURIs = new HashSet(); generateShortNames(); writeShortNames(); sdf = new SimpleDateFormat("yyyy-MM-dd-HH-mm-ss"); gmt = java.util.TimeZone.getTimeZone("GMT"); sdf.setTimeZone(gmt); doneThing = false; random = new Random(); anonymousIndividuals = new HashMap(); for (Iterator ontoIt = allOntologies.iterator(); ontoIt.hasNext(); ) { OWLOntology onto = (OWLOntology) ontoIt.next(); pw.println(" ;; Ontology: " + onto.getURI()); pw.println(); pw.println(" ;; Classes "); pw.println(); for (Iterator it = orderedEntities(onto.getClasses()).iterator(); it.hasNext(); ) { renderClass(onto, (OWLClass) it.next()); } pw.println(" ;; Object Properties "); for (Iterator it = orderedEntities(onto.getObjectProperties()).iterator(); it.hasNext(); ) { renderObjectProperty(onto, (OWLObjectProperty) it.next()); } pw.println(" ;; Data Properties "); for (Iterator it = orderedEntities(onto.getDataProperties()).iterator(); it.hasNext(); ) { renderDataProperty(onto, (OWLDataProperty) it.next()); } pw.println(" ;; Individuals "); for (Iterator it = orderedEntities(onto.getIndividuals()).iterator(); it.hasNext(); ) { renderIndividual(onto, (OWLIndividual) it.next()); } pw.println(" ;; Class Axioms "); for (Iterator it = orderedEntities(onto.getDatatypes()).iterator(); it.hasNext(); ) { renderDataType(onto, (OWLDataType) it.next()); } pw.println(" ;;_Datatypes "); for (Iterator it = orderedEntities(onto.getClassAxioms()).iterator(); it.hasNext(); ) { renderClassAxiom((OWLClassAxiom) it.next()); } pw.println(" ;; Property Axioms "); for (Iterator it = orderedEntities(onto.getPropertyAxioms()).iterator(); it.hasNext(); ) { renderPropertyAxiom((OWLPropertyAxiom) it.next()); } pw.println(" ;; Individual Axioms "); for (Iterator it = orderedEntities(onto.getIndividualAxioms()).iterator(); it.hasNext(); ) { renderIndividualAxiom((OWLIndividualAxiom) it.next()); } } } catch (OWLException ex) { throw new RendererException(ex.getMessage()); } }
private void checkExpressivity() throws OWLException { try { /* * Here, we need to look at all the expressions used anywhere within * the ontology and check their level. */ /* For each ontology, we need to check everything within it */ expressivityLevel = LITE; SwoopExpressionValidatorVisitor evv = new SwoopExpressionValidatorVisitor(this, objectRenderer); for (Iterator it = allOntologies.iterator(); it.hasNext(); ) { OWLOntology onto = (OWLOntology) it.next(); for (Iterator cit = onto.getClasses().iterator(); cit.hasNext(); ) { OWLClass clazz = (OWLClass) cit.next(); if (!clazz.getEnumerations(onto).isEmpty()) { /* We're in DL. */ expressivityLevel = expressivityLevel | DL; URI uri = clazz.getURI(); explain( DL, ONEOF, "Enumeration used: " + encodeHLink(uri.toString(), myModel.shortForm(uri))); } for (Iterator superit = clazz.getSuperClasses(onto).iterator(); superit.hasNext(); ) { /* Check the expressivity of any superclasses */ /* * Tricky bit here -- if there's an intersection used at * the top level, we're still ok for LITE. This is *not* * currently catered for, so we will get some stuff * wrong. */ OWLDescription description = (OWLDescription) superit.next(); evv.reset(); evv.setTopLevelDescription(true); try { description.accept(evv); expressivityLevel = expressivityLevel | evv.getLevel(); } catch (OWLException ex) { explain(OTHER, UNKNOWN, ex.getMessage()); expressivityLevel = OTHER; } } for (Iterator superit = clazz.getEquivalentClasses(onto).iterator(); superit.hasNext(); ) { /* Check the expressivity of any equivalences */ /* * This is tricky, as these expressions *can* be * intersections, as long as they're intersections of * Lite constructs. This is the only place that it can * happen in Lite. */ OWLDescription description = (OWLDescription) superit.next(); evv.reset(); evv.setTopLevelDescription(true); try { description.accept(evv); expressivityLevel = expressivityLevel | evv.getLevel(); } catch (OWLException ex) { explain(OTHER, UNKNOWN, ex.getMessage()); expressivityLevel = OTHER; } } } for (Iterator iit = onto.getObjectProperties().iterator(); iit.hasNext(); ) { OWLObjectProperty op = (OWLObjectProperty) iit.next(); for (Iterator dit = op.getDomains(onto).iterator(); dit.hasNext(); ) { /* Check the expressivity of any equivalences */ OWLDescription description = (OWLDescription) dit.next(); evv.reset(); try { description.accept(evv); expressivityLevel = expressivityLevel | evv.getLevel(); } catch (OWLException ex) { explain(OTHER, UNKNOWN, ex.getMessage()); expressivityLevel = OTHER; } } for (Iterator dit = op.getRanges(onto).iterator(); dit.hasNext(); ) { /* Check the expressivity of any equivalences */ OWLDescription description = (OWLDescription) dit.next(); evv.reset(); try { description.accept(evv); expressivityLevel = expressivityLevel | evv.getLevel(); } catch (OWLException ex) { explain(OTHER, UNKNOWN, ex.getMessage()); expressivityLevel = OTHER; } } } for (Iterator iit = onto.getDataProperties().iterator(); iit.hasNext(); ) { OWLDataProperty dp = (OWLDataProperty) iit.next(); for (Iterator dit = dp.getDomains(onto).iterator(); dit.hasNext(); ) { /* Check the expressivity of any equivalences */ OWLDescription description = (OWLDescription) dit.next(); evv.reset(); try { description.accept(evv); expressivityLevel = expressivityLevel | evv.getLevel(); } catch (OWLException ex) { explain(OTHER, UNKNOWN, ex.getMessage()); expressivityLevel = OTHER; } } for (Iterator dit = dp.getRanges(onto).iterator(); dit.hasNext(); ) { /* Check the expressivity of any equivalences */ OWLDataRange description = (OWLDataRange) dit.next(); evv.reset(); try { description.accept(evv); expressivityLevel = expressivityLevel | evv.getLevel(); } catch (OWLException ex) { explain(OTHER, UNKNOWN, ex.getMessage()); expressivityLevel = OTHER; } } } for (Iterator iit = onto.getIndividuals().iterator(); iit.hasNext(); ) { OWLIndividual ind = (OWLIndividual) iit.next(); for (Iterator typeit = ind.getTypes(onto).iterator(); typeit.hasNext(); ) { /* Check the expressivity of any equivalences */ OWLDescription description = (OWLDescription) typeit.next(); evv.reset(); try { description.accept(evv); expressivityLevel = expressivityLevel | evv.getLevel(); } catch (OWLException ex) { explain(OTHER, UNKNOWN, ex.getMessage()); expressivityLevel = OTHER; } } } } Set complexProperties = evv.getComplexProperties(); /* * Gather all the properties that are known to be functional or * inverse functional */ for (Iterator it = allOntologies.iterator(); it.hasNext(); ) { OWLOntology onto = (OWLOntology) it.next(); for (Iterator pit = onto.getObjectProperties().iterator(); pit.hasNext(); ) { OWLObjectProperty prop = (OWLObjectProperty) pit.next(); if (prop.isFunctional(onto) || prop.isInverseFunctional(onto)) { complexProperties.add(prop); } } } /* * We aren't doing everything yet as we still need to grab those * that have complex superproperties. */ /* * Now check to see if they've been said to be transitive, in which * case we're in FULL. */ for (Iterator pit = complexProperties.iterator(); pit.hasNext(); ) { OWLObjectProperty prop = (OWLObjectProperty) pit.next(); for (Iterator it = allOntologies.iterator(); it.hasNext(); ) { OWLOntology onto = (OWLOntology) it.next(); if (prop.isTransitive(onto)) { expressivityLevel = FULL; URI uri = prop.getURI(); explain( FULL, COMPLEXTRANSITIVE, "Complex property " + encodeHLink(uri.toString(), myModel.shortForm(uri)) + " asserted to be transitive."); } } } } catch (Exception ex) { ex.printStackTrace(); throw new OWLException(ex.getMessage()); } }
/** * Set the ontology that the validator will work with. Note that this performs some * initialisation. This particular implementation does not track ontology changes, so if the * ontology is changed before validation takes place, the results may not be as expected. * * @param ontology an <code>OWLOntology</code> value * @param checkImport if true, grab the imports closure and check the species of any imported * ontologies. If false, just look here. Allows us to catch situations where an ontology is * imported that has a higher expressivity, but the classes involved in that aren't explicitly * used in the importer. */ private int species(OWLOntology ontology, boolean checkImport) { int result = LITE; try { this.ontology = ontology; // logger.info( "Validating: " // + (checkImport?"[imports] ":"") // + ontology.getURI() ); if (reporter != null) { reporter.ontology(ontology); } /* Find the import closure */ this.allOntologies = OntologyHelper.importClosure(ontology); /* Do some initial processing */ gatherURIs(); /* Set up all the variables */ this.namespacesSeparated = true; this.correctOWLUsage = true; this.correctOWLNamespaceUsage = true; this.individualsTyped = true; this.classAxiomLevel = FULL; this.propertyAxiomLevel = FULL; this.expressivityLevel = FULL; /* A helper used when reporting stuff. */ objectRenderer = new ObjectRenderer(ontology); /* Now do all the relevant checks */ checkNamespaceSeparation(); checkCorrectOWLUsage(); checkCorrectOWLNamespaceUsage(); /* This should be done during parsing */ // checkIndividualTyping(); checkClassAxioms(); checkPropertyAxioms(); checkExpressivity(); if (!correctOWLNamespaceUsage) { /* * If there are things in the OWL namespace, we're in OTHER. See * http://lists.w3.org/Archives/Public/www-webont-wg/2003Feb/0157.html */ /* * This doesn't seem right though. I think it's actually the * case that any RDF document is an OWL FULL document. See * Section 1.3 of the Overview. */ // result = OTHER; result = FULL; } else if (!namespacesSeparated || !correctOWLUsage || !individualsTyped) { /* * If namespaces aren't separated, or redefinitions have * occurred, or individuals aren't all explicitly typed, we're * in Full */ result = FULL; } else { /* * Otherwise, it's the highest level that's used for classes, * properties and expressivity */ result = (classAxiomLevel | propertyAxiomLevel | expressivityLevel); } if (reporter != null) { reporter.done(level(result)); } } catch (OWLException e) { result = FULL; reporter.explain(FULL, UNKNOWN, "Exception occurred: " + e.getMessage()); } return result; }