org.obolibrary.macro.ManchesterSyntaxTool Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of owlapi-oboformat Show documentation
Show all versions of owlapi-oboformat Show documentation
A java library for converting obo format documents to OWL, and for converting (a subset of) OWL to obo format. This version has been slightly modified to be included directly in the OWL API.
The upstream code for this module and its authors can be found at https://code.google.com/p/oboformat/.
package org.obolibrary.macro;
import java.util.Collection;
import java.util.HashSet;
import java.util.Set;
import java.util.concurrent.atomic.AtomicBoolean;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
import org.obolibrary.obo2owl.OWLAPIObo2Owl;
import org.obolibrary.oboformat.model.OBODoc;
import org.semanticweb.owlapi.OWLAPIConfigProvider;
import org.semanticweb.owlapi.expression.OWLEntityChecker;
import org.semanticweb.owlapi.expression.ShortFormEntityChecker;
import org.semanticweb.owlapi.manchestersyntax.parser.ManchesterOWLSyntaxParserImpl;
import org.semanticweb.owlapi.manchestersyntax.renderer.ParserException;
import org.semanticweb.owlapi.model.*;
import org.semanticweb.owlapi.util.BidirectionalShortFormProviderAdapter;
import org.semanticweb.owlapi.util.IRIShortFormProvider;
import org.semanticweb.owlapi.util.OntologyAxiomPair;
import org.semanticweb.owlapi.util.ShortFormProvider;
import org.semanticweb.owlapi.util.SimpleIRIShortFormProvider;
import org.semanticweb.owlapi.util.mansyntax.ManchesterOWLSyntaxParser;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* wrapper for parsing Manchester Syntax.
*
* @author heiko
*/
public class ManchesterSyntaxTool {
private static final Logger LOG = LoggerFactory.getLogger(ManchesterSyntaxTool.class);
@Nonnull
protected final IRIShortFormProvider iriShortFormProvider = new SimpleIRIShortFormProvider();
@Nonnull
private final OWLDataFactory dataFactory;
@Nonnull
private final AdvancedEntityChecker entityChecker;
@Nonnull
private final ShortFormProvider shortFormProvider = new ShortFormProvider() {
@Override
public void dispose() {
// do nothing
}
@Override
public String getShortForm(@Nonnull OWLEntity entity) {
return iriShortFormProvider.getShortForm(entity.getIRI());
}
};
private final AtomicBoolean disposed = new AtomicBoolean(false);
/**
* Create a new parser instance for the given ontology. By default, this
* parser will also try to resolve OWLObjects via their identifier or
* rdfs:label.
*
* @param inputOntology
* inputOntology
*/
public ManchesterSyntaxTool(@Nonnull OWLOntology inputOntology) {
this(inputOntology, null);
}
/**
* Create a new parser instance for the given ontologies. By default, this
* parser will also try to resolve OWLObjects via their identifier or
* rdfs:label.
*
* @param inputOntology
* inputOntology
* @param auxiliaryOntologies
* set of additional ontologies or null
*/
public ManchesterSyntaxTool(@Nonnull OWLOntology inputOntology,
@Nullable Collection auxiliaryOntologies) {
OWLOntologyManager manager = inputOntology.getOWLOntologyManager();
dataFactory = manager.getOWLDataFactory();
Set ontologies = new HashSet<>(inputOntology.getImportsClosure());
if (auxiliaryOntologies != null && !auxiliaryOntologies.isEmpty()) {
for (OWLOntology auxOnt : auxiliaryOntologies) {
ontologies.addAll(auxOnt.getImportsClosure());
}
}
ShortFormEntityChecker defaultInstance = new ShortFormEntityChecker(new BidirectionalShortFormProviderAdapter(
manager, ontologies, shortFormProvider));
entityChecker = new AdvancedEntityChecker(defaultInstance, ontologies, inputOntology.getOWLOntologyManager());
}
/**
* Parse frame expressions in Manchester syntax.
*
* @param expression
* expression
* @return set of {@link OntologyAxiomPair}
* @throws ParserException
* parser exception
*/
public Set parseManchesterExpressionFrames(@Nonnull String expression) {
ManchesterOWLSyntaxParser parser = createParser(expression);
return parser.parseFrames();
}
/**
* Parse a class expression in Manchester syntax.
*
* @param expression
* expression
* @return {@link OWLClassExpression}
* @throws ParserException
* parser exception
*/
public OWLClassExpression parseManchesterExpression(@Nonnull String expression) {
ManchesterOWLSyntaxParser parser = createParser(expression);
return parser.parseClassExpression();
}
@Nonnull
private ManchesterOWLSyntaxParser createParser(@Nonnull String expression) {
if (disposed.get()) {
throw new OWLRuntimeException("Illegal State: Trying to use an disposed instance.");
}
ManchesterOWLSyntaxParser parser = new ManchesterOWLSyntaxParserImpl(new OWLAPIConfigProvider(), dataFactory);
parser.setStringToParse(expression);
parser.setOWLEntityChecker(entityChecker);
LOG.info("parsing: {}", expression);
return parser;
}
/**
* Translate the {@link IRI} into the short form as expected by the parser.
*
* @param iri
* iri
* @return short form
*/
public String getId(@Nonnull IRI iri) {
if (disposed.get()) {
throw new OWLRuntimeException("Illegal State: Trying to use an disposed instance.");
}
return iriShortFormProvider.getShortForm(iri);
}
/**
* Translate the {@link OWLEntity} identifier into the short form as
* expected by the parser.
*
* @param entity
* entity
* @return short form
*/
public String getId(@Nonnull OWLEntity entity) {
if (disposed.get()) {
throw new OWLRuntimeException("Illegal State: Trying to use an disposed instance.");
}
return shortFormProvider.getShortForm(entity);
}
/**
* {@link OWLEntityChecker} which additionally checks for corresponding
* identifiers and labels to retrieve entities. The intended behavior is
* specified as follows:
*
* - If the string is enclosed with matching single quotes, try to resolve
* as label
* - Otherwise, try to resolve as identifier
*
*/
static class AdvancedEntityChecker implements OWLEntityChecker {
private final OWLEntityChecker defaultInstance;
private final Set ontologies;
private final OWLOntologyManager manager;
/**
* @param defaultInstance
* defaultInstance
* @param ontologies
* ontologies
* @param manager
* manager
*/
AdvancedEntityChecker(OWLEntityChecker defaultInstance, Set ontologies,
OWLOntologyManager manager) {
this.defaultInstance = defaultInstance;
this.ontologies = ontologies;
this.manager = manager;
}
@Nullable
@Override
public OWLClass getOWLClass(@Nonnull String name) {
OWLClass owlClass = defaultInstance.getOWLClass(name);
if (owlClass == null) {
IRI iri = getIRI(name);
if (iri != null) {
owlClass = getOWLClass(iri);
}
}
return owlClass;
}
@Nullable
@Override
public OWLObjectProperty getOWLObjectProperty(@Nonnull String name) {
OWLObjectProperty owlObjectProperty = defaultInstance.getOWLObjectProperty(name);
if (owlObjectProperty == null) {
IRI iri = getIRI(name);
if (iri != null) {
owlObjectProperty = getOWLObjectProperty(iri);
}
}
return owlObjectProperty;
}
@Override
public OWLDataProperty getOWLDataProperty(String name) {
return defaultInstance.getOWLDataProperty(name);
}
@Nullable
@Override
public OWLNamedIndividual getOWLIndividual(@Nonnull String name) {
OWLNamedIndividual owlIndividual = defaultInstance.getOWLIndividual(name);
if (owlIndividual == null) {
IRI iri = getIRI(name);
if (iri != null) {
owlIndividual = getOWLIndividual(iri);
}
}
return owlIndividual;
}
@Override
public OWLDatatype getOWLDatatype(String name) {
return defaultInstance.getOWLDatatype(name);
}
@Override
public OWLAnnotationProperty getOWLAnnotationProperty(String name) {
return defaultInstance.getOWLAnnotationProperty(name);
}
@Nullable
IRI getIRI(@Nonnull String name) {
if (isQuoted(name)) {
// anything in '....' quotes is a label
return getIRIByLabel(name.substring(1, name.length() - 1));
}
if (name.length() > 2 && name.charAt(0) == '<' && name.charAt(name.length() - 1) == '>') {
// anything between <...> brackets is a complete IRI
return IRI.create(name.substring(1, name.length() - 1));
}
return getIRIByIdentifier(name);
}
private static boolean isQuoted(@Nonnull String s) {
int length = s.length();
if (length >= 2) {
return s.charAt(0) == '\'' && s.charAt(length - 1) == '\'';
}
return false;
}
@Nullable
IRI getIRIByIdentifier(@Nonnull String id) {
OWLAPIObo2Owl b = new OWLAPIObo2Owl(manager);
b.setObodoc(new OBODoc());
return b.oboIdToIRI(id);
}
/**
* Retrieve an {@link IRI} by rdfs:label.
*
* @param label
* label
* @return {@link IRI} or null
*/
@Nullable
IRI getIRIByLabel(@Nonnull String label) {
for (OWLOntology o : ontologies) {
Set aas = o.getAxioms(AxiomType.ANNOTATION_ASSERTION);
for (OWLAnnotationAssertionAxiom aa : aas) {
OWLAnnotationValue v = aa.getValue();
OWLAnnotationProperty property = aa.getProperty();
if (isMatchingLabel(label, v, property)) {
OWLAnnotationSubject obj = aa.getSubject();
if (obj instanceof IRI) {
return (IRI) obj;
}
}
}
}
return null;
}
/**
* @param label
* label to match
* @param v
* annotation value
* @param property
* property to check
* @return true if property is a label, v is a literal and v matches
* label
*/
protected boolean isMatchingLabel(String label, OWLAnnotationValue v, OWLAnnotationProperty property) {
return property.isLabel() && v instanceof OWLLiteral && label.equals(((OWLLiteral) v).getLiteral());
}
/**
* Retrieve the {@link OWLClass} for a given {@link IRI}, if it has at
* least one {@link OWLDeclarationAxiom}.
*
* @param iri
* iri
* @return {@link OWLClass} or null
*/
@Nullable
OWLClass getOWLClass(@Nonnull IRI iri) {
for (OWLOntology o : ontologies) {
OWLClass c = o.getOWLOntologyManager().getOWLDataFactory().getOWLClass(iri);
if (!o.getDeclarationAxioms(c).isEmpty()) {
return c;
}
if (o.getOWLOntologyManager().getOWLDataFactory().getOWLNothing().equals(c)) {
return c;
}
}
return null;
}
/**
* Retrieve the {@link OWLNamedIndividual} for a given {@link IRI}, if
* it has at least one corresponding {@link OWLDeclarationAxiom}.
*
* @param iri
* iri
* @return {@link OWLNamedIndividual} or null
*/
@Nullable
OWLNamedIndividual getOWLIndividual(@Nonnull IRI iri) {
for (OWLOntology o : ontologies) {
OWLNamedIndividual c = o.getOWLOntologyManager().getOWLDataFactory().getOWLNamedIndividual(iri);
for (OWLDeclarationAxiom da : o.getDeclarationAxioms(c)) {
if (da.getEntity() instanceof OWLNamedIndividual) {
return (OWLNamedIndividual) da.getEntity();
}
}
}
return null;
}
/**
* Retrieve the {@link OWLObjectProperty} for a given {@link IRI}, if it
* has at least one {@link OWLDeclarationAxiom}.
*
* @param iri
* iri
* @return {@link OWLObjectProperty} or null
*/
@Nullable
OWLObjectProperty getOWLObjectProperty(@Nonnull IRI iri) {
for (OWLOntology o : ontologies) {
OWLObjectProperty p = o.getOWLOntologyManager().getOWLDataFactory().getOWLObjectProperty(iri);
if (!o.getDeclarationAxioms(p).isEmpty()) {
return p;
}
}
return null;
}
}
/**
* Call this method to dispose the internal data structures. This will
* remove also the listeners registered with the ontology manager.
*/
public void dispose() {
if (!disposed.getAndSet(true)) {
shortFormProvider.dispose();
}
}
}