Debian Codegraph @

Source/Parser/CXMLOWL2Handler.cpp

raw
1 /*
2 * Copyright (C) 2013-2015, 2019 by the Konclude Developer Team.
3 *
4 * This file is part of the reasoning system Konclude.
5 * For details and support, see <http://konclude.com/>.
6 *
7 * Konclude is free software: you can redistribute it and/or modify
8 * it under the terms of version 3 of the GNU Lesser General Public
9 * License (LGPLv3) as published by the Free Software Foundation.
10 *
11 * Konclude is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU (Lesser) General Public License for more details.
15 *
16 * You should have received a copy of the GNU (Lesser) General Public
17 * License along with Konclude. If not, see <http://www.gnu.org/licenses/>.
18 *
19 */
20
21 #include "CXMLOWL2Handler.h"
22
23
24 namespace Konclude {
25
26 namespace Parser {
27
28
29
30 CXMLOWL2Handler::CXMLOWL2Handler(COntologyBuilder* ontoBuilder)
31 : CLogIdentifier("::Konclude::Parser::OWL2QtXMLOntologyParser",this),recordRouter(0,this) {
32
33 mOntoBuilder = ontoBuilder;
34 mAxiomNumber = 0;
35 LOG(INFO,getLogDomain(),logTr("Created OWL 2.0 Qt XML Parser."),this);
36
37 initializeParseFunctionJumpHash();
38 }
39
40 CXMLOWL2Handler::CXMLOWL2Handler(COntologyBuilder* ontoBuilder, CCommandRecordRouter *commandRecordRouter)
41 : CLogIdentifier("::Konclude::Parser::OWL2QtXMLOntologyParser",this),recordRouter(*commandRecordRouter,this) {
42
43 mOntoBuilder = ontoBuilder;
44 mAxiomNumber = 0;
45 LOG(INFO,getLogDomain(),logTr("Created OWL 2.0 Qt XML Parser."),this);
46
47 initializeParseFunctionJumpHash();
48 }
49
50
51
52
53
54 bool CXMLOWL2Handler::startElement(const QString& namespaceURI, const QString& localName, const QString& qName, const QXmlAttributes& atts, CParsingHandlingContext* handlingContext) {
55 mStack.push(new CParseStackObject(namespaceURI,localName,qName,atts));
56 return true;
57 }
58
59 bool CXMLOWL2Handler::endElement(const QString& namespaceURI, const QString& localName, const QString& qName, CParsingHandlingContext* handlingContext) {
60 CParseStackObject* parseStackObject = mStack.pop();
61 parseBuildNode(parseStackObject);
62 delete parseStackObject;
63 return true;
64 }
65
66
67 bool CXMLOWL2Handler::startDocument(CParsingHandlingContext* handlingContext) {
68 mStack.push(new CParseStackObject("","","",QXmlAttributes()));
69 return true;
70 }
71
72 bool CXMLOWL2Handler::endDocument(CParsingHandlingContext* handlingContext) {
73 if (mStack.count() > 0) {
74 CParseStackObject* parseStackObject = mStack.pop();
75 parseTellOntologyAxiomNode(parseStackObject);
76 delete parseStackObject;
77 }
78 return true;
79 }
80
81
82
83
84
85
86 void CXMLOWL2Handler::parseTellOntologyAxiomNode(CParseStackObject* parseStackObj) {
87 if (mOntoBuilder && parseStackObj->hasExpressions()) {
88
89 QList<CBuildExpression*>* expList = parseStackObj->getExpressions();
90 for (QList<CBuildExpression*>::const_iterator it = expList->constBegin(), itEnd = expList->constEnd(); it != itEnd; ++it) {
91 CAxiomExpression* axiomExpression = dynamic_cast<CAxiomExpression*>(*it);
92 if (axiomExpression) {
93 mOntoBuilder->tellOntologyAxiom(axiomExpression);
94 }
95 }
96
97 }
98 }
99
100 void CXMLOWL2Handler::parseRetractOntologyAxiomNode(CParseStackObject* parseStackObj) {
101 if (mOntoBuilder && parseStackObj->hasExpressions()) {
102
103 QList<CBuildExpression*>* expList = parseStackObj->getExpressions();
104 for (QList<CBuildExpression*>::const_iterator it = expList->constBegin(), itEnd = expList->constEnd(); it != itEnd; ++it) {
105 CAxiomExpression* axiomExpression = dynamic_cast<CAxiomExpression*>(*it);
106 if (axiomExpression) {
107 mOntoBuilder->retractOntologyAxiom(axiomExpression);
108 }
109 }
110
111 }
112 }
113
114
115 void CXMLOWL2Handler::parsePrefixNode(CParseStackObject* parseStackObj) {
116 QString abbName = parseStackObj->mAtts.value(mNameString);
117 QString totalIRIName = parseStackObj->mAtts.value(mIRIString);
118
119 if (abbName.isEmpty()) {
120 abbName = parseStackObj->mAtts.value(mOWLPrefixNameString);
121 }
122 if (totalIRIName.isEmpty()) {
123 totalIRIName = parseStackObj->mAtts.value(mOWLPrefixIRIString);
124 }
125
126 if (!totalIRIName.isEmpty()) {
127 mOntoBuilder->addNameAbbreviation(totalIRIName,abbName);
128 }
129 }
130
131
132
133
134 QString CXMLOWL2Handler::getEntityName(CParseStackObject* parseStackObj) {
135 QString entityName;
136
137 bool abbreviated = false;
138
139 QString attrNameString;
140 attrNameString = parseStackObj->mAtts.value(mIRIString);
141 if (attrNameString.isEmpty()) {
142 attrNameString = parseStackObj->mAtts.value(mOWLPrefixIRIString);
143 abbreviated = true;
144 }
145 if (attrNameString.isEmpty()) {
146 attrNameString = parseStackObj->mAtts.value(mAbbreviatedIRIString);
147 abbreviated = true;
148 }
149 if (attrNameString.isEmpty()) {
150 attrNameString = parseStackObj->mAtts.value(mOWLPrefixAbbreviatedIRIString);
151 abbreviated = true;
152 }
153 if (attrNameString.isEmpty()) {
154 attrNameString = parseStackObj->mAtts.value(mURIString);
155 abbreviated = true;
156 }
157 if (attrNameString.isEmpty()) {
158 attrNameString = parseStackObj->mAtts.value(mOWLPrefixURIString);
159 abbreviated = true;
160 }
161 if (abbreviated) {
162 entityName = mOntoBuilder->resolveAbbreviationName(attrNameString);
163 } else {
164 entityName = attrNameString;
165 }
166
167 return entityName;
168 }
169
170 QString CXMLOWL2Handler::getCardinality(CParseStackObject* parseStackObj) {
171 QString cardinalityString;
172 cardinalityString = parseStackObj->mAtts.value(mCardinalityString);
173 if (cardinalityString.isEmpty()) {
174 cardinalityString = parseStackObj->mAtts.value(mOWLPrefixCardinalityString);
175 }
176
177 return cardinalityString;
178 }
179
180
181 QString CXMLOWL2Handler::getNodeID(CParseStackObject* parseStackObj) {
182 QString nodeIDString;
183 nodeIDString = parseStackObj->mAtts.value(mNodeIDString);
184 if (nodeIDString.isEmpty()) {
185 nodeIDString = parseStackObj->mAtts.value(mOWLPrefixNodeIDString);
186 }
187
188 return nodeIDString;
189 }
190
191
192 bool CXMLOWL2Handler::initializeParseFunctionJumpHash() {
193
194 mOWLString = QString("http://www.w3.org/2002/07/owl#");
195 mOWLPrefixString = QString("owl");
196
197 mURIString = QString("URI");
198 mOWLPrefixURIString = mOWLPrefixString+QString(":")+mURIString;
199
200 mIRIString = QString("IRI");
201 mOWLPrefixIRIString = mOWLPrefixString+QString(":")+mIRIString;
202
203 mAbbreviatedIRIString = QString("abbreviatedIRI");
204 mOWLPrefixAbbreviatedIRIString = mOWLPrefixString+QString(":")+mAbbreviatedIRIString;
205
206 mCardinalityString = QString("cardinality");
207 mOWLPrefixCardinalityString = mOWLPrefixString+QString(":")+mCardinalityString;
208
209 mNodeIDString = QString("nodeID");
210 mOWLPrefixNodeIDString = mOWLPrefixString+QString(":")+mNodeIDString;
211
212 mNameString = QString("name");
213 mOWLPrefixNameString = mOWLPrefixString+QString(":")+mNameString;
214
215
216
217
218 mParseFunctionJumpHash.insert("Prefix",&CXMLOWL2Handler::jumpFunctionParsePrefixNode);
219 mParseFunctionJumpHash.insert(mOWLPrefixString+":Prefix",&CXMLOWL2Handler::jumpFunctionParsePrefixNode);
220
221 mParseFunctionJumpHash.insert("Class",&CXMLOWL2Handler::jumpFunctionParseClassNode);
222 mParseFunctionJumpHash.insert(mOWLPrefixString+":Class",&CXMLOWL2Handler::jumpFunctionParseClassNode);
223 mParseFunctionJumpHash.insert("OWLClass",&CXMLOWL2Handler::jumpFunctionParseClassNode);
224 mParseFunctionJumpHash.insert(mOWLPrefixString+":OWLClass",&CXMLOWL2Handler::jumpFunctionParseClassNode);
225 mParseFunctionJumpHash.insert("ObjectProperty",&CXMLOWL2Handler::jumpFunctionParseObjectPropertyNode);
226 mParseFunctionJumpHash.insert(mOWLPrefixString+":ObjectProperty",&CXMLOWL2Handler::jumpFunctionParseObjectPropertyNode);
227 mParseFunctionJumpHash.insert("IndividualVariable",&CXMLOWL2Handler::jumpFunctionParseIndividualVariable);
228 mParseFunctionJumpHash.insert(mOWLPrefixString+":IndividualVariable",&CXMLOWL2Handler::jumpFunctionParseIndividualVariable);
229 mParseFunctionJumpHash.insert("Variable",&CXMLOWL2Handler::jumpFunctionParseIndividualVariable);
230 mParseFunctionJumpHash.insert(mOWLPrefixString+":Variable",&CXMLOWL2Handler::jumpFunctionParseIndividualVariable);
231
232 mParseFunctionJumpHash.insert("Declaration",&CXMLOWL2Handler::jumpFunctionParseDeclarationNode);
233 mParseFunctionJumpHash.insert(mOWLPrefixString+":Declaration",&CXMLOWL2Handler::jumpFunctionParseDeclarationNode);
234
235 mParseFunctionJumpHash.insert("SubClassOf",&CXMLOWL2Handler::jumpFunctionParseSubClassOfNode);
236 mParseFunctionJumpHash.insert(mOWLPrefixString+":SubClassOf",&CXMLOWL2Handler::jumpFunctionParseSubClassOfNode);
237 mParseFunctionJumpHash.insert("EquivalentClasses",&CXMLOWL2Handler::jumpFunctionParseEquivalentClassesNode);
238 mParseFunctionJumpHash.insert(mOWLPrefixString+":EquivalentClasses",&CXMLOWL2Handler::jumpFunctionParseEquivalentClassesNode);
239 mParseFunctionJumpHash.insert("DisjointClasses",&CXMLOWL2Handler::jumpFunctionParseDisjontClassesNode);
240 mParseFunctionJumpHash.insert(mOWLPrefixString+":DisjointClasses",&CXMLOWL2Handler::jumpFunctionParseDisjontClassesNode);
241 mParseFunctionJumpHash.insert("DisjointUnion",&CXMLOWL2Handler::jumpFunctionParseDisjontUnionNode);
242 mParseFunctionJumpHash.insert(mOWLPrefixString+":DisjointUnion",&CXMLOWL2Handler::jumpFunctionParseDisjontUnionNode);
243
244 mParseFunctionJumpHash.insert("SubObjectPropertyOf",&CXMLOWL2Handler::jumpFunctionParseSubObjectPropertyOfNode);
245 mParseFunctionJumpHash.insert(mOWLPrefixString+":SubObjectPropertyOf",&CXMLOWL2Handler::jumpFunctionParseSubObjectPropertyOfNode);
246 mParseFunctionJumpHash.insert("ObjectPropertyChain",&CXMLOWL2Handler::jumpFunctionParseObjectPropertyChainNode);
247 mParseFunctionJumpHash.insert(mOWLPrefixString+":ObjectPropertyChain",&CXMLOWL2Handler::jumpFunctionParseObjectPropertyChainNode);
248 mParseFunctionJumpHash.insert("EquivalentObjectProperties",&CXMLOWL2Handler::jumpFunctionParseEquivalentObjectPropertiesNode);
249 mParseFunctionJumpHash.insert(mOWLPrefixString+":EquivalentObjectProperties",&CXMLOWL2Handler::jumpFunctionParseEquivalentObjectPropertiesNode);
250 mParseFunctionJumpHash.insert("DisjointObjectProperties",&CXMLOWL2Handler::jumpFunctionParseDisjointObjectPropertiesNode);
251 mParseFunctionJumpHash.insert(mOWLPrefixString+":DisjointObjectProperties",&CXMLOWL2Handler::jumpFunctionParseDisjointObjectPropertiesNode);
252
253 mParseFunctionJumpHash.insert("ObjectInverseOf",&CXMLOWL2Handler::jumpFunctionParseInverseObjectPropertyOfNode);
254 mParseFunctionJumpHash.insert(mOWLPrefixString+":ObjectInverseOf",&CXMLOWL2Handler::jumpFunctionParseInverseObjectPropertyOfNode);
255 mParseFunctionJumpHash.insert("InverseObjectProperties",&CXMLOWL2Handler::jumpFunctionParseInverseObjectPropertiesNode);
256 mParseFunctionJumpHash.insert(mOWLPrefixString+":InverseObjectProperties",&CXMLOWL2Handler::jumpFunctionParseInverseObjectPropertiesNode);
257 mParseFunctionJumpHash.insert("ObjectPropertyRange",&CXMLOWL2Handler::jumpFunctionParseObjectPropertyRangeNode);
258 mParseFunctionJumpHash.insert(mOWLPrefixString+":ObjectPropertyRange",&CXMLOWL2Handler::jumpFunctionParseObjectPropertyRangeNode);
259 mParseFunctionJumpHash.insert("ObjectPropertyDomain",&CXMLOWL2Handler::jumpFunctionParseObjectPropertyDomainNode);
260 mParseFunctionJumpHash.insert(mOWLPrefixString+":ObjectPropertyDomain",&CXMLOWL2Handler::jumpFunctionParseObjectPropertyDomainNode);
261 mParseFunctionJumpHash.insert("TransitiveObjectProperty",&CXMLOWL2Handler::jumpFunctionParseTransetiveObjectPropertyNode);
262 mParseFunctionJumpHash.insert(mOWLPrefixString+":TransitiveObjectProperty",&CXMLOWL2Handler::jumpFunctionParseTransetiveObjectPropertyNode);
263 mParseFunctionJumpHash.insert("FunctionalObjectProperty",&CXMLOWL2Handler::jumpFunctionParseFunctionalObjectPropertyNode);
264 mParseFunctionJumpHash.insert(mOWLPrefixString+":FunctionalObjectProperty",&CXMLOWL2Handler::jumpFunctionParseFunctionalObjectPropertyNode);
265 mParseFunctionJumpHash.insert("SymmetricObjectProperty",&CXMLOWL2Handler::jumpFunctionParseSymmetricObjectPropertyNode);
266 mParseFunctionJumpHash.insert(mOWLPrefixString+":SymmetricObjectProperty",&CXMLOWL2Handler::jumpFunctionParseSymmetricObjectPropertyNode);
267 mParseFunctionJumpHash.insert("AsymmetricObjectProperty",&CXMLOWL2Handler::jumpFunctionParseAsymmetricObjectPropertyNode);
268 mParseFunctionJumpHash.insert(mOWLPrefixString+":AsymmetricObjectProperty",&CXMLOWL2Handler::jumpFunctionParseAsymmetricObjectPropertyNode);
269 mParseFunctionJumpHash.insert("ReflexiveObjectProperty",&CXMLOWL2Handler::jumpFunctionParseReflexiveObjectPropertyNode);
270 mParseFunctionJumpHash.insert(mOWLPrefixString+":ReflexiveObjectProperty",&CXMLOWL2Handler::jumpFunctionParseReflexiveObjectPropertyNode);
271 mParseFunctionJumpHash.insert("IrreflexiveObjectProperty",&CXMLOWL2Handler::jumpFunctionParseIrreflexiveObjectPropertyNode);
272 mParseFunctionJumpHash.insert(mOWLPrefixString+":IrreflexiveObjectProperty",&CXMLOWL2Handler::jumpFunctionParseIrreflexiveObjectPropertyNode);
273 mParseFunctionJumpHash.insert("InverseFunctionalObjectProperty",&CXMLOWL2Handler::jumpFunctionParseInverseFunctionalObjectPropertyNode);
274 mParseFunctionJumpHash.insert(mOWLPrefixString+":InverseFunctionalObjectProperty",&CXMLOWL2Handler::jumpFunctionParseInverseFunctionalObjectPropertyNode);
275
276 mParseFunctionJumpHash.insert("ObjectIntersectionOf",&CXMLOWL2Handler::jumpFunctionParseObjectIntersectionOfNode);
277 mParseFunctionJumpHash.insert(mOWLPrefixString+":ObjectIntersectionOf",&CXMLOWL2Handler::jumpFunctionParseObjectIntersectionOfNode);
278 mParseFunctionJumpHash.insert("ObjectUnionOf",&CXMLOWL2Handler::jumpFunctionParseObjectUnionOfNode);
279 mParseFunctionJumpHash.insert(mOWLPrefixString+":ObjectUnionOf",&CXMLOWL2Handler::jumpFunctionParseObjectUnionOfNode);
280 mParseFunctionJumpHash.insert("ObjectMaxCardinality",&CXMLOWL2Handler::jumpFunctionParseObjectMaxCardinalityNode);
281 mParseFunctionJumpHash.insert(mOWLPrefixString+":ObjectMaxCardinality",&CXMLOWL2Handler::jumpFunctionParseObjectMaxCardinalityNode);
282 mParseFunctionJumpHash.insert("ObjectMinCardinality",&CXMLOWL2Handler::jumpFunctionParseObjectMinCardinalityNode);
283 mParseFunctionJumpHash.insert(mOWLPrefixString+":ObjectMinCardinality",&CXMLOWL2Handler::jumpFunctionParseObjectMinCardinalityNode);
284 mParseFunctionJumpHash.insert("ObjectExactCardinality",&CXMLOWL2Handler::jumpFunctionParseObjectExactlyCardinalityNode);
285 mParseFunctionJumpHash.insert(mOWLPrefixString+":ObjectExactCardinality",&CXMLOWL2Handler::jumpFunctionParseObjectExactlyCardinalityNode);
286 mParseFunctionJumpHash.insert("ObjectSomeValuesFrom",&CXMLOWL2Handler::jumpFunctionParseObjectSomeValuesFromNode);
287 mParseFunctionJumpHash.insert(mOWLPrefixString+":ObjectSomeValuesFrom",&CXMLOWL2Handler::jumpFunctionParseObjectSomeValuesFromNode);
288 mParseFunctionJumpHash.insert("ObjectAllValuesFrom",&CXMLOWL2Handler::jumpFunctionParseObjectAllValuesFromNode);
289 mParseFunctionJumpHash.insert(mOWLPrefixString+":ObjectAllValuesFrom",&CXMLOWL2Handler::jumpFunctionParseObjectAllValuesFromNode);
290 mParseFunctionJumpHash.insert("ObjectComplementOf",&CXMLOWL2Handler::jumpFunctionParseObjectComplementOfNode);
291 mParseFunctionJumpHash.insert(mOWLPrefixString+":ObjectComplementOf",&CXMLOWL2Handler::jumpFunctionParseObjectComplementOfNode);
292 mParseFunctionJumpHash.insert("ObjectOneOf",&CXMLOWL2Handler::jumpFunctionParseObjectOneOfNode);
293 mParseFunctionJumpHash.insert(mOWLPrefixString+":ObjectOneOf",&CXMLOWL2Handler::jumpFunctionParseObjectOneOfNode);
294 mParseFunctionJumpHash.insert("ObjectHasValue",&CXMLOWL2Handler::jumpFunctionParseObjectHasValueNode);
295 mParseFunctionJumpHash.insert(mOWLPrefixString+":ObjectHasValue",&CXMLOWL2Handler::jumpFunctionParseObjectHasValueNode);
296 mParseFunctionJumpHash.insert("ObjectHasSelf",&CXMLOWL2Handler::jumpFunctionParseObjectHasSelfNode);
297 mParseFunctionJumpHash.insert(mOWLPrefixString+":ObjectHasSelf",&CXMLOWL2Handler::jumpFunctionParseObjectHasSelfNode);
298
299 mParseFunctionJumpHash.insert("NamedIndividual",&CXMLOWL2Handler::jumpFunctionParseNamedIndividualNode);
300 mParseFunctionJumpHash.insert(mOWLPrefixString+":NamedIndividual",&CXMLOWL2Handler::jumpFunctionParseNamedIndividualNode);
301 mParseFunctionJumpHash.insert("AnonymousIndividual",&CXMLOWL2Handler::jumpFunctionParseAnonymousIndividualNode);
302 mParseFunctionJumpHash.insert(mOWLPrefixString+":AnonymousIndividual",&CXMLOWL2Handler::jumpFunctionParseAnonymousIndividualNode);
303 mParseFunctionJumpHash.insert("ClassAssertion",&CXMLOWL2Handler::jumpFunctionParseClassAssertionNode);
304 mParseFunctionJumpHash.insert(mOWLPrefixString+":ClassAssertion",&CXMLOWL2Handler::jumpFunctionParseClassAssertionNode);
305 mParseFunctionJumpHash.insert("ObjectPropertyAssertion",&CXMLOWL2Handler::jumpFunctionParseObjectPropertyAssertionNode);
306 mParseFunctionJumpHash.insert(mOWLPrefixString+":ObjectPropertyAssertion",&CXMLOWL2Handler::jumpFunctionParseObjectPropertyAssertionNode);
307 mParseFunctionJumpHash.insert("NegativeObjectPropertyAssertion",&CXMLOWL2Handler::jumpFunctionParseNegativeObjectPropertyAssertionNode);
308 mParseFunctionJumpHash.insert(mOWLPrefixString+":NegativeObjectPropertyAssertion",&CXMLOWL2Handler::jumpFunctionParseNegativeObjectPropertyAssertionNode);
309 mParseFunctionJumpHash.insert("SameIndividual",&CXMLOWL2Handler::jumpFunctionParseSameIndividualNode);
310 mParseFunctionJumpHash.insert(mOWLPrefixString+":SameIndividual",&CXMLOWL2Handler::jumpFunctionParseSameIndividualNode);
311 mParseFunctionJumpHash.insert("DifferentIndividuals",&CXMLOWL2Handler::jumpFunctionParseDifferentIndividualsNode);
312 mParseFunctionJumpHash.insert(mOWLPrefixString+":DifferentIndividuals",&CXMLOWL2Handler::jumpFunctionParseDifferentIndividualsNode);
313
314 mParseFunctionJumpHash.insert("#text",&CXMLOWL2Handler::jumpFunctionParseIgnoredNode);
315 mParseFunctionJumpHash.insert("#comment",&CXMLOWL2Handler::jumpFunctionParseIgnoredNode);
316 mParseFunctionJumpHash.insert("ExpectedResult",&CXMLOWL2Handler::jumpFunctionParseIgnoredNode);
317
318 mParseFunctionJumpHash.insert("Ontology",&CXMLOWL2Handler::jumpFunctionTellOntologyAxiomNode);
319 mParseFunctionJumpHash.insert("Tell",&CXMLOWL2Handler::jumpFunctionTellOntologyAxiomNode);
320 mParseFunctionJumpHash.insert("Whereby",&CXMLOWL2Handler::jumpFunctionTellOntologyAxiomNode);
321 mParseFunctionJumpHash.insert("Retract",&CXMLOWL2Handler::jumpFunctionRetractOntologyAxiomNode);
322
323
324 mParseFunctionJumpHash.insert("DLSafeRule",&CXMLOWL2Handler::jumpFunctionParseRuleNode);
325 mParseFunctionJumpHash.insert(mOWLPrefixString+":DLSafeRule",&CXMLOWL2Handler::jumpFunctionParseRuleNode);
326
327 mParseFunctionJumpHash.insert("Head",&CXMLOWL2Handler::jumpFunctionParseRuleAtomHeadNode);
328 mParseFunctionJumpHash.insert(mOWLPrefixString+":Head",&CXMLOWL2Handler::jumpFunctionParseRuleAtomHeadNode);
329 mParseFunctionJumpHash.insert("Body",&CXMLOWL2Handler::jumpFunctionParseRuleAtomBodyNode);
330 mParseFunctionJumpHash.insert(mOWLPrefixString+":Body",&CXMLOWL2Handler::jumpFunctionParseRuleAtomBodyNode);
331 mParseFunctionJumpHash.insert("ObjectPropertyAtom",&CXMLOWL2Handler::jumpFunctionParseRulePropertyAtomNode);
332 mParseFunctionJumpHash.insert(mOWLPrefixString+":ObjectPropertyAtom",&CXMLOWL2Handler::jumpFunctionParseRulePropertyAtomNode);
333 mParseFunctionJumpHash.insert("ClassAtom",&CXMLOWL2Handler::jumpFunctionParseRuleClassAtomNode);
334 mParseFunctionJumpHash.insert(mOWLPrefixString+":ClassAtom",&CXMLOWL2Handler::jumpFunctionParseRuleClassAtomNode);
335
336 return true;
337 }
338
339
340
341
342 CRulePropertyAtomTermExpression* CXMLOWL2Handler::parseRuleObjectPropertyAtomNode(CParseStackObject* parseStackObj) {
343 CRulePropertyAtomTermExpression* rulePropertyAtomExp = nullptr;
344 if (parseStackObj->hasExpressions()) {
345 CParsingExpressionSplitter mParsingExpSpl(parseStackObj->getExpressions());
346 if (mParsingExpSpl.proofExpressionComposition(0,1,0,2,0)) {
347 rulePropertyAtomExp = new CRulePropertyAtomTermExpression(mParsingExpSpl.getFirstClassVariableTermExpression(),mParsingExpSpl.getSecondClassVariableTermExpression(),mParsingExpSpl.getFirstObjectPropertyTermExpression());
348 mRuleExpContainer.append(rulePropertyAtomExp);
349 }
350 }
351 return rulePropertyAtomExp;
352 }
353
354 CRuleClassAtomTermExpression* CXMLOWL2Handler::parseRuleClassAtomNode(CParseStackObject* parseStackObj) {
355 CRuleClassAtomTermExpression* ruleClassAtomExp = nullptr;
356 if (parseStackObj->hasExpressions()) {
357 CParsingExpressionSplitter mParsingExpSpl(parseStackObj->getExpressions());
358 if (mParsingExpSpl.proofExpressionComposition(2,0,0,1,1)) {
359 ruleClassAtomExp = new CRuleClassAtomTermExpression(mParsingExpSpl.getFirstClassTermExpression(),mParsingExpSpl.getFirstClassVariableTermExpression());
360 mRuleExpContainer.append(ruleClassAtomExp);
361 }
362 }
363 return ruleClassAtomExp;
364 }
365
366
367 CRuleAtomListBodyExpression* CXMLOWL2Handler::parseRuleAtomBodyNode(CParseStackObject* parseStackObj) {
368 CRuleAtomListBodyExpression* ruleAtomBodyExp = nullptr;
369 if (parseStackObj->hasExpressions()) {
370 QList<CBuildExpression*>* expList = &parseStackObj->mExpList;
371 QList<CRuleAtomTermExpression*> atomExpList;
372 for (QList<CBuildExpression*>::const_iterator it = expList->constBegin(), itEnd = expList->constEnd(); it != itEnd; ++it) {
373 CRuleAtomTermExpression* ruleAtTeExp = dynamic_cast<CRuleAtomTermExpression*>(*it);
374 if (ruleAtTeExp) {
375 atomExpList.append(ruleAtTeExp);
376 }
377 }
378 if (!atomExpList.isEmpty()) {
379 ruleAtomBodyExp = new CRuleAtomListBodyExpression(atomExpList);
380 mRuleExpContainer.append(ruleAtomBodyExp);
381 }
382 }
383 return ruleAtomBodyExp;
384 }
385
386
387 CRuleAtomListHeadExpression* CXMLOWL2Handler::parseRuleAtomHeadNode(CParseStackObject* parseStackObj) {
388 CRuleAtomListHeadExpression* ruleAtomHeadExp = nullptr;
389 if (parseStackObj->hasExpressions()) {
390 QList<CBuildExpression*>* expList = &parseStackObj->mExpList;
391 QList<CRuleAtomTermExpression*> atomExpList;
392 for (QList<CBuildExpression*>::const_iterator it = expList->constBegin(), itEnd = expList->constEnd(); it != itEnd; ++it) {
393 CRuleAtomTermExpression* ruleAtTeExp = dynamic_cast<CRuleAtomTermExpression*>(*it);
394 if (ruleAtTeExp) {
395 atomExpList.append(ruleAtTeExp);
396 }
397 }
398 if (!atomExpList.isEmpty()) {
399 ruleAtomHeadExp = new CRuleAtomListHeadExpression(atomExpList);
400 mRuleExpContainer.append(ruleAtomHeadExp);
401 }
402 }
403 return ruleAtomHeadExp;
404 }
405
406
407
408 QHash<QString,CParseRuleAtom*> CXMLOWL2Handler::createVariableAtomHash(const QList<CParseRuleAtom*>& atomList) {
409 QHash<QString,CParseRuleAtom*> variableAtomHash;
410 foreach (CParseRuleAtom* atom, atomList) {
411 if (!atom->mVariableName1.isEmpty()) {
412 variableAtomHash.insertMulti(atom->mVariableName1,atom);
413 }
414 if (!atom->mVariableName2.isEmpty()) {
415 variableAtomHash.insertMulti(atom->mVariableName2,atom);
416 }
417 }
418 return variableAtomHash;
419 }
420
421
422
423 QMap<cint64,QString> CXMLOWL2Handler::createVariableCountMap(const QList<CParseRuleAtom*>& atomList) {
424 QHash<QString,cint64> variableCountHash;
425 foreach (CParseRuleAtom* atom, atomList) {
426 if (!atom->mVariableName1.isEmpty()) {
427 cint64 prevCount = variableCountHash.value(atom->mVariableName1,0);
428 variableCountHash.insert(atom->mVariableName1,prevCount+1);
429 }
430 if (!atom->mVariableName2.isEmpty()) {
431 cint64 prevCount = variableCountHash.value(atom->mVariableName2,0);
432 variableCountHash.insert(atom->mVariableName2,prevCount+1);
433 }
434 }
435 QMap<cint64,QString> countVariableMap;
436 for (QHash<QString,cint64>::const_iterator it = variableCountHash.constBegin(), itEnd = variableCountHash.constEnd(); it != itEnd; ++it) {
437 const QString& variableName = it.key();
438 cint64 variableAtomCount = it.value();
439 countVariableMap.insertMulti(variableAtomCount,variableName);
440 }
441 return countVariableMap;
442 }
443
444
445
446 QList<CParseRuleAtom*> CXMLOWL2Handler::parseRuleAtomNodes(CParseStackObject* parseStackObj, const CQtList<CBuildExpression*>& buildExpList, bool parseHeadAtoms) {
447 QList<CParseRuleAtom*> atomList;
448 for (CQtList<CBuildExpression*>::const_iterator it1 = buildExpList.constBegin(), it1End = buildExpList.constEnd(); it1 != it1End; ++it1) {
449 CRuleAtomListExpression* buildListExp = nullptr;
450 CRuleAtomListBodyExpression* buildBodyListExp = dynamic_cast<CRuleAtomListBodyExpression*>(*it1);
451 CRuleAtomListHeadExpression* buildHeadListExp = dynamic_cast<CRuleAtomListHeadExpression*>(*it1);
452 if (parseHeadAtoms) {
453 buildListExp = buildHeadListExp;
454 }
455 if (!parseHeadAtoms) {
456 buildListExp = buildBodyListExp;
457 }
458 if (buildListExp) {
459 CEXPRESSIONLIST<CRuleAtomTermExpression*>* ruleAtomExpList = buildListExp->getRuleAtomTermExpressionList();
460 for (CEXPRESSIONLIST<CRuleAtomTermExpression*>::const_iterator it2 = ruleAtomExpList->constBegin(), it2End = ruleAtomExpList->constEnd(); it2 != it2End; ++it2) {
461 CRuleAtomTermExpression* ruleAtomExp = *it2;
462
463 CParseRuleAtom* ruleAtom = nullptr;
464
465 if (ruleAtomExp->getType() == CBuildExpression::BETRULEPROPERTYATOM) {
466 CRulePropertyAtomTermExpression* rulePropertyAtomExp = (CRulePropertyAtomTermExpression*)ruleAtomExp;
467 CEXPRESSIONLIST<CObjectIndividualVariableExpression*>* varList = rulePropertyAtomExp->getClassVariableTermExpressionList();
468 ruleAtom = new CParseRuleAtom(CParseRuleAtom::PROPERTYATOM);
469 ruleAtom->mVariableName1 = varList->first()->getName();
470 ruleAtom->mVariableName2 = varList->last()->getName();
471 ruleAtom->mAtomExpression = rulePropertyAtomExp->getObjectPropertyTermExpression();
472 atomList.append(ruleAtom);
473 } else if (ruleAtomExp->getType() == CBuildExpression::BETRULECLASSATOM) {
474 CRuleClassAtomTermExpression* ruleClassAtomExp = (CRuleClassAtomTermExpression*)ruleAtomExp;
475 ruleAtom = new CParseRuleAtom(CParseRuleAtom::CLASSATOM);
476 ruleAtom->mVariableName1 = ruleClassAtomExp->getClassVariableExpression()->getName();
477 ruleAtom->mAtomExpression = ruleClassAtomExp->getClassTermExpression();
478 atomList.append(ruleAtom);
479 }
480
481 }
482 }
483
484 }
485
486 return atomList;
487 }
488
489
490
491
492 void CXMLOWL2Handler::parseRuleNode(CParseStackObject* parseStackObj) {
493 if (parseStackObj->hasExpressions()) {
494 QList<CBuildExpression*> expressionList;
495
496 QHash<QString,CParseRuleAtom*> bodyVariableAtomHash;
497 QHash<QString,CParseRuleAtom*> headVariableAtomHash;
498
499 CQtList<CBuildExpression*> buildExpList(*parseStackObj->getExpressions());
500
501 QList<CParseRuleAtom*> bodyVariableAtomList = parseRuleAtomNodes(parseStackObj,buildExpList,false);
502 QList<CParseRuleAtom*> headVariableAtomList = parseRuleAtomNodes(parseStackObj,buildExpList,true);
503
504 bodyVariableAtomHash = createVariableAtomHash(bodyVariableAtomList);
505 headVariableAtomHash = createVariableAtomHash(headVariableAtomList);
506
507 QMap<cint64,QString> headCountVariableMap = createVariableCountMap(headVariableAtomList);
508
509
510 QSet<CParseRuleAtom*> headProcessedAtomSet;
511
512 QList<QString> reversHeadCountVariableList;
513 for (QMap<cint64,QString>::const_iterator it = headCountVariableMap.constBegin(), itEnd = headCountVariableMap.constEnd(); it != itEnd; ++it) {
514 const QString& varString = it.value();
515 reversHeadCountVariableList.prepend(varString);
516 }
517
518 for (QList<QString>::const_iterator it = reversHeadCountVariableList.constBegin(), itEnd = reversHeadCountVariableList.constEnd(); it != itEnd; ++it) {
519 const QString& varString = *it;
520
521 QSet<CParseRuleAtom*> processedBodyAtoms;
522 QList<CParseRuleAtom*> headAtomList = headVariableAtomHash.values(varString);
523 QList<CBuildExpression*> headExpressionList;
524 foreach (CParseRuleAtom* headAtom, headAtomList) {
525 if (!headProcessedAtomSet.contains(headAtom)) {
526 headProcessedAtomSet.insert(headAtom);
527
528 if (headAtom->mAtomType == CParseRuleAtom::PROPERTYATOM) {
529 bool inversed = false;
530 QString otherVarString = headAtom->getOtherVariable(varString,inversed);
531 CBuildExpression* otherVarExp = mOntoBuilder->getNominalIndividualVariable(otherVarString,mAxiomNumber);
532 CBuildExpression* someExp = mOntoBuilder->getObjectSomeValuesFrom(getNeighbourAtomObjectPropertyExpression(headAtom,inversed),otherVarExp);
533 headExpressionList.append(someExp);
534 } else if (headAtom->mAtomType == CParseRuleAtom::CLASSATOM) {
535 headExpressionList.append(headAtom->mAtomExpression);
536 }
537
538 }
539 }
540
541 if (!headExpressionList.isEmpty()) {
542 CBuildExpression* headExp = nullptr;
543 if (headExpressionList.count() >= 2) {
544 headExp = mOntoBuilder->getObjectIntersectionOf(headExpressionList);
545 } else {
546 headExp = headExpressionList.first();
547 }
548
549 CBuildExpression* bodyExp = createBodyExpresions(varString,bodyVariableAtomHash,headVariableAtomHash);
550 CBuildExpression* axiomExp = mOntoBuilder->getSubClassOf(bodyExp,headExp);
551 expressionList.append(axiomExp);
552 }
553
554 ++mAxiomNumber;
555 }
556
557 addTemporaryBuildExpressions(&expressionList);
558 }
559 }
560
561
562 CBuildExpression* CXMLOWL2Handler::createBodyExpresions(const QString& varString, QHash<QString,CParseRuleAtom*>& bodyVariableAtomHash, QHash<QString,CParseRuleAtom*>& headVariableAtomHash) {
563 QSet<QString> processedVarSet;
564 QSet<CParseRuleAtom*> processedAtomSet;
565 QList<CBuildExpression*> expList;
566 CBuildExpression* mainExp = createBodyExpresions(varString,true,bodyVariableAtomHash,processedVarSet,processedAtomSet,headVariableAtomHash);
567 expList.append(mainExp);
568
569 for (QHash<QString,CParseRuleAtom*>::const_iterator it = bodyVariableAtomHash.constBegin(), itEnd = bodyVariableAtomHash.constEnd(); it != itEnd; ++it) {
570 QString nextVarString = it.key();
571 if (!processedVarSet.contains(nextVarString)) {
572 CBuildExpression* topPropExp = mOntoBuilder->getTopObjectProberty();
573 CBuildExpression* succExp = createBodyExpresions(nextVarString,true,bodyVariableAtomHash,processedVarSet,processedAtomSet,headVariableAtomHash);
574 CBuildExpression* someExp = mOntoBuilder->getObjectSomeValuesFrom(topPropExp,succExp);
575 expList.append(someExp);
576 }
577 }
578
579 if (expList.count() >= 2) {
580 return mOntoBuilder->getObjectIntersectionOf(expList);
581 }
582 return expList.first();
583 }
584
585 CBuildExpression* CXMLOWL2Handler::getNeighbourAtomObjectPropertyExpression(CParseRuleAtom* ruleAtom, bool inversed) {
586 if (!inversed) {
587 return ruleAtom->mAtomExpression;
588 } else {
589 return mOntoBuilder->getInverseObjectPropertyOf(ruleAtom->mAtomExpression);
590 }
591 }
592
593
594
595 bool CXMLOWL2Handler::hasBackExpressionLinks(const QString& varString, CParseRuleAtom* notRuleAtom, QHash<QString,CParseRuleAtom*>& bodyVariableAtomHash, QSet<QString>& processedVarSet,
596 QSet<CParseRuleAtom*>& processedAtomSet, QHash<QString,CParseRuleAtom*>& headVariableAtomHash) {
597
598 QSet<QString> backTestProcessedVarSet;
599 QSet<CParseRuleAtom*> backTestProcessedAtomSet;
600
601 return hasBackExpressionLinks(varString,notRuleAtom,bodyVariableAtomHash,processedVarSet,processedAtomSet,headVariableAtomHash,backTestProcessedVarSet,backTestProcessedAtomSet);
602 }
603
604
605
606 bool CXMLOWL2Handler::hasBackExpressionLinks(const QString& varString, CParseRuleAtom* notRuleAtom, QHash<QString,CParseRuleAtom*>& bodyVariableAtomHash, QSet<QString>& processedVarSet,
607 QSet<CParseRuleAtom*>& processedAtomSet, QHash<QString,CParseRuleAtom*>& headVariableAtomHash, QSet<QString>& backTestProcessedVarSet, QSet<CParseRuleAtom*>& backTestProcessedAtomSet) {
608
609 if (processedVarSet.contains(varString)) {
610 return false;
611 }
612 if (!backTestProcessedVarSet.contains(varString)) {
613 backTestProcessedVarSet.insert(varString);
614
615 QList<CParseRuleAtom*> atomList = bodyVariableAtomHash.values(varString);
616 foreach (CParseRuleAtom* ruleAtom, atomList) {
617 if (ruleAtom->mAtomType == CParseRuleAtom::PROPERTYATOM) {
618 if (ruleAtom != notRuleAtom) {
619 if (processedAtomSet.contains(ruleAtom)) {
620 return true;
621 }
622 if (!backTestProcessedAtomSet.contains(ruleAtom)) {
623 backTestProcessedAtomSet.insert(ruleAtom);
624 bool inversed = false;
625 QString otherVarString = ruleAtom->getOtherVariable(varString,inversed);
626 if (hasBackExpressionLinks(otherVarString,ruleAtom,bodyVariableAtomHash,processedVarSet,processedAtomSet,headVariableAtomHash,backTestProcessedVarSet,backTestProcessedAtomSet)) {
627 return true;
628 }
629 }
630 }
631 }
632 }
633 }
634 return false;
635 }
636
637
638 CBuildExpression* CXMLOWL2Handler::createBodyExpresions(const QString& varString, bool direct, QHash<QString,CParseRuleAtom*>& bodyVariableAtomHash, QSet<QString>& processedVarSet, QSet<CParseRuleAtom*>& processedAtomSet, QHash<QString,CParseRuleAtom*>& headVariableAtomHash) {
639 QList<CBuildExpression*> expList;
640 expList.append(mOntoBuilder->getNominalIndividualVariable(varString,mAxiomNumber));
641
642 if (!processedVarSet.contains(varString)) {
643 processedVarSet.insert(varString);
644
645 QList<CParseRuleAtom*> atomList = bodyVariableAtomHash.values(varString);
646 QList<CParseRuleAtom*> processList;
647 foreach (CParseRuleAtom* ruleAtom, atomList) {
648 if (ruleAtom->mAtomType == CParseRuleAtom::PROPERTYATOM) {
649 if (!processedAtomSet.contains(ruleAtom)) {
650
651 bool inversed = false;
652 QString otherVarString = ruleAtom->getOtherVariable(varString,inversed);
653
654 if (direct || !headVariableAtomHash.contains(varString) || !hasBackExpressionLinks(otherVarString,ruleAtom,bodyVariableAtomHash,processedVarSet,processedAtomSet,headVariableAtomHash)) {
655
656 processedAtomSet.insert(ruleAtom);
657 processList.append(ruleAtom);
658 }
659 }
660 } else if (ruleAtom->mAtomType == CParseRuleAtom::CLASSATOM) {
661 processList.append(ruleAtom);
662 }
663 }
664 foreach (CParseRuleAtom* ruleAtom, processList) {
665
666 if (ruleAtom->mAtomType == CParseRuleAtom::PROPERTYATOM) {
667 bool inversed = false;
668 QString otherVarString = ruleAtom->getOtherVariable(varString,inversed);
669 CBuildExpression* succExp = createBodyExpresions(otherVarString,false,bodyVariableAtomHash,processedVarSet,processedAtomSet,headVariableAtomHash);
670 CBuildExpression* someExp = mOntoBuilder->getObjectSomeValuesFrom(getNeighbourAtomObjectPropertyExpression(ruleAtom,inversed),succExp);
671 expList.append(someExp);
672 } else if (ruleAtom->mAtomType == CParseRuleAtom::CLASSATOM) {
673 expList.append(ruleAtom->mAtomExpression);
674 }
675
676 }
677 }
678 if (expList.count() >= 2) {
679 return mOntoBuilder->getObjectIntersectionOf(expList);
680 }
681 return expList.first();
682 }
683
684
685
686 void CXMLOWL2Handler::parseBuildNode(CParseStackObject* parseStackObj) {
687 const QString& nodeString(parseStackObj->mQName);
688
689 ParseFunction function = mParseFunctionJumpHash.value(nodeString);
690 if (function) {
691 (this->*function)(parseStackObj);
692 if (!mStack.isEmpty() && !mTmpExpList.isEmpty()) {
693 CParseStackObject* topParsStackObj = mStack.top();
694 topParsStackObj->addBuildExpressions(&mTmpExpList);
695 }
696 } else {
697 const QString& notSupportedNodeString(nodeString);
698 CNotSupportedNodeErrorRecord::makeRecord(notSupportedNodeString,&recordRouter);
699 }
700 mTmpExpList.clear();
701 }
702
703
704 CDeclarationAxiomExpression* CXMLOWL2Handler::parseDeclarationNode(CParseStackObject* parseStackObj) {
705 CDeclarationAxiomExpression* declarationExpression = nullptr;
706 if (parseStackObj->hasExpressions()) {
707 declarationExpression = mOntoBuilder->getDeclaration(*parseStackObj->getExpressions());
708 ++mAxiomNumber;
709 }
710 return declarationExpression;
711 }
712
713
714 CObjectPropertyExpression *CXMLOWL2Handler::parseObjectPropertyNode(CParseStackObject* parseStackObj) {
715 const QString& probName = getEntityName(parseStackObj);
716 CObjectPropertyExpression *objectExpression = 0;
717 if (!probName.isEmpty()) {
718 objectExpression = mOntoBuilder->getObjectProberty(probName);
719 }
720 return objectExpression;
721 }
722
723
724 CClassExpression *CXMLOWL2Handler::parseClassNode(CParseStackObject* parseStackObj) {
725 const QString& className = getEntityName(parseStackObj);
726 CClassExpression *classExpression = 0;
727 if (!className.isEmpty()) {
728 classExpression = mOntoBuilder->getClass(className);
729 }
730 return classExpression;
731 }
732
733
734 CObjectIndividualVariableExpression* CXMLOWL2Handler::parseIndividualVariableNode(CParseStackObject* parseStackObj) {
735 const QString& indiVarName = getEntityName(parseStackObj);
736 CObjectIndividualVariableExpression *indiVarExpression = 0;
737 if (!indiVarName.isEmpty()) {
738 indiVarExpression = mOntoBuilder->getNominalIndividualVariable(indiVarName,mAxiomNumber);
739 }
740 return indiVarExpression;
741 }
742
743
744
745
746 CEquivalentClassesExpression *CXMLOWL2Handler::parseEquivalentClassesNode(CParseStackObject* parseStackObj) {
747 CEquivalentClassesExpression *ecExp = 0;
748 if (parseStackObj->hasExpressions()) {
749 ecExp = mOntoBuilder->getEquivalentClasses(*parseStackObj->getExpressions());
750 ++mAxiomNumber;
751 }
752 return ecExp;
753 }
754
755
756 CSubClassOfExpression *CXMLOWL2Handler::parseSubClassOfNode(CParseStackObject* parseStackObj) {
757 CSubClassOfExpression *scoExp = 0;
758 if (parseStackObj->hasExpressions()) {
759 scoExp = mOntoBuilder->getSubClassOf(*parseStackObj->getExpressions());
760 ++mAxiomNumber;
761 }
762 return scoExp;
763 }
764
765
766 CObjectPropertyDomainExpression *CXMLOWL2Handler::parseObjectPropertyDomainNode(CParseStackObject* parseStackObj) {
767 CObjectPropertyDomainExpression *obPrDoExp = 0;
768 if (parseStackObj->hasExpressions()) {
769 obPrDoExp = mOntoBuilder->getObjectPropertyDomainExpression(*parseStackObj->getExpressions());
770 ++mAxiomNumber;
771 }
772 return obPrDoExp;
773 }
774
775 CObjectPropertyRangeExpression *CXMLOWL2Handler::parseObjectPropertyRangeNode(CParseStackObject* parseStackObj) {
776 CObjectPropertyRangeExpression *obPrRaExp = 0;
777 if (parseStackObj->hasExpressions()) {
778 obPrRaExp = mOntoBuilder->getObjectPropertyRangeExpression(*parseStackObj->getExpressions());
779 ++mAxiomNumber;
780 }
781 return obPrRaExp;
782 }
783
784
785 CSubObjectPropertyOfExpression *CXMLOWL2Handler::parseSubObjectPropertyOfNode(CParseStackObject* parseStackObj) {
786 CSubObjectPropertyOfExpression *sopoExp = 0;
787 if (parseStackObj->hasExpressions()) {
788 sopoExp = mOntoBuilder->getSubObjectPropertyOf(*parseStackObj->getExpressions());
789 ++mAxiomNumber;
790 }
791 return sopoExp;
792 }
793
794 CObjectPropertyChainExpression *CXMLOWL2Handler::parseObjectPropertyChainNode(CParseStackObject* parseStackObj) {
795 CObjectPropertyChainExpression *sopoExp = 0;
796 if (parseStackObj->hasExpressions()) {
797 sopoExp = mOntoBuilder->getObjectPropertyChain(*parseStackObj->getExpressions());
798 }
799 return sopoExp;
800 }
801
802 CEquivalentObjectPropertiesExpression *CXMLOWL2Handler::parseEquivalentObjectPropertiesNode(CParseStackObject* parseStackObj) {
803 CEquivalentObjectPropertiesExpression *sopoExp = 0;
804 if (parseStackObj->hasExpressions()) {
805 sopoExp = mOntoBuilder->getEquivalentObjectProperties(*parseStackObj->getExpressions());
806 ++mAxiomNumber;
807 }
808 return sopoExp;
809 }
810
811 CDisjointObjectPropertiesExpression *CXMLOWL2Handler::parseDisjointObjectPropertiesNode(CParseStackObject* parseStackObj) {
812 CDisjointObjectPropertiesExpression *sopoExp = 0;
813 if (parseStackObj->hasExpressions()) {
814 sopoExp = mOntoBuilder->getDisjointObjectProperties(*parseStackObj->getExpressions());
815 ++mAxiomNumber;
816 }
817 return sopoExp;
818 }
819
820 CInverseObjectPropertyOfExpression *CXMLOWL2Handler::parseInverseObjectPropertyOfNode(CParseStackObject* parseStackObj) {
821 CInverseObjectPropertyOfExpression *iopoExp = 0;
822 if (parseStackObj->hasExpressions()) {
823 iopoExp = mOntoBuilder->getInverseObjectPropertyOf(*parseStackObj->getExpressions());
824 }
825 return iopoExp;
826 }
827
828 CInverseObjectPropertiesExpression *CXMLOWL2Handler::parseInverseObjectPropertiesNode(CParseStackObject* parseStackObj) {
829 CInverseObjectPropertiesExpression *iopoExp = 0;
830 if (parseStackObj->hasExpressions()) {
831 iopoExp = mOntoBuilder->getInverseObjectProperties(*parseStackObj->getExpressions());
832 ++mAxiomNumber;
833 }
834 return iopoExp;
835 }
836
837
838 CDisjointClassesExpression *CXMLOWL2Handler::parseDisjontClassesNode(CParseStackObject* parseStackObj) {
839 CDisjointClassesExpression *disClassExp = 0;
840 if (parseStackObj->hasExpressions()) {
841 disClassExp = mOntoBuilder->getDisjointClasses(*parseStackObj->getExpressions());
842 ++mAxiomNumber;
843 }
844 return disClassExp;
845 }
846
847 CDisjointUnionExpression *CXMLOWL2Handler::parseDisjontUnionNode(CParseStackObject* parseStackObj) {
848 CDisjointUnionExpression *disClassExp = 0;
849 if (parseStackObj->hasExpressions()) {
850 disClassExp = mOntoBuilder->getDisjointUnion(*parseStackObj->getExpressions());
851 }
852 return disClassExp;
853 }
854
855
856
857 CObjectIntersectionOfExpression *CXMLOWL2Handler::parseObjectIntersectionOfNode(CParseStackObject* parseStackObj) {
858 CObjectIntersectionOfExpression *exp = 0;
859 if (parseStackObj->hasExpressions()) {
860 exp = mOntoBuilder->getObjectIntersectionOf(*parseStackObj->getExpressions());
861 }
862 return exp;
863 }
864
865 CObjectUnionOfExpression *CXMLOWL2Handler::parseObjectUnionOfNode(CParseStackObject* parseStackObj) {
866 CObjectUnionOfExpression *exp = 0;
867 if (parseStackObj->hasExpressions()) {
868 exp = mOntoBuilder->getObjectUnionOf(*parseStackObj->getExpressions());
869 }
870 return exp;
871 }
872
873 CObjectMaxCardinalityExpression *CXMLOWL2Handler::parseObjectMaxCardinalityNode(CParseStackObject* parseStackObj) {
874 QString cardinalityName = getCardinality(parseStackObj);
875 CObjectMaxCardinalityExpression *exp = 0;
876 if (!cardinalityName.isEmpty()) {
877 exp = mOntoBuilder->getObjectMaxCardinality(*parseStackObj->getExpressions(),cardinalityName.toInt());
878 }
879 return exp;
880 }
881
882 CObjectMinCardinalityExpression *CXMLOWL2Handler::parseObjectMinCardinalityNode(CParseStackObject* parseStackObj) {
883 QString cardinalityName = getCardinality(parseStackObj);
884 CObjectMinCardinalityExpression *exp = 0;
885 if (!cardinalityName.isEmpty()) {
886 exp = mOntoBuilder->getObjectMinCardinality(*parseStackObj->getExpressions(),cardinalityName.toInt());
887 }
888 return exp;
889 }
890
891 CObjectExactlyCardinalityExpression *CXMLOWL2Handler::parseObjectExactlyCardinalityNode(CParseStackObject* parseStackObj) {
892 QString cardinalityName = getCardinality(parseStackObj);
893 CObjectExactlyCardinalityExpression *exp = 0;
894 if (!cardinalityName.isEmpty()) {
895 exp = mOntoBuilder->getObjectExactlyCardinality(*parseStackObj->getExpressions(),cardinalityName.toInt());
896 }
897 return exp;
898 }
899
900 CObjectSomeValuesFromExpression *CXMLOWL2Handler::parseObjectSomeValuesFromNode(CParseStackObject* parseStackObj) {
901 CObjectSomeValuesFromExpression *exp = 0;
902 if (parseStackObj->hasExpressions()) {
903 exp = mOntoBuilder->getObjectSomeValuesFrom(*parseStackObj->getExpressions());
904 }
905 return exp;
906 }
907
908 CObjectHasValueExpression* CXMLOWL2Handler::parseObjectHasValueNode(CParseStackObject* parseStackObj) {
909 CObjectHasValueExpression *exp = 0;
910 if (parseStackObj->hasExpressions()) {
911 exp = mOntoBuilder->getObjectHasValue(*parseStackObj->getExpressions());
912 }
913 return exp;
914 }
915
916 CObjectHasSelfExpression* CXMLOWL2Handler::parseObjectHasSelfNode(CParseStackObject* parseStackObj) {
917 CObjectHasSelfExpression *exp = 0;
918 if (parseStackObj->hasExpressions()) {
919 exp = mOntoBuilder->getObjectHasSelf(*parseStackObj->getExpressions());
920 }
921 return exp;
922 }
923
924
925 CObjectAllValuesFromExpression *CXMLOWL2Handler::parseObjectAllValuesFromNode(CParseStackObject* parseStackObj) {
926 CObjectAllValuesFromExpression *exp = 0;
927 if (parseStackObj->hasExpressions()) {
928 exp = mOntoBuilder->getObjectAllValuesFrom(*parseStackObj->getExpressions());
929 }
930 return exp;
931 }
932
933
934 CObjectComplementOfExpression *CXMLOWL2Handler::parseObjectComplementOfNode(CParseStackObject* parseStackObj) {
935 CObjectComplementOfExpression *exp = 0;
936 if (parseStackObj->hasExpressions()) {
937 exp = mOntoBuilder->getObjectComplementOf(*parseStackObj->getExpressions());
938 }
939 return exp;
940 }
941
942 CObjectOneOfExpression *CXMLOWL2Handler::parseObjectOneOfNode(CParseStackObject* parseStackObj) {
943 CObjectOneOfExpression *exp = 0;
944 if (parseStackObj->hasExpressions()) {
945 exp = mOntoBuilder->getObjectOneOf(*parseStackObj->getExpressions());
946 }
947 return exp;
948 }
949
950
951 CTransetiveObjectPropertyExpression *CXMLOWL2Handler::parseTransetiveObjectPropertyNode(CParseStackObject* parseStackObj) {
952 CTransetiveObjectPropertyExpression *exp = 0;
953 if (parseStackObj->hasExpressions()) {
954 exp = mOntoBuilder->getTransetiveObjectProperty(*parseStackObj->getExpressions());
955 ++mAxiomNumber;
956 }
957 return exp;
958 }
959
960
961 CFunctionalObjectPropertyExpression *CXMLOWL2Handler::parseFunctionalObjectPropertyNode(CParseStackObject* parseStackObj) {
962 CFunctionalObjectPropertyExpression *exp = 0;
963 if (parseStackObj->hasExpressions()) {
964 exp = mOntoBuilder->getFunctionalObjectProperty(*parseStackObj->getExpressions());
965 ++mAxiomNumber;
966 }
967 return exp;
968 }
969
970
971 CSymmetricObjectPropertyExpression* CXMLOWL2Handler::parseSymmetricObjectPropertyNode(CParseStackObject* parseStackObj) {
972 CSymmetricObjectPropertyExpression *exp = 0;
973 if (parseStackObj->hasExpressions()) {
974 exp = mOntoBuilder->getSymmetricObjectProperty(*parseStackObj->getExpressions());
975 ++mAxiomNumber;
976 }
977 return exp;
978 }
979
980 CAsymmetricObjectPropertyExpression* CXMLOWL2Handler::parseAsymmetricObjectPropertyNode(CParseStackObject* parseStackObj) {
981 CAsymmetricObjectPropertyExpression *exp = 0;
982 if (parseStackObj->hasExpressions()) {
983 exp = mOntoBuilder->getAsymmetricObjectProperty(*parseStackObj->getExpressions());
984 ++mAxiomNumber;
985 }
986 return exp;
987 }
988
989 CReflexiveObjectPropertyExpression* CXMLOWL2Handler::parseReflexiveObjectPropertyNode(CParseStackObject* parseStackObj) {
990 CReflexiveObjectPropertyExpression *exp = 0;
991 if (parseStackObj->hasExpressions()) {
992 exp = mOntoBuilder->getReflexiveObjectProperty(*parseStackObj->getExpressions());
993 ++mAxiomNumber;
994 }
995 return exp;
996 }
997
998 CIrreflexiveObjectPropertyExpression* CXMLOWL2Handler::parseIrreflexiveObjectPropertyNode(CParseStackObject* parseStackObj) {
999 CIrreflexiveObjectPropertyExpression *exp = 0;
1000 if (parseStackObj->hasExpressions()) {
1001 exp = mOntoBuilder->getIrreflexiveObjectProperty(*parseStackObj->getExpressions());
1002 ++mAxiomNumber;
1003 }
1004 return exp;
1005 }
1006
1007 CInverseFunctionalObjectPropertyExpression* CXMLOWL2Handler::parseInverseFunctionalObjectPropertyNode(CParseStackObject* parseStackObj) {
1008 CInverseFunctionalObjectPropertyExpression *exp = 0;
1009 if (parseStackObj->hasExpressions()) {
1010 exp = mOntoBuilder->getInverseFunctionalObjectProperty(*parseStackObj->getExpressions());
1011 ++mAxiomNumber;
1012 }
1013 return exp;
1014 }
1015
1016
1017
1018
1019
1020 CClassAssertionExpression *CXMLOWL2Handler::parseClassAssertionNode(CParseStackObject* parseStackObj) {
1021 CClassAssertionExpression *exp = 0;
1022 if (parseStackObj->hasExpressions()) {
1023 exp = mOntoBuilder->getClassAssertion(*parseStackObj->getExpressions());
1024 ++mAxiomNumber;
1025 }
1026 return exp;
1027 }
1028
1029
1030 CSameIndividualExpression *CXMLOWL2Handler::parseSameIndividualNode(CParseStackObject* parseStackObj) {
1031 CSameIndividualExpression *exp = 0;
1032 if (mOntoBuilder && parseStackObj->hasExpressions()) {
1033 exp = mOntoBuilder->getSameIndividual(*parseStackObj->getExpressions());
1034 ++mAxiomNumber;
1035 }
1036 return exp;
1037 }
1038
1039 CDifferentIndividualsExpression *CXMLOWL2Handler::parseDifferentIndividualsNode(CParseStackObject* parseStackObj) {
1040 CDifferentIndividualsExpression *exp = 0;
1041 if (mOntoBuilder && parseStackObj->hasExpressions()) {
1042 exp = mOntoBuilder->getDifferentIndividuals(*parseStackObj->getExpressions());
1043 ++mAxiomNumber;
1044 }
1045 return exp;
1046 }
1047
1048
1049 CNamedIndividualExpression *CXMLOWL2Handler::parseNamedIndividualNode(CParseStackObject* parseStackObj) {
1050 const QString& indiNameName = getEntityName(parseStackObj);
1051 CNamedIndividualExpression *exp = 0;
1052 if (!indiNameName.isEmpty()) {
1053 if (mOntoBuilder) {
1054 exp = mOntoBuilder->getNamedIndividual(indiNameName);
1055 }
1056 }
1057 return exp;
1058 }
1059
1060
1061 CAnonymousIndividualExpression *CXMLOWL2Handler::parseAnonymousIndividualNode(CParseStackObject* parseStackObj) {
1062 if (mOntologyIdentifier.isEmpty()) {
1063 mOntologyIdentifier = mOntoBuilder->getOntologyAnonymousIdentifier(mOntoBuilder->getOntologyName());
1064 }
1065 const QString& indiNameName = getNodeID(parseStackObj);
1066 CAnonymousIndividualExpression *exp = 0;
1067 if (!indiNameName.isEmpty()) {
1068 if (mOntoBuilder) {
1069 exp = mOntoBuilder->getAnonymousIndividual(mOntologyIdentifier,indiNameName);
1070 }
1071 }
1072 return exp;
1073 }
1074
1075 CObjectPropertyAssertionExpression *CXMLOWL2Handler::parseObjectPropertyAssertionNode(CParseStackObject* parseStackObj) {
1076 CObjectPropertyAssertionExpression *exp = 0;
1077 if (mOntoBuilder && parseStackObj->hasExpressions()) {
1078 exp = mOntoBuilder->getObjectPropertyAssertion(*parseStackObj->getExpressions());
1079 ++mAxiomNumber;
1080 }
1081 return exp;
1082 }
1083
1084 CNegativeObjectPropertyAssertionExpression *CXMLOWL2Handler::parseNegativeObjectPropertyAssertionNode(CParseStackObject* parseStackObj) {
1085 CNegativeObjectPropertyAssertionExpression *exp = 0;
1086 if (mOntoBuilder && parseStackObj->hasExpressions()) {
1087 exp = mOntoBuilder->getNegativeObjectPropertyAssertion(*parseStackObj->getExpressions());
1088 ++mAxiomNumber;
1089 }
1090 return exp;
1091 }
1092
1093
1094
1095
1096
1097
1098 void CXMLOWL2Handler::jumpFunctionParseRuleNode(CParseStackObject* parseStackObj) {
1099 parseRuleNode(parseStackObj);
1100 }
1101
1102 void CXMLOWL2Handler::jumpFunctionParseRulePropertyAtomNode(CParseStackObject* parseStackObj) {
1103 addTemporaryBuildExpression(parseRuleObjectPropertyAtomNode(parseStackObj));
1104 }
1105
1106 void CXMLOWL2Handler::jumpFunctionParseRuleClassAtomNode(CParseStackObject* parseStackObj) {
1107 addTemporaryBuildExpression(parseRuleClassAtomNode(parseStackObj));
1108 }
1109
1110 void CXMLOWL2Handler::jumpFunctionParseRuleAtomBodyNode(CParseStackObject* parseStackObj) {
1111 addTemporaryBuildExpression(parseRuleAtomBodyNode(parseStackObj));
1112 }
1113
1114 void CXMLOWL2Handler::jumpFunctionParseRuleAtomHeadNode(CParseStackObject* parseStackObj) {
1115 addTemporaryBuildExpression(parseRuleAtomHeadNode(parseStackObj));
1116 }
1117
1118
1119
1120
1121
1122
1123 void CXMLOWL2Handler::jumpFunctionTellOntologyAxiomNode(CParseStackObject* parseStackObj) {
1124 parseTellOntologyAxiomNode(parseStackObj);
1125 }
1126
1127 void CXMLOWL2Handler::jumpFunctionRetractOntologyAxiomNode(CParseStackObject* parseStackObj) {
1128 parseRetractOntologyAxiomNode(parseStackObj);
1129 }
1130
1131 void CXMLOWL2Handler::jumpFunctionParsePrefixNode(CParseStackObject* parseStackObj) {
1132 parsePrefixNode(parseStackObj);
1133 }
1134
1135
1136
1137
1138
1139
1140 void CXMLOWL2Handler::addTemporaryBuildExpression(CBuildExpression* buildExp) {
1141 if (buildExp) {
1142 mTmpExpList.append(buildExp);
1143 }
1144 }
1145
1146 void CXMLOWL2Handler::addTemporaryBuildExpressions(QList<CBuildExpression*>* buildExps) {
1147 if (buildExps) {
1148 for (QList<CBuildExpression*>::const_iterator it = buildExps->constBegin(), itEnd = buildExps->constEnd(); it != itEnd; ++it) {
1149 CBuildExpression* buildExp = *it;
1150 if (buildExp) {
1151 mTmpExpList.append(buildExp);
1152 }
1153 }
1154 }
1155 }
1156
1157
1158
1159
1160
1161 void CXMLOWL2Handler::jumpFunctionParseClassNode(CParseStackObject* parseStackObj) {
1162 addTemporaryBuildExpression(parseClassNode(parseStackObj));
1163 }
1164
1165 void CXMLOWL2Handler::jumpFunctionParseObjectPropertyNode(CParseStackObject* parseStackObj) {
1166 addTemporaryBuildExpression(parseObjectPropertyNode(parseStackObj));
1167 }
1168
1169
1170 void CXMLOWL2Handler::jumpFunctionParseIndividualVariable(CParseStackObject* parseStackObj) {
1171 addTemporaryBuildExpression(parseIndividualVariableNode(parseStackObj));
1172 }
1173
1174
1175 void CXMLOWL2Handler::jumpFunctionParseDeclarationNode(CParseStackObject* parseStackObj) {
1176 addTemporaryBuildExpression(parseDeclarationNode(parseStackObj));
1177 }
1178
1179
1180 void CXMLOWL2Handler::jumpFunctionParseEquivalentClassesNode(CParseStackObject* parseStackObj) {
1181 addTemporaryBuildExpression(parseEquivalentClassesNode(parseStackObj));
1182 }
1183
1184 void CXMLOWL2Handler::jumpFunctionParseSubClassOfNode(CParseStackObject* parseStackObj) {
1185 addTemporaryBuildExpression(parseSubClassOfNode(parseStackObj));
1186 }
1187
1188 void CXMLOWL2Handler::jumpFunctionParseDisjontClassesNode(CParseStackObject* parseStackObj) {
1189 addTemporaryBuildExpression(parseDisjontClassesNode(parseStackObj));
1190 }
1191
1192 void CXMLOWL2Handler::jumpFunctionParseDisjontUnionNode(CParseStackObject* parseStackObj) {
1193 addTemporaryBuildExpression(parseDisjontUnionNode(parseStackObj));
1194 }
1195
1196
1197 void CXMLOWL2Handler::jumpFunctionParseSubObjectPropertyOfNode(CParseStackObject* parseStackObj) {
1198 addTemporaryBuildExpression(parseSubObjectPropertyOfNode(parseStackObj));
1199 }
1200
1201 void CXMLOWL2Handler::jumpFunctionParseObjectPropertyChainNode(CParseStackObject* parseStackObj) {
1202 addTemporaryBuildExpression(parseObjectPropertyChainNode(parseStackObj));
1203 }
1204
1205 void CXMLOWL2Handler::jumpFunctionParseEquivalentObjectPropertiesNode(CParseStackObject* parseStackObj) {
1206 addTemporaryBuildExpression(parseEquivalentObjectPropertiesNode(parseStackObj));
1207 }
1208
1209 void CXMLOWL2Handler::jumpFunctionParseDisjointObjectPropertiesNode(CParseStackObject* parseStackObj) {
1210 addTemporaryBuildExpression(parseDisjointObjectPropertiesNode(parseStackObj));
1211 }
1212
1213
1214 void CXMLOWL2Handler::jumpFunctionParseObjectIntersectionOfNode(CParseStackObject* parseStackObj) {
1215 addTemporaryBuildExpression(parseObjectIntersectionOfNode(parseStackObj));
1216 }
1217
1218 void CXMLOWL2Handler::jumpFunctionParseObjectUnionOfNode(CParseStackObject* parseStackObj) {
1219 addTemporaryBuildExpression(parseObjectUnionOfNode(parseStackObj));
1220 }
1221
1222 void CXMLOWL2Handler::jumpFunctionParseObjectMaxCardinalityNode(CParseStackObject* parseStackObj) {
1223 addTemporaryBuildExpression(parseObjectMaxCardinalityNode(parseStackObj));
1224 }
1225
1226 void CXMLOWL2Handler::jumpFunctionParseObjectMinCardinalityNode(CParseStackObject* parseStackObj) {
1227 addTemporaryBuildExpression(parseObjectMinCardinalityNode(parseStackObj));
1228 }
1229
1230 void CXMLOWL2Handler::jumpFunctionParseObjectExactlyCardinalityNode(CParseStackObject* parseStackObj) {
1231 addTemporaryBuildExpression(parseObjectExactlyCardinalityNode(parseStackObj));
1232 }
1233
1234 void CXMLOWL2Handler::jumpFunctionParseObjectSomeValuesFromNode(CParseStackObject* parseStackObj) {
1235 addTemporaryBuildExpression(parseObjectSomeValuesFromNode(parseStackObj));
1236 }
1237
1238 void CXMLOWL2Handler::jumpFunctionParseObjectAllValuesFromNode(CParseStackObject* parseStackObj) {
1239 addTemporaryBuildExpression(parseObjectAllValuesFromNode(parseStackObj));
1240 }
1241
1242 void CXMLOWL2Handler::jumpFunctionParseObjectComplementOfNode(CParseStackObject* parseStackObj) {
1243 addTemporaryBuildExpression(parseObjectComplementOfNode(parseStackObj));
1244 }
1245
1246 void CXMLOWL2Handler::jumpFunctionParseObjectOneOfNode(CParseStackObject* parseStackObj) {
1247 addTemporaryBuildExpression(parseObjectOneOfNode(parseStackObj));
1248 }
1249
1250 void CXMLOWL2Handler::jumpFunctionParseObjectHasValueNode(CParseStackObject* parseStackObj) {
1251 addTemporaryBuildExpression(parseObjectHasValueNode(parseStackObj));
1252 }
1253
1254 void CXMLOWL2Handler::jumpFunctionParseObjectHasSelfNode(CParseStackObject* parseStackObj) {
1255 addTemporaryBuildExpression(parseObjectHasSelfNode(parseStackObj));
1256 }
1257
1258
1259 void CXMLOWL2Handler::jumpFunctionParseClassAssertionNode(CParseStackObject* parseStackObj) {
1260 addTemporaryBuildExpression(parseClassAssertionNode(parseStackObj));
1261 }
1262
1263 void CXMLOWL2Handler::jumpFunctionParseNamedIndividualNode(CParseStackObject* parseStackObj) {
1264 addTemporaryBuildExpression(parseNamedIndividualNode(parseStackObj));
1265 }
1266
1267 void CXMLOWL2Handler::jumpFunctionParseAnonymousIndividualNode(CParseStackObject* parseStackObj) {
1268 addTemporaryBuildExpression(parseAnonymousIndividualNode(parseStackObj));
1269 }
1270
1271 void CXMLOWL2Handler::jumpFunctionParseObjectPropertyAssertionNode(CParseStackObject* parseStackObj) {
1272 addTemporaryBuildExpression(parseObjectPropertyAssertionNode(parseStackObj));
1273 }
1274
1275 void CXMLOWL2Handler::jumpFunctionParseNegativeObjectPropertyAssertionNode(CParseStackObject* parseStackObj) {
1276 addTemporaryBuildExpression(parseNegativeObjectPropertyAssertionNode(parseStackObj));
1277 }
1278
1279 void CXMLOWL2Handler::jumpFunctionParseSameIndividualNode(CParseStackObject* parseStackObj) {
1280 addTemporaryBuildExpression(parseSameIndividualNode(parseStackObj));
1281 }
1282
1283 void CXMLOWL2Handler::jumpFunctionParseDifferentIndividualsNode(CParseStackObject* parseStackObj) {
1284 addTemporaryBuildExpression(parseDifferentIndividualsNode(parseStackObj));
1285 }
1286
1287
1288 void CXMLOWL2Handler::jumpFunctionParseObjectPropertyDomainNode(CParseStackObject* parseStackObj) {
1289 addTemporaryBuildExpression(parseObjectPropertyDomainNode(parseStackObj));
1290 }
1291
1292 void CXMLOWL2Handler::jumpFunctionParseObjectPropertyRangeNode(CParseStackObject* parseStackObj) {
1293 addTemporaryBuildExpression(parseObjectPropertyRangeNode(parseStackObj));
1294 }
1295
1296 void CXMLOWL2Handler::jumpFunctionParseInverseObjectPropertyOfNode(CParseStackObject* parseStackObj) {
1297 addTemporaryBuildExpression(parseInverseObjectPropertyOfNode(parseStackObj));
1298 }
1299
1300 void CXMLOWL2Handler::jumpFunctionParseInverseObjectPropertiesNode(CParseStackObject* parseStackObj) {
1301 addTemporaryBuildExpression(parseInverseObjectPropertiesNode(parseStackObj));
1302 }
1303
1304 void CXMLOWL2Handler::jumpFunctionParseTransetiveObjectPropertyNode(CParseStackObject* parseStackObj) {
1305 addTemporaryBuildExpression(parseTransetiveObjectPropertyNode(parseStackObj));
1306 }
1307
1308 void CXMLOWL2Handler::jumpFunctionParseFunctionalObjectPropertyNode(CParseStackObject* parseStackObj) {
1309 addTemporaryBuildExpression(parseFunctionalObjectPropertyNode(parseStackObj));
1310 }
1311
1312 void CXMLOWL2Handler::jumpFunctionParseSymmetricObjectPropertyNode(CParseStackObject* parseStackObj) {
1313 addTemporaryBuildExpression(parseSymmetricObjectPropertyNode(parseStackObj));
1314 }
1315
1316 void CXMLOWL2Handler::jumpFunctionParseAsymmetricObjectPropertyNode(CParseStackObject* parseStackObj) {
1317 addTemporaryBuildExpression(parseAsymmetricObjectPropertyNode(parseStackObj));
1318 }
1319
1320 void CXMLOWL2Handler::jumpFunctionParseReflexiveObjectPropertyNode(CParseStackObject* parseStackObj) {
1321 addTemporaryBuildExpression(parseReflexiveObjectPropertyNode(parseStackObj));
1322 }
1323
1324 void CXMLOWL2Handler::jumpFunctionParseIrreflexiveObjectPropertyNode(CParseStackObject* parseStackObj) {
1325 addTemporaryBuildExpression(parseIrreflexiveObjectPropertyNode(parseStackObj));
1326 }
1327
1328 void CXMLOWL2Handler::jumpFunctionParseInverseFunctionalObjectPropertyNode(CParseStackObject* parseStackObj) {
1329 addTemporaryBuildExpression(parseInverseFunctionalObjectPropertyNode(parseStackObj));
1330 }
1331
1332 void CXMLOWL2Handler::jumpFunctionParseIgnoredNode(CParseStackObject* parseStackObj) {
1333 }
1334
1335
1336
1337 }; // end namespace Parser
1338
1339 }; // end namespace Konclude