Menu
▾
▴
[DL-Learner SVN] SF.net SVN: dl-learner:[2099] trunk/src/dl-learner/org/dllearner/tools/ore
|
From: <lor...@us...> - 2010-03-09 09:04:34
|
Revision: 2099
http://dl-learner.svn.sourceforge.net/dl-learner/?rev=2099&view=rev
Author: lorenz_b
Date: 2010-03-09 09:04:25 +0000 (Tue, 09 Mar 2010)
Log Message:
-----------
Continued axiom editing component. Refactored rendering.
Modified Paths:
--------------
trunk/src/dl-learner/org/dllearner/tools/ore/OREManager.java
trunk/src/dl-learner/org/dllearner/tools/ore/cache/OWLEntityRenderingCache.java
trunk/src/dl-learner/org/dllearner/tools/ore/ui/ExplanationTable.java
trunk/src/dl-learner/org/dllearner/tools/ore/ui/ExplanationTableModel.java
trunk/src/dl-learner/org/dllearner/tools/ore/ui/RepairTable.java
trunk/src/dl-learner/org/dllearner/tools/ore/ui/RepairTableModel.java
trunk/src/dl-learner/org/dllearner/tools/ore/ui/ResultTable.java
trunk/src/dl-learner/org/dllearner/tools/ore/ui/editor/ExpressionEditor.java
trunk/src/dl-learner/org/dllearner/tools/ore/ui/editor/OWLAutoCompleter.java
trunk/src/dl-learner/org/dllearner/tools/ore/ui/editor/OWLClassAxiomEditor.java
trunk/src/dl-learner/org/dllearner/tools/ore/ui/editor/OWLObjectPropertyAxiomEditor.java
trunk/src/dl-learner/org/dllearner/tools/ore/ui/editor/ParserUtil.java
trunk/src/dl-learner/org/dllearner/tools/ore/ui/rendering/ManchesterOWLSyntaxOWLObjectRendererImpl.java
trunk/src/dl-learner/org/dllearner/tools/ore/ui/rendering/ManchesterOWLSyntaxObjectRenderer.java
trunk/src/dl-learner/org/dllearner/tools/ore/ui/rendering/ManchesterSyntaxRenderer.java
trunk/src/dl-learner/org/dllearner/tools/ore/ui/rendering/ManchesterSyntaxTableCellRenderer.java
trunk/src/dl-learner/org/dllearner/tools/ore/ui/rendering/TextAreaRenderer.java
Added Paths:
-----------
trunk/src/dl-learner/org/dllearner/tools/ore/cache/DLSyntaxRenderingCache.java
trunk/src/dl-learner/org/dllearner/tools/ore/cache/LRUMap.java
trunk/src/dl-learner/org/dllearner/tools/ore/cache/ManchesterSyntaxRenderingCache.java
trunk/src/dl-learner/org/dllearner/tools/ore/ui/editor/ManchesterOWLSyntaxParser.java
trunk/src/dl-learner/org/dllearner/tools/ore/ui/editor/OWLAxiomChecker.java
trunk/src/dl-learner/org/dllearner/tools/ore/ui/editor/OWLAxiomsEditor.java
trunk/src/dl-learner/org/dllearner/tools/ore/ui/editor/ParserException.java
Removed Paths:
-------------
trunk/src/dl-learner/org/dllearner/tools/ore/cache/OWLObjectRenderingCache.java
Modified: trunk/src/dl-learner/org/dllearner/tools/ore/OREManager.java
===================================================================
--- trunk/src/dl-learner/org/dllearner/tools/ore/OREManager.java 2010-03-09 08:52:35 UTC (rev 2098)
+++ trunk/src/dl-learner/org/dllearner/tools/ore/OREManager.java 2010-03-09 09:04:25 UTC (rev 2099)
@@ -34,17 +34,16 @@
import org.dllearner.learningproblems.ClassLearningProblem;
import org.dllearner.learningproblems.EvaluatedDescriptionClass;
import org.dllearner.reasoning.PelletReasoner;
+import org.dllearner.tools.ore.cache.DLSyntaxRenderingCache;
+import org.dllearner.tools.ore.cache.ManchesterSyntaxRenderingCache;
import org.dllearner.tools.ore.cache.OWLEntityRenderingCache;
-import org.dllearner.tools.ore.cache.OWLObjectRenderingCache;
import org.dllearner.tools.ore.ui.DescriptionLabel;
import org.dllearner.tools.ore.ui.editor.OWLEntityFinder;
import org.dllearner.tools.ore.ui.rendering.KeywordColorMap;
-import org.dllearner.tools.ore.ui.rendering.ManchesterOWLSyntaxOWLObjectRendererImpl;
import org.dllearner.tools.ore.ui.rendering.OWLEntityRenderer;
import org.dllearner.utilities.owl.OWLAPIConverter;
import org.mindswap.pellet.exceptions.InconsistentOntologyException;
import org.mindswap.pellet.utils.SetUtils;
-import org.semanticweb.owl.io.OWLObjectRenderer;
import org.semanticweb.owl.io.OWLXMLOntologyFormat;
import org.semanticweb.owl.model.OWLAxiom;
import org.semanticweb.owl.model.OWLDataFactory;
@@ -56,7 +55,6 @@
import org.semanticweb.owl.model.OWLOntologyCreationException;
import org.semanticweb.owl.model.OWLOntologyStorageException;
import org.semanticweb.owl.model.UnknownOWLOntologyException;
-import org.semanticweb.owl.util.SimpleShortFormProvider;
public class OREManager {
@@ -84,9 +82,9 @@
private double threshold;
private int minInstanceCount;
- private OWLObjectRenderingCache owlObjectRenderingCache;
+ private ManchesterSyntaxRenderingCache manchesterSyntaxRenderingCache;
+ private DLSyntaxRenderingCache dlSyntaxRenderingCache;
private OWLEntityRenderingCache owlEntityRenderingCache;
- private OWLObjectRenderer owlObjectRenderer;
private OWLEntityRenderer owlEntityRenderer;
private OWLEntityFinder owlEntityFinder;
private Map<String, Color> keywordColorMap;
@@ -100,11 +98,9 @@
public OREManager(){
cm = ComponentManager.getInstance();
listeners = new ArrayList<OREManagerListener>();
- owlObjectRenderingCache = new OWLObjectRenderingCache(this);
- owlEntityRenderingCache = new OWLEntityRenderingCache();
- owlEntityRenderingCache.setOREManager(this);
- owlObjectRenderer = new ManchesterOWLSyntaxOWLObjectRendererImpl();
- owlObjectRenderer.setShortFormProvider(new SimpleShortFormProvider());
+ manchesterSyntaxRenderingCache = new ManchesterSyntaxRenderingCache(this);
+ dlSyntaxRenderingCache = new DLSyntaxRenderingCache(this);
+ owlEntityRenderingCache = new OWLEntityRenderingCache(this);
owlEntityRenderer = new OWLEntityRenderer();
keywordColorMap = new KeywordColorMap();
}
@@ -285,7 +281,7 @@
return prefixes;
}
- public String getRendering(OWLObject object){
+ public String getManchesterSyntaxRendering(OWLObject object){
if(object instanceof OWLEntity){
String rendering = owlEntityRenderingCache.getRendering((OWLEntity) object);
if(rendering != null) {
@@ -295,9 +291,21 @@
return owlEntityRenderer.render((OWLEntity) object);
}
}
- return owlObjectRenderingCache.getRendering(object, owlObjectRenderer);
+ return manchesterSyntaxRenderingCache.getRendering(object);
}
+ public String getManchesterSyntaxRendering(Description description){
+ return manchesterSyntaxRenderingCache.getRendering(description);
+ }
+
+ public String getManchesterSyntaxRendering(Individual individual){
+ return manchesterSyntaxRenderingCache.getRendering(individual);
+ }
+
+ public String getDLSyntaxRendering(OWLObject object){
+ return dlSyntaxRenderingCache.getRendering(object);
+ }
+
public OWLEntityRenderer getOWLEntityRenderer(){
return owlEntityRenderer;
}
Added: trunk/src/dl-learner/org/dllearner/tools/ore/cache/DLSyntaxRenderingCache.java
===================================================================
--- trunk/src/dl-learner/org/dllearner/tools/ore/cache/DLSyntaxRenderingCache.java (rev 0)
+++ trunk/src/dl-learner/org/dllearner/tools/ore/cache/DLSyntaxRenderingCache.java 2010-03-09 09:04:25 UTC (rev 2099)
@@ -0,0 +1,63 @@
+package org.dllearner.tools.ore.cache;
+
+import java.util.Map;
+
+import org.dllearner.tools.ore.OREManager;
+import org.dllearner.tools.ore.OREManagerListener;
+import org.semanticweb.owl.model.OWLObject;
+
+import uk.ac.manchester.cs.owl.dlsyntax.DLSyntaxObjectRenderer;
+
+public class DLSyntaxRenderingCache {
+
+ Map<OWLObject, String> cache = new LRUMap<OWLObject, String>(50, 1, 50);
+ DLSyntaxObjectRenderer renderer = new DLSyntaxObjectRenderer();
+
+ private OREManagerListener l = new OREManagerListener(){
+ @Override
+ public void activeOntologyChanged() {
+ clear();
+ }
+ };
+
+// private OWLOntologyChangeListener l2 = new OWLOntologyChangeListener(){
+// public void ontologiesChanged(List<? extends OWLOntologyChange> owlOntologyChanges) throws OWLException {
+// clear();
+// }
+// };
+
+ private OREManager mngr;
+
+
+ public DLSyntaxRenderingCache(OREManager oreManager) {
+ this.mngr = oreManager;
+ oreManager.addListener(l);
+ }
+
+
+ public void clear() {
+ cache.clear();
+ }
+
+
+ public String getRendering(OWLObject object) {
+ String s = null;
+ if (s == null){
+ s = cache.get(object);
+ if (s == null){
+ s = renderer.render(object);
+ cache.put(object, s);
+ }
+ }
+ return s;
+ }
+
+
+ public void dispose() {
+ clear();
+ mngr.removeListener(l);
+ }
+
+
+
+}
Added: trunk/src/dl-learner/org/dllearner/tools/ore/cache/LRUMap.java
===================================================================
--- trunk/src/dl-learner/org/dllearner/tools/ore/cache/LRUMap.java (rev 0)
+++ trunk/src/dl-learner/org/dllearner/tools/ore/cache/LRUMap.java 2010-03-09 09:04:25 UTC (rev 2099)
@@ -0,0 +1,21 @@
+package org.dllearner.tools.ore.cache;
+
+import java.util.LinkedHashMap;
+import java.util.Map;
+
+public class LRUMap<K, V> extends LinkedHashMap<K, V>{
+ /**
+ *
+ */
+ private static final long serialVersionUID = 7878033647212810101L;
+ private int maxCapacity;
+
+ public LRUMap(int initialCapacity, float loadFactor, int maxCapacity) {
+ super(initialCapacity, loadFactor, true);
+ this.maxCapacity = maxCapacity;
+ }
+
+ protected boolean removeEldestEntry(Map.Entry<K,V> eldest) {
+ return size() >= this.maxCapacity;
+ }
+}
Copied: trunk/src/dl-learner/org/dllearner/tools/ore/cache/ManchesterSyntaxRenderingCache.java (from rev 2093, trunk/src/dl-learner/org/dllearner/tools/ore/cache/OWLObjectRenderingCache.java)
===================================================================
--- trunk/src/dl-learner/org/dllearner/tools/ore/cache/ManchesterSyntaxRenderingCache.java (rev 0)
+++ trunk/src/dl-learner/org/dllearner/tools/ore/cache/ManchesterSyntaxRenderingCache.java 2010-03-09 09:04:25 UTC (rev 2099)
@@ -0,0 +1,87 @@
+package org.dllearner.tools.ore.cache;
+
+import java.util.Map;
+
+import org.dllearner.core.owl.Description;
+import org.dllearner.core.owl.Individual;
+import org.dllearner.tools.ore.OREManager;
+import org.dllearner.tools.ore.OREManagerListener;
+import org.dllearner.tools.ore.ui.rendering.ManchesterOWLSyntaxOWLObjectRendererImpl;
+import org.dllearner.utilities.owl.OWLAPIConverter;
+import org.dllearner.utilities.owl.OWLAPIDescriptionConvertVisitor;
+import org.semanticweb.owl.io.OWLObjectRenderer;
+import org.semanticweb.owl.model.OWLObject;
+import org.semanticweb.owl.util.SimpleShortFormProvider;
+
+public class ManchesterSyntaxRenderingCache {
+
+ private OWLObjectRenderer renderer;
+
+ Map<OWLObject, String> owlObjectCache = new LRUMap<OWLObject, String>(50, 1, 50);
+ Map<Description, String> descriptionCache = new LRUMap<Description, String>(50, 1, 50);
+ Map<Individual, String> individualCache = new LRUMap<Individual, String>(50, 1, 50);
+
+ private OREManager mngr;
+
+ private OREManagerListener l = new OREManagerListener() {
+ @Override
+ public void activeOntologyChanged() {
+ clear();
+ }
+ };
+
+ // private OWLOntologyChangeListener l2 = new OWLOntologyChangeListener(){
+ // public void ontologiesChanged(List<? extends OWLOntologyChange>
+ // owlOntologyChanges) throws OWLException {
+ // clear();
+ // }
+ // };
+
+ public ManchesterSyntaxRenderingCache(OREManager oreManager) {
+ this.mngr = oreManager;
+ oreManager.addListener(l);
+ renderer = new ManchesterOWLSyntaxOWLObjectRendererImpl();
+ renderer.setShortFormProvider(new SimpleShortFormProvider());
+ }
+
+ public void clear() {
+ owlObjectCache.clear();
+ descriptionCache.clear();
+ }
+
+ public String getRendering(OWLObject object) {
+ String s = null;
+ s = owlObjectCache.get(object);
+ if (s == null) {
+ s = renderer.render(object);
+ owlObjectCache.put(object, s);
+ }
+ return s;
+ }
+
+ public String getRendering(Description description) {
+ String s = null;
+ s = descriptionCache.get(description);
+ if (s == null) {
+ s = renderer.render(OWLAPIDescriptionConvertVisitor.getOWLDescription(description));
+ descriptionCache.put(description, s);
+ }
+ return s;
+ }
+
+ public String getRendering(Individual individual) {
+ String s = null;
+ s = individualCache.get(individual);
+ if (s == null) {
+ s = renderer.render(OWLAPIConverter.getOWLAPIIndividual(individual));
+ individualCache.put(individual, s);
+ }
+ return s;
+ }
+
+ public void dispose() {
+ clear();
+ mngr.removeListener(l);
+ }
+
+}
Modified: trunk/src/dl-learner/org/dllearner/tools/ore/cache/OWLEntityRenderingCache.java
===================================================================
--- trunk/src/dl-learner/org/dllearner/tools/ore/cache/OWLEntityRenderingCache.java 2010-03-09 08:52:35 UTC (rev 2098)
+++ trunk/src/dl-learner/org/dllearner/tools/ore/cache/OWLEntityRenderingCache.java 2010-03-09 09:04:25 UTC (rev 2099)
@@ -23,15 +23,6 @@
import org.semanticweb.owl.model.OWLOntologyChangeListener;
-/**
- * Author: Matthew Horridge<br>
- * The University Of Manchester<br>
- * Medical Informatics Group<br>
- * Date: 21-Sep-2006<br><br>
- * <p/>
- * mat...@cs...<br>
- * www.cs.man.ac.uk/~horridgm<br><br>
- */
public class OWLEntityRenderingCache{
private static final Logger logger = Logger.getLogger(OWLEntityRenderingCache.class);
@@ -66,14 +57,9 @@
};
- public OWLEntityRenderingCache() {
- }
-
-
- public void setOREManager(OREManager oreManager) {
- this.oreManager = oreManager;
+ public OWLEntityRenderingCache(OREManager oreManager) {
+ this.oreManager = oreManager;
oreManager.addListener(oreManagerListener);
-// owlModelManager.addOntologyChangeListener(listener);
}
@@ -128,7 +114,7 @@
public void dispose() {
clear();
-// owlModelManager.removeOntologyChangeListener(listener);
+ oreManager.removeListener(oreManagerListener);
}
@@ -226,7 +212,7 @@
private <T extends OWLEntity> void addRendering(T entity, Map<String, T> map) {
if (!entityRenderingMap.containsKey(entity)) {
- String rendering = oreManager.getRendering(entity);
+ String rendering = oreManager.getManchesterSyntaxRendering(entity);
map.put(rendering, entity);
entityRenderingMap.put(entity, rendering);
}
Deleted: trunk/src/dl-learner/org/dllearner/tools/ore/cache/OWLObjectRenderingCache.java
===================================================================
--- trunk/src/dl-learner/org/dllearner/tools/ore/cache/OWLObjectRenderingCache.java 2010-03-09 08:52:35 UTC (rev 2098)
+++ trunk/src/dl-learner/org/dllearner/tools/ore/cache/OWLObjectRenderingCache.java 2010-03-09 09:04:25 UTC (rev 2099)
@@ -1,89 +0,0 @@
-package org.dllearner.tools.ore.cache;
-
-import java.util.LinkedHashMap;
-import java.util.Map;
-
-import org.dllearner.tools.ore.OREManager;
-import org.dllearner.tools.ore.OREManagerListener;
-import org.protege.editor.core.Disposable;
-import org.semanticweb.owl.io.OWLObjectRenderer;
-import org.semanticweb.owl.model.OWLObject;
-
-/**
- * Author: drummond<br>
- * http://www.cs.man.ac.uk/~drummond/<br><br>
- * <p/>
- * The University Of Manchester<br>
- * Bio Health Informatics Group<br>
- * Date: Jun 27, 2008<br><br>
- */
-public class OWLObjectRenderingCache implements Disposable {
-
- Map<OWLObject, String> cache = new MyLRUMap<OWLObject, String>(50, 1, 50);
-
- private OREManagerListener l = new OREManagerListener(){
- @Override
- public void activeOntologyChanged() {
- clear();
- }
- };
-
-// private OWLOntologyChangeListener l2 = new OWLOntologyChangeListener(){
-// public void ontologiesChanged(List<? extends OWLOntologyChange> owlOntologyChanges) throws OWLException {
-// clear();
-// }
-// };
-
- private OREManager mngr;
-
-
- public OWLObjectRenderingCache(OREManager oreManager) {
- this.mngr = oreManager;
- oreManager.addListener(l);
- }
-
-
- public void clear() {
- cache.clear();
- }
-
-
- public String getRendering(OWLObject object, OWLObjectRenderer owlObjectRenderer) {
- String s = null;
-// if (object instanceof OWLClassExpression){
-// String userRendering = OWLExpressionUserCache.getInstance(mngr).getRendering((OWLClassExpression) object);
-// if (userRendering != null){
-// s = userRendering;
-// cache.put(object, s);
-// }
-// }
- if (s == null){
- s = cache.get(object);
- if (s == null){
- s = owlObjectRenderer.render(object);
- cache.put(object, s);
- }
- }
- return s;
- }
-
-
- public void dispose() {
- clear();
- mngr.removeListener(l);
- }
-
-
- class MyLRUMap<K,V> extends LinkedHashMap<K,V> {
- private int maxCapacity;
-
- public MyLRUMap(int initialCapacity, float loadFactor, int maxCapacity) {
- super(initialCapacity, loadFactor, true);
- this.maxCapacity = maxCapacity;
- }
-
- protected boolean removeEldestEntry(Map.Entry<K,V> eldest) {
- return size() >= this.maxCapacity;
- }
- }
-}
Modified: trunk/src/dl-learner/org/dllearner/tools/ore/ui/ExplanationTable.java
===================================================================
--- trunk/src/dl-learner/org/dllearner/tools/ore/ui/ExplanationTable.java 2010-03-09 08:52:35 UTC (rev 2098)
+++ trunk/src/dl-learner/org/dllearner/tools/ore/ui/ExplanationTable.java 2010-03-09 09:04:25 UTC (rev 2099)
@@ -39,8 +39,7 @@
import org.dllearner.tools.ore.explanation.Explanation;
import org.dllearner.tools.ore.ui.editor.InputVerificationStatusChangedListener;
import org.dllearner.tools.ore.ui.editor.OWLAxiomEditor;
-import org.dllearner.tools.ore.ui.editor.OWLClassAxiomEditor;
-import org.dllearner.tools.ore.ui.editor.OWLObjectPropertyAxiomEditor;
+import org.dllearner.tools.ore.ui.editor.OWLAxiomsEditor;
import org.dllearner.tools.ore.ui.editor.VerifiedInputEditor;
import org.dllearner.tools.ore.ui.editor.VerifyingOptionPane;
import org.dllearner.tools.ore.ui.rendering.TextAreaRenderer;
@@ -51,15 +50,11 @@
import org.semanticweb.owl.model.AddAxiom;
import org.semanticweb.owl.model.OWLAxiom;
import org.semanticweb.owl.model.OWLClass;
-import org.semanticweb.owl.model.OWLClassAxiom;
import org.semanticweb.owl.model.OWLObject;
-import org.semanticweb.owl.model.OWLObjectPropertyAxiom;
import org.semanticweb.owl.model.OWLOntology;
import org.semanticweb.owl.model.OWLOntologyChange;
import org.semanticweb.owl.model.RemoveAxiom;
-import uk.ac.manchester.cs.owl.dlsyntax.DLSyntaxObjectRenderer;
-
public class ExplanationTable extends JXTable implements RepairManagerListener, Disposable{
/**
@@ -68,8 +63,9 @@
private static final long serialVersionUID = 5580730282611559609L;
private RepairManager repMan;
- DLSyntaxObjectRenderer renderer = new DLSyntaxObjectRenderer();
+ private OREManager oreMan;
+
protected String[] columnToolTips = {
null,
"The number of already computed explanations wherein the axiom occurs.",
@@ -81,16 +77,17 @@
public ExplanationTable(Explanation exp, OWLClass cl) {
-
+ oreMan = OREManager.getInstance();
repMan = RepairManager.getInstance(OREManager.getInstance());
-
repMan.addListener(this);
+
setBackground(Color.WHITE);
setAutoResizeMode(JTable.AUTO_RESIZE_OFF);
setModel(new ExplanationTableModel(exp, cl));
setRolloverEnabled(true);
addHighlighter(new ColorHighlighter(HighlightPredicate.ROLLOVER_ROW,
Color.YELLOW, Color.BLACK));
+
TableColumn column6 = getColumn(5);
column6.setCellRenderer(new ButtonCellRenderer());
column6.setCellEditor(new ButtonCellEditor());
@@ -183,9 +180,7 @@
java.awt.Point p = e.getPoint();
int rowIndex = rowAtPoint(p);
if(rowIndex != -1){
-
-// tip = ((ExplanationTableModel)getModel()).getOWLAxiomAtRow(rowIndex).toString();
- tip = renderer.render(((ExplanationTableModel)getModel()).getOWLAxiomAtRow(rowIndex));
+ tip = oreMan.getDLSyntaxRendering(((ExplanationTableModel)getModel()).getOWLAxiomAtRow(rowIndex));
} else {
tip = super.getToolTipText(e);
}
@@ -265,15 +260,18 @@
public void actionPerformed(ActionEvent e) {
fireEditingStopped();
OWLAxiom ax = ((ExplanationTableModel)getModel()).getOWLAxiomAtRow(row);
- if(ax instanceof OWLClassAxiom){
- OWLClassAxiomEditor editor = new OWLClassAxiomEditor(OREManager.getInstance());
- editor.setEditedObject((OWLClassAxiom) ax);
- showEditorDialog(editor, ax);
- } else if(ax instanceof OWLObjectPropertyAxiom){
- OWLObjectPropertyAxiomEditor editor = new OWLObjectPropertyAxiomEditor(OREManager.getInstance());
- editor.setEditedObject((OWLObjectPropertyAxiom) ax);
- showEditorDialog(editor, ax);
- }
+ OWLAxiomsEditor editor = new OWLAxiomsEditor(oreMan);
+ editor.setEditedObject(ax);
+ showEditorDialog(editor, ax);
+// if(ax instanceof OWLClassAxiom){
+// OWLClassAxiomEditor editor = new OWLClassAxiomEditor(OREManager.getInstance());
+// editor.setEditedObject((OWLClassAxiom) ax);
+// showEditorDialog(editor, ax);
+// } else if(ax instanceof OWLObjectPropertyAxiom){
+// OWLObjectPropertyAxiomEditor editor = new OWLObjectPropertyAxiomEditor(OREManager.getInstance());
+// editor.setEditedObject((OWLObjectPropertyAxiom) ax);
+// showEditorDialog(editor, ax);
+// }
}
}
@@ -341,7 +339,6 @@
}
final Component parent = SwingUtilities.getAncestorOfClass(Frame.class, getParent());
final JDialog dlg = optionPane.createDialog(parent, null);
- // The editor shouldn't be modal (or should it?)
dlg.setModal(false);
dlg.setResizable(true);
dlg.pack();
@@ -363,7 +360,7 @@
}
});
- dlg.setTitle(OREManager.getInstance().getRendering(value));
+ dlg.setTitle(OREManager.getInstance().getManchesterSyntaxRendering(value));
dlg.setVisible(true);
}
Modified: trunk/src/dl-learner/org/dllearner/tools/ore/ui/ExplanationTableModel.java
===================================================================
--- trunk/src/dl-learner/org/dllearner/tools/ore/ui/ExplanationTableModel.java 2010-03-09 08:52:35 UTC (rev 2098)
+++ trunk/src/dl-learner/org/dllearner/tools/ore/ui/ExplanationTableModel.java 2010-03-09 09:04:25 UTC (rev 2099)
@@ -59,6 +59,7 @@
if(strikeOutIrrelevantParts){
return ManchesterSyntaxRenderer.render(ax, impMan.isSelected(ax), depth2Root, laconicExplanation);
} else {
+// return ax;
// return OREManager.getInstance().getRendering(ax);
return ManchesterSyntaxRenderer.render(ax, impMan.isSelected(ax), depth2Root);
}
Modified: trunk/src/dl-learner/org/dllearner/tools/ore/ui/RepairTable.java
===================================================================
--- trunk/src/dl-learner/org/dllearner/tools/ore/ui/RepairTable.java 2010-03-09 08:52:35 UTC (rev 2098)
+++ trunk/src/dl-learner/org/dllearner/tools/ore/ui/RepairTable.java 2010-03-09 09:04:25 UTC (rev 2099)
@@ -35,7 +35,6 @@
setShowHorizontalLines(true);
setGridColor(Color.LIGHT_GRAY);
setTableHeader(null);
- setRowHeightEnabled(true);
getColumn(0).setMaxWidth(30);
getColumn(1).setCellRenderer(new TextAreaRenderer());
getColumn(2).setMaxWidth(40);
Modified: trunk/src/dl-learner/org/dllearner/tools/ore/ui/RepairTableModel.java
===================================================================
--- trunk/src/dl-learner/org/dllearner/tools/ore/ui/RepairTableModel.java 2010-03-09 08:52:35 UTC (rev 2098)
+++ trunk/src/dl-learner/org/dllearner/tools/ore/ui/RepairTableModel.java 2010-03-09 09:04:25 UTC (rev 2099)
@@ -43,16 +43,15 @@
}
public Object getValueAt(int rowIndex, int columnIndex) {
-
- if(columnIndex == 0){
+
+ if (columnIndex == 0) {
if (repairPlan.get(rowIndex) instanceof RemoveAxiom) {
return "–";
} else {
return "+";
}
} else if (columnIndex == 1) {
- return ManchesterSyntaxRenderer.render(repairPlan.get(rowIndex)
- .getAxiom(), false, 0);
+ return ManchesterSyntaxRenderer.render(repairPlan.get(rowIndex).getAxiom(), false, 0);
} else {
return null;
}
Modified: trunk/src/dl-learner/org/dllearner/tools/ore/ui/ResultTable.java
===================================================================
--- trunk/src/dl-learner/org/dllearner/tools/ore/ui/ResultTable.java 2010-03-09 08:52:35 UTC (rev 2098)
+++ trunk/src/dl-learner/org/dllearner/tools/ore/ui/ResultTable.java 2010-03-09 09:04:25 UTC (rev 2099)
@@ -26,9 +26,11 @@
// setAutoResizeMode(JTable.AUTO_RESIZE_OFF);
setModel(new ResultTableModel());
setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
+
ProgressBarTableCellRenderer renderer = new ProgressBarTableCellRenderer();
renderer.setBackground(getBackground());
getColumn(0).setCellRenderer(renderer);
+
getColumn(1).setCellRenderer(new ManchesterSyntaxTableCellRenderer());
setColumnSizes();
getColumn(0).setResizable(false);
@@ -41,9 +43,7 @@
private void setColumnSizes(){
getColumn(0).setMaxWidth(100);
-
getColumn(1).setPreferredWidth(430);
-
}
Modified: trunk/src/dl-learner/org/dllearner/tools/ore/ui/editor/ExpressionEditor.java
===================================================================
--- trunk/src/dl-learner/org/dllearner/tools/ore/ui/editor/ExpressionEditor.java 2010-03-09 08:52:35 UTC (rev 2098)
+++ trunk/src/dl-learner/org/dllearner/tools/ore/ui/editor/ExpressionEditor.java 2010-03-09 09:04:25 UTC (rev 2099)
@@ -133,7 +133,7 @@
setText("");
}
else if (desc instanceof OWLObject) {
- String rendering = mngr.getRendering((OWLObject) desc);
+ String rendering = mngr.getManchesterSyntaxRendering((OWLObject) desc);
setText(rendering);
}
else if (desc instanceof Collection){
@@ -143,7 +143,7 @@
if (sb.length() > 0){
sb.append(", ");
}
- sb.append(mngr.getRendering((OWLObject)obj));
+ sb.append(mngr.getManchesterSyntaxRendering((OWLObject)obj));
}
}
setText(sb.toString());
Added: trunk/src/dl-learner/org/dllearner/tools/ore/ui/editor/ManchesterOWLSyntaxParser.java
===================================================================
--- trunk/src/dl-learner/org/dllearner/tools/ore/ui/editor/ManchesterOWLSyntaxParser.java (rev 0)
+++ trunk/src/dl-learner/org/dllearner/tools/ore/ui/editor/ManchesterOWLSyntaxParser.java 2010-03-09 09:04:25 UTC (rev 2099)
@@ -0,0 +1,2271 @@
+package org.dllearner.tools.ore.ui.editor;
+
+
+import java.net.URI;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+import org.coode.manchesterowlsyntax.ManchesterOWLSyntax;
+import org.coode.manchesterowlsyntax.ManchesterOWLSyntaxTokenizer;
+import org.semanticweb.owl.expression.OWLEntityChecker;
+import org.semanticweb.owl.model.AddAxiom;
+import org.semanticweb.owl.model.OWLAnnotation;
+import org.semanticweb.owl.model.OWLAxiom;
+import org.semanticweb.owl.model.OWLClass;
+import org.semanticweb.owl.model.OWLClassAxiom;
+import org.semanticweb.owl.model.OWLConstant;
+import org.semanticweb.owl.model.OWLDataFactory;
+import org.semanticweb.owl.model.OWLDataProperty;
+import org.semanticweb.owl.model.OWLDataPropertyExpression;
+import org.semanticweb.owl.model.OWLDataRange;
+import org.semanticweb.owl.model.OWLDataRangeFacetRestriction;
+import org.semanticweb.owl.model.OWLDataType;
+import org.semanticweb.owl.model.OWLDescription;
+import org.semanticweb.owl.model.OWLEntity;
+import org.semanticweb.owl.model.OWLImportsDeclaration;
+import org.semanticweb.owl.model.OWLIndividual;
+import org.semanticweb.owl.model.OWLObjectProperty;
+import org.semanticweb.owl.model.OWLObjectPropertyAxiom;
+import org.semanticweb.owl.model.OWLObjectPropertyChainSubPropertyAxiom;
+import org.semanticweb.owl.model.OWLObjectPropertyExpression;
+import org.semanticweb.owl.model.OWLOntology;
+import org.semanticweb.owl.model.OWLOntologyChange;
+import org.semanticweb.owl.model.OWLOntologyChangeException;
+import org.semanticweb.owl.model.OWLOntologyCreationException;
+import org.semanticweb.owl.model.OWLOntologyManager;
+import org.semanticweb.owl.model.SetOntologyURI;
+import org.semanticweb.owl.util.CollectionFactory;
+import org.semanticweb.owl.util.NamespaceUtil;
+import org.semanticweb.owl.vocab.Namespaces;
+import org.semanticweb.owl.vocab.OWLRDFVocabulary;
+import org.semanticweb.owl.vocab.OWLRestrictedDataRangeFacetVocabulary;
+import org.semanticweb.owl.vocab.XSDVocabulary;
+
+
+/**
+ * Author: Matthew Horridge<br>
+ * The University Of Manchester<br>
+ * Bio-Health Informatics Group<br>
+ * Date: 10-Sep-2007<br><br>
+ * <p/>
+ * A parser for the Manchester OWL Syntax.
+ * All properties must be defined before they are used. For example,
+ * consider the restriction hasPart some Leg. The parser must know
+ * in advance whether or not hasPart is an object property or a data
+ * property so that Leg gets parsed correctly. In a tool, such as an
+ * editor, it is expected that hasPart will already exists as either
+ * a data property or an object property. If a complete ontology is
+ * being parsed, it is expected that hasPart will have been defined at
+ * the top of the file before it is used in any class descriptions or
+ * property assertions (e.g. ObjectProperty: hasPart)
+ */
+public class ManchesterOWLSyntaxParser {
+
+ // This parser was built by hand! After stuggling with terrible
+ // error messages produced by ANTLR (or JavaCC) I decides to construct
+ // this parser by hand. The error messages that this parser generates
+ // are specific to the Manchester OWL Syntax and are such that it should
+ // be easy to use this parser in tools such as editors.
+
+ private OWLDataFactory dataFactory;
+
+
+ private OWLEntityChecker owlEntityChecker;
+
+ private final String EOF = "<EOF>";
+
+ private Set<Character> skip = new HashSet<Character>();
+
+ private Set<Character> delims = new HashSet<Character>();
+
+ private Set<Character> escapeChars = new HashSet<Character>();
+
+ private String base;
+
+ private Set<String> classNames;
+
+ private Set<String> objectPropertyNames;
+
+ private Set<String> dataPropertyNames;
+
+ private Set<String> individualNames;
+
+ private Set<String> dataTypeNames;
+
+ private Set<String> annotationURIs;
+
+ private Set<String> restrictionKeywords;
+
+ private Map<String, URI> namespaceMap;
+
+ private int col = 0;
+
+ private int tokenStartCol = 0;
+
+ private int line = 0;
+
+ private int tokenStartPos;
+
+ private String token;
+
+ private String bufferedToken = null;
+
+ private String buffer;
+
+ private int pos;
+
+ private static final String AND = ManchesterOWLSyntax.AND.toString();
+
+ private static final String OR = ManchesterOWLSyntax.OR.toString();
+
+ private static final String INV = ManchesterOWLSyntax.INVERSE.toString();
+
+ private static final String SOME = ManchesterOWLSyntax.SOME.toString();
+
+ private static final String SELF = ManchesterOWLSyntax.SELF.toString();
+
+ private static final String ONLY = ManchesterOWLSyntax.ONLY.toString();
+
+ private static final String VALUE = ManchesterOWLSyntax.VALUE.toString();
+
+ private static final String MIN = ManchesterOWLSyntax.MIN.toString();
+
+ private static final String MAX = ManchesterOWLSyntax.MAX.toString();
+
+ private static final String EXACTLY = ManchesterOWLSyntax.EXACTLY.toString();
+
+ private static final String ONLYSOME = ManchesterOWLSyntax.ONLYSOME.toString();
+
+ private static final String NOT = ManchesterOWLSyntax.NOT.toString();
+
+ private static final String CLASS = ManchesterOWLSyntax.CLASS.toString() + ":";
+
+ private static final String SUB_CLASS_OF = ManchesterOWLSyntax.SUBCLASS_OF.toString() + ":";
+
+ private static final String EQUIVALENT_TO = ManchesterOWLSyntax.EQUIVALENT_TO.toString() + ":";
+
+ private static final String DISJOINT_WITH = ManchesterOWLSyntax.DISJOINT_WITH.toString() + ":";
+
+ private static final String OBJECT_PROPERTY = ManchesterOWLSyntax.OBJECT_PROPERTY.toString() + ":";
+
+ private static final String DATA_PROPERTY = ManchesterOWLSyntax.DATA_PROPERTY.toString() + ":";
+
+ private static final String SUB_PROPERTY_OF = ManchesterOWLSyntax.SUB_PROPERTY_OF.toString() + ":";
+
+ private static final String DOMAIN = ManchesterOWLSyntax.DOMAIN.toString() + ":";
+
+ private static final String RANGE = ManchesterOWLSyntax.RANGE.toString() + ":";
+
+ private static final String CHARACTERISTICS = ManchesterOWLSyntax.CHARACTERISTICS.toString() + ":";
+
+ private static final String INDIVIDUAL = ManchesterOWLSyntax.INDIVIDUAL.toString() + ":";
+
+ private static final String ANNOTATIONS = ManchesterOWLSyntax.ANNOTATIONS.toString() + ":";
+
+ private static final String TYPES = ManchesterOWLSyntax.TYPES.toString() + ":";
+
+ private static final String FACTS = ManchesterOWLSyntax.FACTS.toString() + ":";
+
+ private static final String SAME_AS = ManchesterOWLSyntax.SAME_AS.toString() + ":";
+
+ private static final String DIFFERENT_FROM = ManchesterOWLSyntax.DIFFERENT_FROM.toString() + ":";
+
+ private static final String VALUE_PARTITION = "ValuePartition:";
+
+ private static final String ONTOLOGY = ManchesterOWLSyntax.ONTOLOGY.toString() + ":";
+
+ private static final String NAMESPACE = ManchesterOWLSyntax.NAMESPACE.toString() + ":";
+
+ private static final String IMPORTS = ":";
+
+
+ private static final String FUNCTIONAL = ManchesterOWLSyntax.FUNCTIONAL.toString();
+
+ private static final String INVERSE_FUNCTIONAL = ManchesterOWLSyntax.INVERSE_FUNCTIONAL.toString();
+
+ private static final String SYMMETRIC = ManchesterOWLSyntax.SYMMETRIC.toString();
+
+ private static final String ANTI_SYMMETRIC = ManchesterOWLSyntax.ANTI_SYMMETRIC.toString();
+
+ private static final String TRANSITIVE = ManchesterOWLSyntax.TRANSITIVE.toString();
+
+ private static final String REFLEXIVE = ManchesterOWLSyntax.REFLEXIVE.toString();
+
+ private static final String IRREFLEXIVE = ManchesterOWLSyntax.IRREFLEXIVE.toString();
+
+ private static final String INVERSE_OF = ManchesterOWLSyntax.INVERSE_OF + ":";
+
+ private Set<String> potentialKeywords;
+
+ private List<ManchesterOWLSyntaxTokenizer.Token> tokens;
+
+
+ public ManchesterOWLSyntaxParser(OWLDataFactory dataFactory, String s) {
+ this.dataFactory = dataFactory;
+ skip.add(' ');
+ skip.add('\n');
+ skip.add('\t');
+ delims.add('(');
+ delims.add(')');
+ delims.add('[');
+ delims.add(']');
+ delims.add(',');
+ delims.add('{');
+ delims.add('}');
+// delims.add('"');
+ delims.add('^');
+ delims.add('@');
+ escapeChars.add('\'');
+ escapeChars.add('\"');
+ potentialKeywords = new HashSet<String>();
+ restrictionKeywords = new HashSet<String>();
+ restrictionKeywords.add(ManchesterOWLSyntax.SOME.toString());
+ restrictionKeywords.add(ManchesterOWLSyntax.ONLY.toString());
+ restrictionKeywords.add(ManchesterOWLSyntax.MIN.toString());
+ restrictionKeywords.add(ManchesterOWLSyntax.MAX.toString());
+ restrictionKeywords.add(ManchesterOWLSyntax.EXACTLY.toString());
+ restrictionKeywords.add(ManchesterOWLSyntax.VALUE.toString());
+ restrictionKeywords.add(ManchesterOWLSyntax.THAT.toString());
+
+
+ classNames = new HashSet<String>();
+ objectPropertyNames = new HashSet<String>();
+ dataPropertyNames = new HashSet<String>();
+ individualNames = new HashSet<String>();
+ dataTypeNames = new HashSet<String>();
+ annotationURIs = new HashSet<String>();
+ namespaceMap = new HashMap<String, URI>();
+ NamespaceUtil u = new NamespaceUtil();
+
+ for (URI uri : OWLRDFVocabulary.BUILT_IN_ANNOTATION_PROPERTIES) {
+ String[] res = u.split(uri.toString(), null);
+ annotationURIs.add(u.getPrefix(res[0]) + ":" + res[1]);
+ }
+ pos = 0;
+ buffer = s;
+ base = "http://www.semanticweb.org#";
+ owlEntityChecker = new DefaultEntityChecker();
+
+ tokens = new ArrayList<ManchesterOWLSyntaxTokenizer.Token>();
+ tokens.addAll(getTokenizer(s).tokenize());
+ tokenIndex = 0;
+ }
+
+
+ public String getBase() {
+ return base;
+ }
+
+
+ public void setBase(String base) {
+ this.base = base;
+ }
+
+
+ public OWLEntityChecker getOWLEntityChecker() {
+ return owlEntityChecker;
+ }
+
+
+ public void setOWLEntityChecker(OWLEntityChecker owlEntityChecker) {
+ this.owlEntityChecker = owlEntityChecker;
+ }
+
+
+ public boolean isClassName(String name) {
+ if (classNames.contains(name)) {
+ return true;
+ }
+ return owlEntityChecker != null && owlEntityChecker.getOWLClass(name) != null;
+ }
+
+
+ public boolean isObjectPropertyName(String name) {
+ if (objectPropertyNames.contains(name)) {
+ return true;
+ }
+ return owlEntityChecker != null && owlEntityChecker.getOWLObjectProperty(name) != null;
+ }
+
+
+ public boolean isAnnotationURI(String name) {
+ return annotationURIs.contains(name);
+ }
+
+
+ public boolean isDataPropertyName(String name) {
+ if (dataPropertyNames.contains(name)) {
+ return true;
+ }
+ return owlEntityChecker != null && owlEntityChecker.getOWLDataProperty(name) != null;
+ }
+
+
+ public boolean isIndividualName(String name) {
+ if (individualNames.contains(name)) {
+ return true;
+ }
+ return owlEntityChecker != null && owlEntityChecker.getOWLIndividual(name) != null;
+ }
+
+
+ public boolean isDatatypeName(String name) {
+ if (dataTypeNames.contains(name)) {
+ return true;
+ }
+ return owlEntityChecker != null && owlEntityChecker.getOWLDataType(name) != null;
+ }
+
+
+ public OWLClass getOWLClass(String name) {
+ return owlEntityChecker.getOWLClass(name);
+ }
+
+
+ public OWLObjectProperty getOWLObjectProperty(String name) {
+ return owlEntityChecker.getOWLObjectProperty(name);
+ }
+
+
+ public OWLIndividual getOWLIndividual(String name) {
+ return owlEntityChecker.getOWLIndividual(name);
+ }
+
+
+ public OWLDataProperty getOWLDataProperty(String name) {
+ return owlEntityChecker.getOWLDataProperty(name);
+ }
+
+
+ public OWLDataType getDataType(String name) {
+ return dataFactory.getOWLDataType(URI.create(Namespaces.XSD + name));
+ }
+
+
+ public URI getAnnotationURI(String name) {
+ if (name.startsWith("rdfs:")) {
+ return URI.create(Namespaces.RDFS + name.substring(5, name.length()));
+ }
+ else if (name.startsWith("owl:")) {
+ return URI.create(Namespaces.RDFS + name.substring(4, name.length()));
+ }
+ return URI.create(base + name);
+ }
+
+
+ private String getLastToken() {
+ return token;
+ }
+
+
+ private String peekToken() {
+ return getToken().getToken();
+ }
+
+ ////////////////////////////////////////////////////////////////////////////////////////////////////
+ //
+ // Tokenizer
+ //
+ ////////////////////////////////////////////////////////////////////////////////////////////////////
+
+
+ private String readToken() {
+ if (bufferedToken != null) {
+ token = bufferedToken;
+ bufferedToken = null;
+ return token;
+ }
+
+ // Skip any skip characters
+ while (pos < buffer.length()) {
+ char ch = buffer.charAt(pos);
+ if (skip.contains(ch)) {
+ if (ch == '\n') {
+ line++;
+ col = 0;
+ }
+ }
+ else {
+ break;
+ }
+ col++;
+ pos++;
+ }
+
+ tokenStartPos = pos;
+ tokenStartCol = col;
+
+ if (pos >= buffer.length()) {
+ // Past end of buffer
+ token = EOF;
+ }
+ else if (pos+1 == buffer.length() && escapeChars.contains(buffer.charAt(pos))){
+ // single escape character
+ token = EOF;
+ }
+ else if (delims.contains(buffer.charAt(pos))) {
+ // Single delim
+ pos++;
+ col++;
+ token = buffer.substring(pos - 1, pos);
+ }
+ else {
+ // Some other token
+ int start = pos;
+ boolean inEscapedString = false;
+ while (pos < buffer.length()) {
+ char ch = buffer.charAt(pos);
+ if (escapeChars.contains(ch) && !inEscapedString) {
+ inEscapedString = true;
+ start++;
+ }
+ else {
+ if (escapeChars.contains(ch) && inEscapedString) {
+ if (ch == '\'') {
+ token = buffer.substring(start, pos);
+ }
+ else {
+ token = buffer.substring(start - 1, pos + 1);
+ }
+ inEscapedString = false;
+ pos++;
+ return token;
+ }
+ if (!inEscapedString && (skip.contains(ch) || delims.contains(ch))) {
+ token = buffer.substring(start, pos);
+ return token;
+ }
+ }
+ col++;
+ pos++;
+ }
+ if (start != pos) {
+ token = buffer.substring(start, pos);
+ }
+ }
+ return token;
+ }
+
+ ////////////////////////////////////////////////////////////////////////////////////////////////////
+ //
+ // Parser
+ //
+ ////////////////////////////////////////////////////////////////////////////////////////////////////
+
+
+ /**
+ * Parses an OWL description that is represented in Manchester OWL Syntax
+ * @return The parsed description
+ * @throws ParserException If an description could not be parsed.
+ */
+ public OWLDescription parseDescription() throws ParserException {
+ OWLDescription desc = parseIntersection();
+ if (!consumeToken().equals(EOF)) {
+ throwException(EOF);
+ }
+ return desc;
+ }
+
+
+ public OWLDescription parseIntersection() throws ParserException {
+ Set<OWLDescription> ops = new HashSet<OWLDescription>();
+ String kw = AND;
+ while (kw.equalsIgnoreCase(AND)) {
+ potentialKeywords.remove(AND);
+ ops.add(parseUnion());
+ potentialKeywords.add(AND);
+ kw = peekToken();
+ if (kw.equalsIgnoreCase(AND)) {
+ kw = consumeToken();
+ }
+ else if (kw.equalsIgnoreCase("that")) {
+ consumeToken();
+ kw = AND;
+ }
+ }
+ if (ops.size() == 1) {
+ return ops.iterator().next();
+ }
+ else {
+ return dataFactory.getOWLObjectIntersectionOf(ops);
+ }
+ }
+
+
+ public OWLDescription parseUnion() throws ParserException {
+ Set<OWLDescription> ops = new HashSet<OWLDescription>();
+ String kw = OR;
+ while (kw.equalsIgnoreCase(OR)) {
+ potentialKeywords.remove(OR);
+ ops.add(parseNonNaryDescription());
+ potentialKeywords.add(OR);
+ kw = peekToken();
+ if (kw.equalsIgnoreCase(OR)) {
+ kw = consumeToken();
+ }
+ }
+ if (ops.size() == 1) {
+ return ops.iterator().next();
+ }
+ else {
+ return dataFactory.getOWLObjectUnionOf(ops);
+ }
+ }
+
+
+ public OWLObjectPropertyExpression parseObjectPropertyExpression(boolean allowUndeclared) throws ParserException {
+ String tok = consumeToken();
+ if (tok.equalsIgnoreCase(INV)) {
+ String open = consumeToken();
+ if (!open.equals("(")) {
+ throwException("(");
+ }
+ OWLObjectPropertyExpression prop = parseObjectPropertyExpression();
+ String close = consumeToken();
+ if (!close.equals(")")) {
+ throwException(")");
+ }
+ return dataFactory.getOWLObjectPropertyInverse(prop);
+ }
+ else {
+ if (!allowUndeclared && !isObjectPropertyName(tok)) {
+ throwException(false, true, false, false, false, INV);
+ }
+ return getOWLObjectProperty(tok);
+ }
+ }
+
+
+ public OWLObjectPropertyExpression parseObjectPropertyExpression() throws ParserException {
+ return parseObjectPropertyExpression(false);
+ }
+
+
+ public OWLDescription parseRestriction() throws ParserException {
+ String tok = peekToken();
+ if (isObjectPropertyName(tok) || tok.equalsIgnoreCase(INV)) {
+ return parseObjectRestriction();
+ }
+ else if (isDataPropertyName(tok)) {
+ return parseDataRestriction();
+ }
+ else {
+ consumeToken();
+ throwException(false, true, true, false);
+ }
+ return null;
+ }
+
+
+ /**
+ * Parses all class descriptions except ObjectIntersectionOf
+ * and ObjectUnionOf
+ * @return The description which was parsed
+ * @throws ParserException if a non-nary description could not be parsed
+ */
+ public OWLDescription parseNonNaryDescription() throws ParserException {
+
+ String tok = peekToken();
+ if (tok.equalsIgnoreCase(NOT)) {
+ consumeToken();
+ OWLDescription complemented = parseNestedClassExpression();
+ return dataFactory.getOWLObjectComplementOf(complemented);
+ }
+ else if (isObjectPropertyName(tok) || tok.equalsIgnoreCase(INV)) {
+ return parseObjectRestriction();
+ }
+ else if (isDataPropertyName(tok)) {
+ // Data restriction
+ return parseDataRestriction();
+ }
+ else if (tok.equals("{")) {
+ return parseObjectOneOf();
+ }
+ else if (tok.equals("(")) {
+ return parseNestedClassExpression();
+ }
+ else if (isClassName(tok)) {
+ consumeToken();
+ OWLDescription desc = getOWLClass(tok);
+// if (peekToken().equalsIgnoreCase("that")) {
+// consumeToken();
+// OWLDescription rest = parseRestriction();
+// desc = dataFactory.getOWLObjectIntersectionOf(CollectionFactory.createSet(desc, rest));
+// }
+ return desc;
+ }
+ // Add option for strict class name checking
+ else {
+ consumeToken();
+ throwException(true, true, true, false, false, "(", "{", NOT, INV);
+ }
+ return null;
+ }
+
+
+ private OWLDescription parseObjectRestriction() throws ParserException {
+ OWLObjectPropertyExpression prop = parseObjectPropertyExpression();
+ String kw = consumeToken();
+ if (kw.equalsIgnoreCase(SOME)) {
+ String possSelfToken = peekToken();
+ if (possSelfToken.equalsIgnoreCase(SELF)) {
+ consumeToken();
+ return dataFactory.getOWLObjectSelfRestriction(prop);
+ }
+ else {
+ OWLDescription filler = null;
+ try {
+ filler = parseNestedClassExpression();
+ }
+ catch (ParserException e) {
+ Set<String> keywords = new HashSet<String>();
+ keywords.addAll(e.getExpectedKeywords());
+ keywords.add(SELF);
+ throwException(e.isClassNameExpected(),
+ e.isObjectPropertyNameExpected(),
+ e.isDataPropertyNameExpected(),
+ e.isIndividualNameExpected(),
+ e.isDatatypeNameExpected(),
+ keywords.toArray(new String[keywords.size()]));
+ }
+ return dataFactory.getOWLObjectSomeRestriction(prop, filler);
+ }
+ }
+ else if (kw.equalsIgnoreCase(ONLY)) {
+ OWLDescription filler = parseNestedClassExpression();
+ return dataFactory.getOWLObjectAllRestriction(prop, filler);
+ }
+ else if (kw.equalsIgnoreCase(VALUE)) {
+ String indName = consumeToken();
+ if (!isIndividualName(indName)) {
+ throwException(false, false, false, true);
+ }
+ return dataFactory.getOWLObjectValueRestriction(prop, getOWLIndividual(indName));
+ }
+ else if (kw.equalsIgnoreCase(MIN)) {
+ int card = parseInteger();
+ OWLDescription filler = parseNestedClassExpression();
+ return dataFactory.getOWLObjectMinCardinalityRestriction(prop, card, filler);
+ }
+ else if (kw.equalsIgnoreCase(MAX)) {
+ int card = parseInteger();
+ OWLDescription filler = parseNestedClassExpression();
+ return dataFactory.getOWLObjectMaxCardinalityRestriction(prop, card, filler);
+ }
+ else if (kw.equalsIgnoreCase(EXACTLY)) {
+ int card = parseInteger();
+ OWLDescription filler = parseNestedClassExpression();
+ return dataFactory.getOWLObjectExactCardinalityRestriction(prop, card, filler);
+ }
+ else if (kw.equalsIgnoreCase(ONLYSOME)) {
+ String tok = peekToken();
+ Set<OWLDescription> descs = new HashSet<OWLDescription>();
+ if (!tok.equals("[")) {
+ descs.add(parseIntersection());
+ }
+ else {
+ descs.addAll(parseDescriptionList("[", "]"));
+ }
+ Set<OWLDescription> ops = new HashSet<OWLDescription>();
+ for (OWLDescription desc : descs) {
+ ops.add(dataFactory.getOWLObjectSomeRestriction(prop, desc));
+ }
+ OWLDescription filler;
+ if (descs.size() == 1) {
+ filler = descs.iterator().next();
+ }
+ else {
+ filler = dataFactory.getOWLObjectUnionOf(descs);
+ }
+ ops.add(dataFactory.getOWLObjectAllRestriction(prop, filler));
+ return dataFactory.getOWLObjectIntersectionOf(ops);
+ }
+ else {
+ // Error!
+ throwException(SOME, ONLY, VALUE, MIN, MAX, EXACTLY);
+ }
+ return null;
+ }
+
+
+ public OWLDescription parseDataRestriction() throws ParserException {
+ OWLDataPropertyExpression prop = parseDataProperty();
+ String kw = consumeToken();
+ if (kw.equalsIgnoreCase(SOME)) {
+ OWLDataRange rng = parseDataRange();
+ return dataFactory.getOWLDataSomeRestriction(prop, rng);
+ }
+ else if (kw.equalsIgnoreCase(ONLY)) {
+ OWLDataRange rng = parseDataRange();
+ return dataFactory.getOWLDataAllRestriction(prop, rng);
+ }
+ else if (kw.equalsIgnoreCase(VALUE)) {
+ OWLConstant con = parseConstant();
+ return dataFactory.getOWLDataValueRestriction(prop, con);
+ }
+ else if (kw.equalsIgnoreCase(MIN)) {
+ int card = parseInteger();
+ OWLDataRange rng = parseDataRange();
+ return dataFactory.getOWLDataMinCardinalityRestriction(prop, card, rng);
+ }
+ else if (kw.equalsIgnoreCase(EXACTLY)) {
+ int card = parseInteger();
+ OWLDataRange rng = parseDataRange();
+ return dataFactory.getOWLDataExactCardinalityRestriction(prop, card, rng);
+ }
+ else if (kw.equalsIgnoreCase(MAX)) {
+ int card = parseInteger();
+ OWLDataRange rng = parseDataRange();
+ return dataFactory.getOWLDataMaxCardinalityRestriction(prop, card, rng);
+ }
+ throwException(SOME, ONLY, VALUE, MIN, EXACTLY, MAX);
+ return null;
+ }
+
+
+ public OWLDataRange parseDataRange() throws ParserException {
+ String tok = peekToken();
+ if (isDatatypeName(tok)) {
+ consumeToken();
+ OWLDataType dataType = getDataType(tok);
+ String next = peekToken();
+ if (next.equals("[")) {
+ // Restricted data range
+ consumeToken();
+ String sep = ",";
+ Set<OWLDataRangeFacetRestriction> facetRestrictions = new HashSet<OWLDataRangeFacetRestriction>();
+ while (sep.equals(",")) {
+ String facet = consumeToken();
+ OWLRestrictedDataRangeFacetVocabulary fv = OWLRestrictedDataRangeFacetVocabulary.getFacetBySymbolicName(
+ facet);
+ if (fv == null) {
+ throwException(OWLRestrictedDataRangeFacetVocabulary.getFacets().toArray(new String[OWLRestrictedDataRangeFacetVocabulary.getFacetURIs().size()]));
+ }
+ OWLConstant con = parseConstant();
+ facetRestrictions.add(dataFactory.getOWLDataRangeFacetRestriction(fv, con.asOWLTypedConstant()));
+ sep = consumeToken();
+ }
+ if (!sep.equals("]")) {
+ throwException("]");
+ }
+ return dataFactory.getOWLDataRangeRestriction(dataType, facetRestrictions);
+ }
+ else {
+ return dataType;
+ }
+ }
+ else if (tok.equalsIgnoreCase(NOT)) {
+ return parseDataComplementOf();
+ }
+ else if (tok.equals("{")) {
+ return parseDataOneOf();
+ }
+ else {
+ consumeToken();
+ throwException(false, false, false, false, true, NOT, "{");
+ }
+ return null;
+ }
+
+
+ private Set<OWLDataRange> parseDataRangeList() throws ParserException {
+ String sep = ",";
+ Set<OWLDataRange> ranges = new HashSet<OWLDataRange>();
+ while (sep.equals(",")) {
+ potentialKeywords.remove(",");
+ OWLDataRange rng = parseDataRange();
+ ranges.add(rng);
+ potentialKeywords.add(",");
+ sep = peekToken();
+ if (sep.equals(",")) {
+ consumeToken();
+ }
+ }
+ return ranges;
+ }
+
+
+ private OWLDataRange parseDataOneOf() throws ParserException {
+ consumeToken();
+ Set<OWLConstant> cons = new HashSet<OWLConstant>();
+ String sep = ",";
+ while (sep.equals(",")) {
+ OWLConstant con = parseConstant();
+ cons.add(con);
+ sep = consumeToken();
+ }
+ if (!sep.equals("}")) {
+ throwException(",", "}");
+ }
+ return dataFactory.getOWLDataOneOf(cons);
+ }
+
+
+ private OWLDataRange parseDataComplementOf() throws ParserException {
+ consumeToken();
+ String open = consumeToken();
+ if (!open.equals("(")) {
+ throwException("(");
+ }
+ OWLDataRange complementedDataRange = parseDataRange();
+ String close = consumeToken();
+ if (!close.equals(")")) {
+ throwException(")");
+ }
+ return dataFactory.getOWLDataComplementOf(complementedDataRange);
+ }
+
+
+ public OWLConstant parseConstant() throws ParserException {
+ String tok = consumeToken();
+ if (tok.startsWith("\"")) {
+ String lit = tok.substring(1, tok.length() - 1);
+ if (peekToken().equals("^")) {
+ consumeToken();
+ String type = consumeToken();
+ String dataType = consumeToken();
+ return dataFactory.getOWLTypedConstant(lit, getDataType(dataType));
+ }
+ else if (peekToken().equals("@")) {
+ consumeToken();
+ String lang = consumeToken();
+ return dataFactory.getOWLUntypedConstant(lit, lang);
+ }
+ else {
+ return dataFactory.getOWLUntypedConstant(lit);
+ }
+ }
+ else {
+ try {
+ Integer.parseInt(tok);
+ return dataFactory.getOWLTypedConstant(tok, dataFactory.getOWLDataType(XSDVocabulary.INT.getURI()));
+ }
+ catch (NumberFormatException e) {
+ // Ignore - not interested
+ }
+ try {
+ Double.parseDouble(tok);
+ return dataFactory.getOWLTypedConstant(tok, dataFactory.getOWLDataType(XSDVocabulary.DOUBLE.getURI()));
+ }
+ catch (NumberFormatException e) {
+ // Ignore - not interested
+ }
+ try {
+ Float.parseFloat(tok);
+ return dataFactory.getOWLTypedConstant(tok, dataFactory.getOWLDataType(XSDVocabulary.FLOAT.getURI()));
+ }
+ catch (NumberFormatException e) {
+ // Ignore - not interested
+ }
+ }
+ throwException(false,
+ false,
+ false,
+ false,
+ false,
+ "\"<Literal>\"",
+ "\"<Literal>\"^^<datatype>",
+ "\"<Literal>\"@<lang>");
+ return null;
+ }
+
+
+ public int parseInteger() throws ParserException {
+ String i = consumeToken();
+ try {
+ return Integer.parseInt(i);
+ }
+ catch (NumberFormatException e) {
+ throw new ParserException(token, tokenStartPos, line, true, tokenStartCol);
+ }
+ }
+
+
+ public String getLineCol() {
+ return "Encountered " + getLastToken() + " at " + line + ":" + col + " ";
+ }
+
+
+ private OWLDescription parseNestedClassExpression() throws ParserException {
+ String tok = peekToken();
+ if (tok.equals("(")) {
+ consumeToken();
+ OWLDescription desc = parseIntersection();
+ String closeBracket = consumeToken();
+ if (!closeBracket.equals(")")) {
+ // Error!
+ throwException(")");
+ }
+ return desc;
+ }
+ else if (tok.equals("{")) {
+ return parseObjectOneOf();
+ }
+ else if (isClassName(tok)) {
+ String name = consumeToken();
+ return getOWLClass(name);
+ }
+ else {
+ consumeToken();
+ throwException(true, false, false, false, false, "(", "{");
+ }
+ return null;
+ }
+
+
+ public OWLDescription parseObjectOneOf() throws ParserException {
+ String open = consumeToken();
+ if (!open.equals("{")) {
+ throwException("{");
+ }
+ String sep = ",";
+ Set<OWLIndividual> inds = new HashSet<OWLIndividual>();
+ while (sep.equals(",")) {
+ OWLIndividual ind = parseIndividual();
+ inds.add(ind);
+ sep = peekToken();
+ if (sep.equals(",")) {
+ consumeToken();
+ }
+ }
+ String close = consumeToken();
+ if (!close.equals("}")) {
+ throwException("}", ",");
+ }
+ return dataFactory.getOWLObjectOneOf(inds);
+ }
+
+
+ public Set<OWLAxiom> parseFrames() throws ParserException {
+ Set<OWLAxiom> axioms = new HashSet<OWLAxiom>();
+ while (true) {
+ ...
[truncated message content] |
