Debian Codegraph @

Source/Parser/CXMLOWL2StreamHandler.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 "CXMLOWL2StreamHandler.h"
22
23
24 namespace Konclude {
25
26 namespace Parser {
27
28
29
30 CXMLOWL2StreamHandler::CXMLOWL2StreamHandler(COntologyBuilder* ontoBuilder)
31 : CLogIdentifier("::Konclude::Parser::OWL2QtXMLStreamOntologyParser",this),recordRouter(0,this) {
32
33 mOntoBuilder = ontoBuilder;
34 mAxiomNumber = 0;
35 mHasCurrentXMLBase = false;
36
37 mIgnoreParsingSubElements = false;
38 mParseIgnoreDepth = 0;
39
40 mCurrentXMLBaseValidDepth = 0;
41 mCurrentXMLNamespaceValidDepth = 0;
42
43 mDataTypeReportErrorCount = 100;
44 mAnnotationReportErrorCount = 100;
45
46 mUnsupportedAnnotationError = false;
47 mUnsupportedImportError = false;
48 mOntologyNodeFound = false;
49 mParseTextElement = false;
50
51 mPunctChar = QChar('.');
52 mDoublePunctChar = QChar(':');
53
54 initializeParseFunctionJumpHash();
55 LOG(INFO,getLogDomain(),logTr("OWL 2 XML Qt stream parser initialized."),this);
56 }
57
58 CXMLOWL2StreamHandler::CXMLOWL2StreamHandler(COntologyBuilder* ontoBuilder, CCommandRecordRouter *commandRecordRouter)
59 : CLogIdentifier("::Konclude::Parser::OWL2QtXMLStreamOntologyParser",this),recordRouter(*commandRecordRouter,this) {
60
61 mOntoBuilder = ontoBuilder;
62 mAxiomNumber = 0;
63 mHasCurrentXMLBase = false;
64
65 mIgnoreParsingSubElements = false;
66 mParseIgnoreDepth = 0;
67
68 mCurrentXMLBaseValidDepth = 0;
69 mCurrentXMLNamespaceValidDepth = 0;
70
71 mDataTypeReportErrorCount = 100;
72 mAnnotationReportErrorCount = 100;
73
74 mUnsupportedAnnotationError = false;
75 mUnsupportedImportError = false;
76 mOntologyNodeFound = false;
77 mParseTextElement = false;
78
79 mPunctChar = QChar('.');
80 mDoublePunctChar = QChar(':');
81
82 initializeParseFunctionJumpHash();
83 LOG(INFO,getLogDomain(),logTr("OWL 2 XML Qt stream parser initialized."),this);
84 }
85
86
87
88
89 bool CXMLOWL2StreamHandler::parseXMLAttributs(const QXmlStreamAttributes& atts) {
90 QStringRef xmlBaseStringRef(atts.value(baseAttributeNamespace, baseAttributeName));
91 if (!xmlBaseStringRef.isEmpty()) {
92 if (mHasCurrentXMLBase) {
93 mXMLBaseStack.push(CStreamXMLBaseStackObject(mCurrentXMLBaseValidDepth,mCurrentXMLBase));
94 }
95 mCurrentXMLBase = xmlBaseStringRef.toString();
96 mCurrentXMLBaseValidDepth = mStack.count();
97 mHasCurrentXMLBase = true;
98 }
99
100
101 QStringRef xmlNamespaceStringRef(atts.value(xmlnsAttributeNamespace, xmlnsAttributeName));
102 if (!xmlNamespaceStringRef.isEmpty()) {
103 QHash<QString,bool> newOWLNamespaceHash;
104 if (!newOWLNamespaceHash.isEmpty()) {
105 CQtHash<CStringRefStringHasher,CStreamParseFunctionData>* newParseHash = new CQtHash<CStringRefStringHasher,CStreamParseFunctionData>(*mCurrentParseFunctionJumpHash);
106
107 for (QHash<QString,bool>::const_iterator it = newOWLNamespaceHash.constBegin(), itEnd = newOWLNamespaceHash.constEnd(); it != itEnd; ++it) {
108 const QString& abbreviationString(it.key());
109 bool abbreviationAdded(it.value());
110 if (abbreviationAdded) {
111 extendParsingHashForNamespace(&mBaseParseFunctionJumpHash,newParseHash,abbreviationString);
112 } else {
113 reduceParsingHashForNamespace(&mBaseParseFunctionJumpHash,newParseHash,abbreviationString);
114 }
115 }
116
117 mXMLNamespaceStack.push(CStreamXMLNamespaceStackObject(mCurrentXMLNamespaceValidDepth,newParseHash));
118 mCurrentParseFunctionJumpHash = newParseHash;
119
120 }
121 mCurrentXMLNamespaceValidDepth = mStack.count();
122 }
123
124 return true;
125 }
126
127
128
129 bool CXMLOWL2StreamHandler::startElement(const QStringRef& namespaceURI, const QStringRef& localName, const QStringRef& qName, const QXmlStreamAttributes& atts) {
130 mParseTextElement = false;
131
132 if (mIgnoreParsingSubElements) {
133 mStack.push(&mDummyFunctionData);
134 } else {
135 parseXMLAttributs(atts);
136
137 const CStreamParseFunctionData& functionData = mCurrentParseFunctionJumpHash->value(qName);
138 if (functionData.mParseDirectFunction) {
139 StreamParseFunctionDirect function = functionData.mParseDirectFunction;
140 (this->*function)(atts);
141 if (!mStack.isEmpty() && !mTmpExpList.isEmpty()) {
142 CStreamParseStackObject* topParsStackObj = mStack.top();
143 topParsStackObj->addBuildExpressions(&mTmpExpList);
144 }
145 mStack.push(&mDummyFunctionData);
146 } else if (functionData.mParseDelayedFunction) {
147 StreamParseFunctionDelayed function = functionData.mParseDelayedFunction;
148 bool requiredCardinality = functionData.mExtraParsingFlags & CStreamParseFunctionData::EPF_CARDINALITY;
149 bool requiredDatatypeIRI = functionData.mExtraParsingFlags & CStreamParseFunctionData::EPF_DATATYPE_IRI;
150 bool requiredFacetIRI = functionData.mExtraParsingFlags & CStreamParseFunctionData::EPF_FACET_IRI;
151 mParseTextElement = functionData.mExtraParsingFlags & CStreamParseFunctionData::EPF_TEXT_ELEMENT;
152 if (requiredCardinality) {
153 cint64 cardinality = 0;
154 bool cardinalityParsed = getCardinality(&cardinality,atts);
155 mStack.push(new CStreamParseStackObject(function,cardinality));
156 } else if (requiredDatatypeIRI) {
157 QString datatypeIRI;
158 bool datatypeParsed = getDatatypeIRI(&datatypeIRI,atts);
159 bool appendixParsed = getLiteralAppendix(&mLastTextAppendix,atts);
160 mParseTextElement = true;
161 mStack.push(new CStreamParseStackObject(function,datatypeIRI));
162 } else if (requiredFacetIRI) {
163 QString facetIRI;
164 bool facetParsed = getFacetIRI(&facetIRI,atts);
165 mStack.push(new CStreamParseStackObject(function,facetIRI));
166 } else {
167 mStack.push(new CStreamParseStackObject(function));
168 }
169 } else {
170 mStack.push(&mDummyFunctionData);
171 }
172 }
173 return true;
174 }
175
176
177 bool CXMLOWL2StreamHandler::endElement(const QStringRef& namespaceURI, const QStringRef& localName, const QStringRef& qName) {
178 if (!mStack.isEmpty()) {
179 CStreamParseStackObject* parseStackObject = mStack.pop();
180 if (mIgnoreParsingSubElements && mStack.count() <= mParseIgnoreDepth) {
181 mIgnoreParsingSubElements = false;
182 mParseIgnoreDepth = 0;
183 } else {
184 if (parseStackObject != &mDummyFunctionData) {
185
186 StreamParseFunctionDelayed function = parseStackObject->mParseFunction;
187 if (function) {
188 (this->*function)(parseStackObject);
189 if (!mStack.isEmpty() && !mTmpExpList.isEmpty()) {
190 CStreamParseStackObject* topParsStackObj = mStack.top();
191 topParsStackObj->addBuildExpressions(&mTmpExpList);
192 }
193 }
194
195 delete parseStackObject;
196 }
197 }
198 }
199 mTmpExpList.clear();
200 mLastReadText.clear();
201 mLastTextAppendix.clear();
202
203 if (mHasCurrentXMLBase) {
204 if (mStack.count() <= mCurrentXMLBaseValidDepth) {
205 if (mXMLBaseStack.isEmpty()) {
206 mHasCurrentXMLBase = false;
207 } else {
208 CStreamXMLBaseStackObject prevXMLBaseObject = mXMLBaseStack.pop();
209 mCurrentXMLBase = prevXMLBaseObject.mXMLBaseString;
210 mCurrentXMLBaseValidDepth = prevXMLBaseObject.mStackValidDepth;
211 }
212 }
213 }
214
215 if (mStack.count() <= mCurrentXMLNamespaceValidDepth) {
216 if (mXMLNamespaceStack.isEmpty()) {
217 mCurrentParseFunctionJumpHash = &mBaseParseFunctionJumpHash;
218 } else {
219 CStreamXMLNamespaceStackObject prevXMLNSObject = mXMLNamespaceStack.pop();
220 mCurrentParseFunctionJumpHash = prevXMLNSObject.mParseHash;
221 mCurrentXMLNamespaceValidDepth = prevXMLNSObject.mStackValidDepth;
222 }
223 }
224
225 return true;
226 }
227
228
229 bool CXMLOWL2StreamHandler::readText(const QStringRef& text) {
230 if (mParseTextElement) {
231 mLastReadText = text.toString();
232 }
233 return true;
234 }
235
236
237 bool CXMLOWL2StreamHandler::startDocument() {
238 mStack.push(&mDummyFunctionData);
239 return true;
240 }
241
242 bool CXMLOWL2StreamHandler::endDocument() {
243 if (mStack.count() > 0) {
244 CStreamParseStackObject* parseStackObject = mStack.pop();
245 parseTellOntologyAxiomNode(parseStackObject);
246 delete parseStackObject;
247 }
248 return true;
249 }
250
251
252
253
254
255
256 void CXMLOWL2StreamHandler::parseTellOntologyAxiomNode(CStreamParseStackObject* parseStackObj) {
257 if (mOntoBuilder && parseStackObj->hasExpressions()) {
258
259 QList<CBuildExpression*>* expList = parseStackObj->getExpressions();
260 for (QList<CBuildExpression*>::const_iterator it = expList->constBegin(), itEnd = expList->constEnd(); it != itEnd; ++it) {
261 CAxiomExpression* axiomExpression = dynamic_cast<CAxiomExpression*>(*it);
262 if (axiomExpression) {
263 mOntoBuilder->tellOntologyAxiom(axiomExpression);
264 }
265 }
266
267 }
268 }
269
270 void CXMLOWL2StreamHandler::parseRetractOntologyAxiomNode(CStreamParseStackObject* parseStackObj) {
271 if (mOntoBuilder && parseStackObj->hasExpressions()) {
272
273 QList<CBuildExpression*>* expList = parseStackObj->getExpressions();
274 for (QList<CBuildExpression*>::const_iterator it = expList->constBegin(), itEnd = expList->constEnd(); it != itEnd; ++it) {
275 CAxiomExpression* axiomExpression = dynamic_cast<CAxiomExpression*>(*it);
276 if (axiomExpression) {
277 mOntoBuilder->retractOntologyAxiom(axiomExpression);
278 }
279 }
280
281 }
282 }
283
284
285 void CXMLOWL2StreamHandler::parsePrefixNode(const QXmlStreamAttributes& attributes) {
286 QStringRef abbName = attributes.value(mNameString);
287 QStringRef totalIRIName = attributes.value(mIRIString);
288
289 if (abbName.isEmpty()) {
290 abbName = attributes.value(mOWLPrefixNameString);
291 }
292 if (totalIRIName.isEmpty()) {
293 totalIRIName = attributes.value(mOWLPrefixIRIString);
294 }
295
296 if (!totalIRIName.isEmpty()) {
297 mOntoBuilder->addNameAbbreviation(totalIRIName.toString(),abbName.toString());
298 }
299 }
300
301
302 bool CXMLOWL2StreamHandler::startsWithScheme(const QStringRef& uriString) {
303 for (int i = 0; i < uriString.count()-1; ++i) {
304 const QChar& c = uriString.at(i);
305 if (!c.isLetterOrNumber() && c != mPunctChar) {
306 if (c == mDoublePunctChar) {
307 return i != 0;
308 }
309 return false;
310 }
311 }
312 return false;
313 }
314
315
316 CStringRefStringHasher CXMLOWL2StreamHandler::getEntityName(const QXmlStreamAttributes& attributes) {
317 CStringRefStringHasher entityName;
318
319 bool abbreviated = false;
320
321 QStringRef attrNameString;
322 attrNameString = attributes.value(mIRIString);
323 if (attrNameString.isEmpty()) {
324 attrNameString = attributes.value(mOWLPrefixIRIString);
325 }
326 if (attrNameString.isEmpty()) {
327 attrNameString = attributes.value(mAbbreviatedIRIString);
328 abbreviated = true;
329 }
330 if (attrNameString.isEmpty()) {
331 attrNameString = attributes.value(mOWLPrefixAbbreviatedIRIString);
332 abbreviated = true;
333 }
334 if (attrNameString.isEmpty()) {
335 attrNameString = attributes.value(mURIString);
336 }
337 if (attrNameString.isEmpty()) {
338 attrNameString = attributes.value(mOWLPrefixURIString);
339 }
340 if (attrNameString.isEmpty()) {
341 abbreviated = false;
342 }
343 if (abbreviated) {
344 entityName = CStringRefStringHasher(mOntoBuilder->resolveAbbreviationName(attrNameString));
345 } else {
346 if (mHasCurrentXMLBase) {
347 if (!startsWithScheme(attrNameString)) {
348 entityName = CStringRefStringHasher(mCurrentXMLBase+attrNameString.toString());
349 }
350 }
351 if (entityName.isEmpty()) {
352 entityName = CStringRefStringHasher(attrNameString);
353 }
354 }
355
356 return entityName;
357 }
358
359
360
361 bool CXMLOWL2StreamHandler::getLiteralAppendix(QString* literalAppendix, const QXmlStreamAttributes& attributes) {
362 QStringRef literalAppendixString;
363 literalAppendixString = attributes.value("lang");
364 if (literalAppendixString.isEmpty()) {
365 literalAppendixString = attributes.value("xml:lang");
366 }
367 if (literalAppendix) {
368 *literalAppendix = literalAppendixString.toString();
369 }
370 return !literalAppendixString.isEmpty();
371 }
372
373 bool CXMLOWL2StreamHandler::getDatatypeIRI(QString* datatypeIRI, const QXmlStreamAttributes& attributes) {
374 QStringRef datatypeIRIString;
375 datatypeIRIString = attributes.value(mDatatypeIRIString);
376 if (datatypeIRIString.isEmpty()) {
377 datatypeIRIString = attributes.value(mOWLPrefixDatatypeIRIString);
378 }
379 if (datatypeIRI) {
380 *datatypeIRI = datatypeIRIString.toString();
381 }
382 return !datatypeIRIString.isEmpty();
383 }
384
385 bool CXMLOWL2StreamHandler::getFacetIRI(QString* facetIRI, const QXmlStreamAttributes& attributes) {
386 QStringRef facetIRIString;
387 facetIRIString = attributes.value(mFacetIRIString);
388 if (facetIRIString.isEmpty()) {
389 facetIRIString = attributes.value(mOWLPrefixFacetIRIString);
390 }
391 if (facetIRI) {
392 *facetIRI = facetIRIString.toString();
393 }
394 return !facetIRIString.isEmpty();
395 }
396
397 bool CXMLOWL2StreamHandler::getCardinality(cint64* cardinality, const QXmlStreamAttributes& attributes) {
398 QStringRef cardinalityString;
399 cardinalityString = attributes.value(mCardinalityString);
400 if (cardinalityString.isEmpty()) {
401 cardinalityString = attributes.value(mOWLPrefixCardinalityString);
402 }
403
404 if (!cardinalityString.isEmpty()) {
405 bool succParsed = false;
406 *cardinality = cardinalityString.toString().toLongLong(&succParsed);
407 return succParsed;
408 }
409 return false;
410 }
411
412
413 QStringRef CXMLOWL2StreamHandler::getNodeID(const QXmlStreamAttributes& attributes) {
414 QStringRef nodeIDString;
415 nodeIDString = attributes.value(mNodeIDString);
416 if (nodeIDString.isEmpty()) {
417 nodeIDString = attributes.value(mOWLPrefixNodeIDString);
418 }
419
420 return nodeIDString;
421 }
422
423
424 bool CXMLOWL2StreamHandler::extendParsingHashForNamespace(CQtHash<CStringRefStringHasher,CStreamParseFunctionData>* baseParseFunctionJumpHash, CQtHash<CStringRefStringHasher,CStreamParseFunctionData>* extendParseFunctionJumpHash, const QString& namespaceExtendString) {
425 bool extendHash = false;
426 for (CQtHash<CStringRefStringHasher,CStreamParseFunctionData>::const_iterator it = baseParseFunctionJumpHash->constBegin(), itEnd = baseParseFunctionJumpHash->constEnd(); it != itEnd; ++it) {
427 const CStringRefStringHasher& stringRefStringHasher(it.key());
428 const CStreamParseFunctionData& streamParseFunctionData(it.value());
429 const QString& keyParseString = stringRefStringHasher.getString();
430 QString extendedKeyParseString = namespaceExtendString+keyParseString;
431 extendParseFunctionJumpHash->insert(CStringRefStringHasher(extendedKeyParseString),streamParseFunctionData);
432 extendHash = true;
433 }
434 return extendHash;
435 }
436
437
438 bool CXMLOWL2StreamHandler::reduceParsingHashForNamespace(CQtHash<CStringRefStringHasher,CStreamParseFunctionData>* baseParseFunctionJumpHash, CQtHash<CStringRefStringHasher,CStreamParseFunctionData>* reduceParseFunctionJumpHash, const QString& namespaceReduceString) {
439 bool reducedHash = false;
440 for (CQtHash<CStringRefStringHasher,CStreamParseFunctionData>::const_iterator it = baseParseFunctionJumpHash->constBegin(), itEnd = baseParseFunctionJumpHash->constEnd(); it != itEnd; ++it) {
441 const CStringRefStringHasher& stringRefStringHasher(it.key());
442 const CStreamParseFunctionData& streamParseFunctionData(it.value());
443 const QString& keyParseString = stringRefStringHasher.getString();
444 QString reduceKeyParseString = namespaceReduceString+keyParseString;
445 reduceParseFunctionJumpHash->insert(CStringRefStringHasher(reduceKeyParseString),CStreamParseFunctionData(&CXMLOWL2StreamHandler::jumpFunctionParseIgnoredNode));
446 reducedHash = true;
447 }
448 return reducedHash;
449 }
450
451
452 bool CXMLOWL2StreamHandler::initializeParseFunctionJumpHash() {
453
454 mOWLString = QString("http://www.w3.org/2002/07/owl#");
455 mOWLPrefixString = QString("owl");
456
457 mURIString = QString("URI");
458 mOWLPrefixURIString = mOWLPrefixString+QString(":")+mURIString;
459
460 mIRIString = QString("IRI");
461 mOWLPrefixIRIString = mOWLPrefixString+QString(":")+mIRIString;
462
463 mAbbreviatedIRIString = QString("abbreviatedIRI");
464 mOWLPrefixAbbreviatedIRIString = mOWLPrefixString+QString(":")+mAbbreviatedIRIString;
465
466 mCardinalityString = QString("cardinality");
467 mOWLPrefixCardinalityString = mOWLPrefixString+QString(":")+mCardinalityString;
468
469 mDatatypeIRIString = QString("datatypeIRI");
470 mOWLPrefixDatatypeIRIString = mOWLPrefixString+QString(":")+mDatatypeIRIString;
471
472 mFacetIRIString = QString("facet");
473 mOWLPrefixFacetIRIString = mOWLPrefixString+QString(":")+mFacetIRIString;
474
475 mNodeIDString = QString("nodeID");
476 mOWLPrefixNodeIDString = mOWLPrefixString+QString(":")+mNodeIDString;
477
478 mNameString = QString("name");
479 mOWLPrefixNameString = mOWLPrefixString+QString(":")+mNameString;
480
481
482
483
484 mBaseParseFunctionJumpHash.insert(CStringRefStringHasher("Prefix"),CStreamParseFunctionData(&CXMLOWL2StreamHandler::jumpFunctionParsePrefixNode));
485
486 mBaseParseFunctionJumpHash.insert(CStringRefStringHasher("Class"),CStreamParseFunctionData(&CXMLOWL2StreamHandler::jumpFunctionParseClassNode));
487 mBaseParseFunctionJumpHash.insert(CStringRefStringHasher("OWLClass"),CStreamParseFunctionData(&CXMLOWL2StreamHandler::jumpFunctionParseClassNode));
488 mBaseParseFunctionJumpHash.insert(CStringRefStringHasher("ObjectProperty"),CStreamParseFunctionData(&CXMLOWL2StreamHandler::jumpFunctionParseObjectPropertyNode));
489 mBaseParseFunctionJumpHash.insert(CStringRefStringHasher("IndividualVariable"),CStreamParseFunctionData(&CXMLOWL2StreamHandler::jumpFunctionParseIndividualVariable));
490 mBaseParseFunctionJumpHash.insert(CStringRefStringHasher("Variable"),CStreamParseFunctionData(&CXMLOWL2StreamHandler::jumpFunctionParseIndividualVariable));
491
492 mBaseParseFunctionJumpHash.insert(CStringRefStringHasher("Declaration"),CStreamParseFunctionData(&CXMLOWL2StreamHandler::jumpFunctionParseDeclarationNode));
493
494 mBaseParseFunctionJumpHash.insert(CStringRefStringHasher("SubClassOf"),CStreamParseFunctionData(&CXMLOWL2StreamHandler::jumpFunctionParseSubClassOfNode));
495 mBaseParseFunctionJumpHash.insert(CStringRefStringHasher("EquivalentClasses"),CStreamParseFunctionData(&CXMLOWL2StreamHandler::jumpFunctionParseEquivalentClassesNode));
496 mBaseParseFunctionJumpHash.insert(CStringRefStringHasher("DisjointClasses"),CStreamParseFunctionData(&CXMLOWL2StreamHandler::jumpFunctionParseDisjontClassesNode));
497 mBaseParseFunctionJumpHash.insert(CStringRefStringHasher("DisjointUnion"),CStreamParseFunctionData(&CXMLOWL2StreamHandler::jumpFunctionParseDisjontUnionNode));
498
499 mBaseParseFunctionJumpHash.insert(CStringRefStringHasher("SubObjectPropertyOf"),CStreamParseFunctionData(&CXMLOWL2StreamHandler::jumpFunctionParseSubObjectPropertyOfNode));
500 mBaseParseFunctionJumpHash.insert(CStringRefStringHasher("ObjectPropertyChain"),CStreamParseFunctionData(&CXMLOWL2StreamHandler::jumpFunctionParseObjectPropertyChainNode));
501 mBaseParseFunctionJumpHash.insert(CStringRefStringHasher("EquivalentObjectProperties"),CStreamParseFunctionData(&CXMLOWL2StreamHandler::jumpFunctionParseEquivalentObjectPropertiesNode));
502 mBaseParseFunctionJumpHash.insert(CStringRefStringHasher("DisjointObjectProperties"),CStreamParseFunctionData(&CXMLOWL2StreamHandler::jumpFunctionParseDisjointObjectPropertiesNode));
503
504 mBaseParseFunctionJumpHash.insert(CStringRefStringHasher("ObjectInverseOf"),CStreamParseFunctionData(&CXMLOWL2StreamHandler::jumpFunctionParseInverseObjectPropertyOfNode));
505 mBaseParseFunctionJumpHash.insert(CStringRefStringHasher("InverseObjectProperties"),CStreamParseFunctionData(&CXMLOWL2StreamHandler::jumpFunctionParseInverseObjectPropertiesNode));
506 mBaseParseFunctionJumpHash.insert(CStringRefStringHasher("ObjectPropertyRange"),CStreamParseFunctionData(&CXMLOWL2StreamHandler::jumpFunctionParseObjectPropertyRangeNode));
507 mBaseParseFunctionJumpHash.insert(CStringRefStringHasher("ObjectPropertyDomain"),CStreamParseFunctionData(&CXMLOWL2StreamHandler::jumpFunctionParseObjectPropertyDomainNode));
508 mBaseParseFunctionJumpHash.insert(CStringRefStringHasher("TransitiveObjectProperty"),CStreamParseFunctionData(&CXMLOWL2StreamHandler::jumpFunctionParseTransetiveObjectPropertyNode));
509 mBaseParseFunctionJumpHash.insert(CStringRefStringHasher("FunctionalObjectProperty"),CStreamParseFunctionData(&CXMLOWL2StreamHandler::jumpFunctionParseFunctionalObjectPropertyNode));
510 mBaseParseFunctionJumpHash.insert(CStringRefStringHasher("SymmetricObjectProperty"),CStreamParseFunctionData(&CXMLOWL2StreamHandler::jumpFunctionParseSymmetricObjectPropertyNode));
511 mBaseParseFunctionJumpHash.insert(CStringRefStringHasher("AsymmetricObjectProperty"),CStreamParseFunctionData(&CXMLOWL2StreamHandler::jumpFunctionParseAsymmetricObjectPropertyNode));
512 mBaseParseFunctionJumpHash.insert(CStringRefStringHasher("ReflexiveObjectProperty"),CStreamParseFunctionData(&CXMLOWL2StreamHandler::jumpFunctionParseReflexiveObjectPropertyNode));
513 mBaseParseFunctionJumpHash.insert(CStringRefStringHasher("IrreflexiveObjectProperty"),CStreamParseFunctionData(&CXMLOWL2StreamHandler::jumpFunctionParseIrreflexiveObjectPropertyNode));
514 mBaseParseFunctionJumpHash.insert(CStringRefStringHasher("InverseFunctionalObjectProperty"),CStreamParseFunctionData(&CXMLOWL2StreamHandler::jumpFunctionParseInverseFunctionalObjectPropertyNode));
515
516 mBaseParseFunctionJumpHash.insert(CStringRefStringHasher("ObjectIntersectionOf"),CStreamParseFunctionData(&CXMLOWL2StreamHandler::jumpFunctionParseObjectIntersectionOfNode));
517 mBaseParseFunctionJumpHash.insert(CStringRefStringHasher("ObjectUnionOf"),CStreamParseFunctionData(&CXMLOWL2StreamHandler::jumpFunctionParseObjectUnionOfNode));
518 mBaseParseFunctionJumpHash.insert(CStringRefStringHasher("ObjectMaxCardinality"),CStreamParseFunctionData(&CXMLOWL2StreamHandler::jumpFunctionParseObjectMaxCardinalityNode,CStreamParseFunctionData::EPF_CARDINALITY));
519 mBaseParseFunctionJumpHash.insert(CStringRefStringHasher("ObjectMinCardinality"),CStreamParseFunctionData(&CXMLOWL2StreamHandler::jumpFunctionParseObjectMinCardinalityNode,CStreamParseFunctionData::EPF_CARDINALITY));
520 mBaseParseFunctionJumpHash.insert(CStringRefStringHasher("ObjectExactCardinality"),CStreamParseFunctionData(&CXMLOWL2StreamHandler::jumpFunctionParseObjectExactlyCardinalityNode,CStreamParseFunctionData::EPF_CARDINALITY));
521 mBaseParseFunctionJumpHash.insert(CStringRefStringHasher("ObjectSomeValuesFrom"),CStreamParseFunctionData(&CXMLOWL2StreamHandler::jumpFunctionParseObjectSomeValuesFromNode));
522 mBaseParseFunctionJumpHash.insert(CStringRefStringHasher("ObjectAllValuesFrom"),CStreamParseFunctionData(&CXMLOWL2StreamHandler::jumpFunctionParseObjectAllValuesFromNode));
523 mBaseParseFunctionJumpHash.insert(CStringRefStringHasher("ObjectComplementOf"),CStreamParseFunctionData(&CXMLOWL2StreamHandler::jumpFunctionParseObjectComplementOfNode));
524 mBaseParseFunctionJumpHash.insert(CStringRefStringHasher("ObjectOneOf"),CStreamParseFunctionData(&CXMLOWL2StreamHandler::jumpFunctionParseObjectOneOfNode));
525 mBaseParseFunctionJumpHash.insert(CStringRefStringHasher("ObjectHasValue"),CStreamParseFunctionData(&CXMLOWL2StreamHandler::jumpFunctionParseObjectHasValueNode));
526 mBaseParseFunctionJumpHash.insert(CStringRefStringHasher("ObjectHasSelf"),CStreamParseFunctionData(&CXMLOWL2StreamHandler::jumpFunctionParseObjectHasSelfNode));
527
528 mBaseParseFunctionJumpHash.insert(CStringRefStringHasher("NamedIndividual"),CStreamParseFunctionData(&CXMLOWL2StreamHandler::jumpFunctionParseNamedIndividualNode));
529 mBaseParseFunctionJumpHash.insert(CStringRefStringHasher("AnonymousIndividual"),CStreamParseFunctionData(&CXMLOWL2StreamHandler::jumpFunctionParseAnonymousIndividualNode));
530 mBaseParseFunctionJumpHash.insert(CStringRefStringHasher("ClassAssertion"),CStreamParseFunctionData(&CXMLOWL2StreamHandler::jumpFunctionParseClassAssertionNode));
531 mBaseParseFunctionJumpHash.insert(CStringRefStringHasher("ObjectPropertyAssertion"),CStreamParseFunctionData(&CXMLOWL2StreamHandler::jumpFunctionParseObjectPropertyAssertionNode));
532 mBaseParseFunctionJumpHash.insert(CStringRefStringHasher(mOWLPrefixString+":ObjectPropertyAssertion"),CStreamParseFunctionData(&CXMLOWL2StreamHandler::jumpFunctionParseObjectPropertyAssertionNode));
533 mBaseParseFunctionJumpHash.insert(CStringRefStringHasher("NegativeObjectPropertyAssertion"),CStreamParseFunctionData(&CXMLOWL2StreamHandler::jumpFunctionParseNegativeObjectPropertyAssertionNode));
534 mBaseParseFunctionJumpHash.insert(CStringRefStringHasher(mOWLPrefixString+":NegativeObjectPropertyAssertion"),CStreamParseFunctionData(&CXMLOWL2StreamHandler::jumpFunctionParseNegativeObjectPropertyAssertionNode));
535 mBaseParseFunctionJumpHash.insert(CStringRefStringHasher("SameIndividual"),CStreamParseFunctionData(&CXMLOWL2StreamHandler::jumpFunctionParseSameIndividualNode));
536 mBaseParseFunctionJumpHash.insert(CStringRefStringHasher(mOWLPrefixString+":SameIndividual"),CStreamParseFunctionData(&CXMLOWL2StreamHandler::jumpFunctionParseSameIndividualNode));
537 mBaseParseFunctionJumpHash.insert(CStringRefStringHasher("DifferentIndividuals"),CStreamParseFunctionData(&CXMLOWL2StreamHandler::jumpFunctionParseDifferentIndividualsNode));
538 mBaseParseFunctionJumpHash.insert(CStringRefStringHasher(mOWLPrefixString+":DifferentIndividuals"),CStreamParseFunctionData(&CXMLOWL2StreamHandler::jumpFunctionParseDifferentIndividualsNode));
539
540 mBaseParseFunctionJumpHash.insert(CStringRefStringHasher("#text"),CStreamParseFunctionData(&CXMLOWL2StreamHandler::jumpFunctionParseIgnoredNode));
541 mBaseParseFunctionJumpHash.insert(CStringRefStringHasher("#comment"),CStreamParseFunctionData(&CXMLOWL2StreamHandler::jumpFunctionParseIgnoredNode));
542 mBaseParseFunctionJumpHash.insert(CStringRefStringHasher("ExpectedResult"),CStreamParseFunctionData(&CXMLOWL2StreamHandler::jumpFunctionParseIgnoredNode));
543
544
545 mBaseParseFunctionJumpHash.insert(CStringRefStringHasher("Datatype"),CStreamParseFunctionData(&CXMLOWL2StreamHandler::jumpFunctionParseDatatypeNode));
546 mBaseParseFunctionJumpHash.insert(CStringRefStringHasher("DataSomeValuesFrom"),CStreamParseFunctionData(&CXMLOWL2StreamHandler::jumpFunctionParseDataSomeValuesFromNode));
547 mBaseParseFunctionJumpHash.insert(CStringRefStringHasher("Literal"),CStreamParseFunctionData(&CXMLOWL2StreamHandler::jumpFunctionParseDataLiteralNode,CStreamParseFunctionData::EPF_DATATYPE_IRI | CStreamParseFunctionData::EPF_LITERAL_APPENDIX | CStreamParseFunctionData::EPF_TEXT_ELEMENT));
548 mBaseParseFunctionJumpHash.insert(CStringRefStringHasher("DataProperty"),CStreamParseFunctionData(&CXMLOWL2StreamHandler::jumpFunctionParseDataPropertyNode));
549
550 mBaseParseFunctionJumpHash.insert(CStringRefStringHasher("DataAllValuesFrom"),CStreamParseFunctionData(&CXMLOWL2StreamHandler::jumpFunctionParseDataAllValuesFromNode));
551 mBaseParseFunctionJumpHash.insert(CStringRefStringHasher("DataHasValue"),CStreamParseFunctionData(&CXMLOWL2StreamHandler::jumpFunctionParseDataHasValueNode));
552
553 mBaseParseFunctionJumpHash.insert(CStringRefStringHasher("DataIntersectionOf"),CStreamParseFunctionData(&CXMLOWL2StreamHandler::jumpFunctionParseDataIntersectionOfNode));
554 mBaseParseFunctionJumpHash.insert(CStringRefStringHasher("DataOneOf"),CStreamParseFunctionData(&CXMLOWL2StreamHandler::jumpFunctionParseDataOneOfNode));
555 mBaseParseFunctionJumpHash.insert(CStringRefStringHasher("DataUnionOf"),CStreamParseFunctionData(&CXMLOWL2StreamHandler::jumpFunctionParseDataUnionOfNode));
556 mBaseParseFunctionJumpHash.insert(CStringRefStringHasher("DataComplementOf"),CStreamParseFunctionData(&CXMLOWL2StreamHandler::jumpFunctionParseDataComplementOfNode));
557 mBaseParseFunctionJumpHash.insert(CStringRefStringHasher("DatatypeRestriction"),CStreamParseFunctionData(&CXMLOWL2StreamHandler::jumpFunctionParseDatatypeRestrictionNode));
558 mBaseParseFunctionJumpHash.insert(CStringRefStringHasher("DataMinCardinality"),CStreamParseFunctionData(&CXMLOWL2StreamHandler::jumpFunctionParseDataMinCardinalityNode,CStreamParseFunctionData::EPF_CARDINALITY));
559 mBaseParseFunctionJumpHash.insert(CStringRefStringHasher("DataMaxCardinality"),CStreamParseFunctionData(&CXMLOWL2StreamHandler::jumpFunctionParseDataMaxCardinalityNode,CStreamParseFunctionData::EPF_CARDINALITY));
560 mBaseParseFunctionJumpHash.insert(CStringRefStringHasher("DataExactCardinality"),CStreamParseFunctionData(&CXMLOWL2StreamHandler::jumpFunctionParseDataExactCardinalityNode,CStreamParseFunctionData::EPF_CARDINALITY));
561 mBaseParseFunctionJumpHash.insert(CStringRefStringHasher("SubDataPropertyOf"),CStreamParseFunctionData(&CXMLOWL2StreamHandler::jumpFunctionParseSubDataPropertyOfNode));
562 mBaseParseFunctionJumpHash.insert(CStringRefStringHasher("EquivalentDataProperties"),CStreamParseFunctionData(&CXMLOWL2StreamHandler::jumpFunctionParseEquivalentDataPropertiesNode));
563 mBaseParseFunctionJumpHash.insert(CStringRefStringHasher("DisjointDataProperties"),CStreamParseFunctionData(&CXMLOWL2StreamHandler::jumpFunctionParseDisjointDataPropertiesNode));
564 mBaseParseFunctionJumpHash.insert(CStringRefStringHasher("DataPropertyDomain"),CStreamParseFunctionData(&CXMLOWL2StreamHandler::jumpFunctionParseDataPropertyDomainNode));
565 mBaseParseFunctionJumpHash.insert(CStringRefStringHasher("DataPropertyRange"),CStreamParseFunctionData(&CXMLOWL2StreamHandler::jumpFunctionParseDataPropertyRangeNode));
566 mBaseParseFunctionJumpHash.insert(CStringRefStringHasher("FunctionalDataProperty"),CStreamParseFunctionData(&CXMLOWL2StreamHandler::jumpFunctionParseFunctionalDataPropertyNode));
567 mBaseParseFunctionJumpHash.insert(CStringRefStringHasher("DataPropertyAssertion"),CStreamParseFunctionData(&CXMLOWL2StreamHandler::jumpFunctionParseDataPropertyAssertionNode));
568 mBaseParseFunctionJumpHash.insert(CStringRefStringHasher("NegativeDataPropertyAssertion"),CStreamParseFunctionData(&CXMLOWL2StreamHandler::jumpFunctionParseNegativeDataPropertyAssertionNode));
569 mBaseParseFunctionJumpHash.insert(CStringRefStringHasher("FacetRestriction"),CStreamParseFunctionData(&CXMLOWL2StreamHandler::jumpFunctionParseDataFacetRestrictionNode,CStreamParseFunctionData::EPF_FACET_IRI));
570
571
572 mBaseParseFunctionJumpHash.insert(CStringRefStringHasher("HasKey"),CStreamParseFunctionData(&CXMLOWL2StreamHandler::jumpFunctionUnsupportedDatatypeNode));
573 mBaseParseFunctionJumpHash.insert(CStringRefStringHasher("DatatypeDefinition"),CStreamParseFunctionData(&CXMLOWL2StreamHandler::jumpFunctionUnsupportedDatatypeNode));
574
575
576 mBaseParseFunctionJumpHash.insert(CStringRefStringHasher("Ontology"),CStreamParseFunctionData(&CXMLOWL2StreamHandler::jumpFunctionTellOntologyAxiomNode));
577 mBaseParseFunctionJumpHash.insert(CStringRefStringHasher("Tell"),CStreamParseFunctionData(&CXMLOWL2StreamHandler::jumpFunctionTellOntologyAxiomNode));
578 mBaseParseFunctionJumpHash.insert(CStringRefStringHasher("Whereby"),CStreamParseFunctionData(&CXMLOWL2StreamHandler::jumpFunctionTellOntologyAxiomNode));
579 mBaseParseFunctionJumpHash.insert(CStringRefStringHasher("Retract"),CStreamParseFunctionData(&CXMLOWL2StreamHandler::jumpFunctionRetractOntologyAxiomNode));
580
581
582 mBaseParseFunctionJumpHash.insert(CStringRefStringHasher("DLSafeRule"),CStreamParseFunctionData(&CXMLOWL2StreamHandler::jumpFunctionParseRuleNode));
583
584 mBaseParseFunctionJumpHash.insert(CStringRefStringHasher("Head"),CStreamParseFunctionData(&CXMLOWL2StreamHandler::jumpFunctionParseRuleAtomHeadNode));
585 mBaseParseFunctionJumpHash.insert(CStringRefStringHasher("Body"),CStreamParseFunctionData(&CXMLOWL2StreamHandler::jumpFunctionParseRuleAtomBodyNode));
586 mBaseParseFunctionJumpHash.insert(CStringRefStringHasher("ObjectPropertyAtom"), CStreamParseFunctionData(&CXMLOWL2StreamHandler::jumpFunctionParseRuleObjectPropertyAtomNode));
587 mBaseParseFunctionJumpHash.insert(CStringRefStringHasher("DataPropertyAtom"), CStreamParseFunctionData(&CXMLOWL2StreamHandler::jumpFunctionParseRuleDataPropertyAtomNode));
588 mBaseParseFunctionJumpHash.insert(CStringRefStringHasher("ClassAtom"),CStreamParseFunctionData(&CXMLOWL2StreamHandler::jumpFunctionParseRuleClassAtomNode));
589
590 mBaseParseFunctionJumpHash.insert(CStringRefStringHasher("DifferentIndividualsAtom"),CStreamParseFunctionData(&CXMLOWL2StreamHandler::jumpFunctionParseDifferentIndividualsAtomNode));
591
592
593 mBaseParseFunctionJumpHash.insert(CStringRefStringHasher("Import"),CStreamParseFunctionData(&CXMLOWL2StreamHandler::jumpFunctionParseImportNode,CStreamParseFunctionData::EPF_TEXT_ELEMENT));
594
595 mBaseParseFunctionJumpHash.insert(CStringRefStringHasher("AnnotationProperty"),CStreamParseFunctionData(&CXMLOWL2StreamHandler::jumpFunctionUnsupportedAnnotationNode));
596 mBaseParseFunctionJumpHash.insert(CStringRefStringHasher("AnnotationPropertyRange"),CStreamParseFunctionData(&CXMLOWL2StreamHandler::jumpFunctionUnsupportedAnnotationNode));
597 mBaseParseFunctionJumpHash.insert(CStringRefStringHasher("AnnotationPropertyDomain"),CStreamParseFunctionData(&CXMLOWL2StreamHandler::jumpFunctionUnsupportedAnnotationNode));
598 mBaseParseFunctionJumpHash.insert(CStringRefStringHasher("SubAnnotationPropertyOf"),CStreamParseFunctionData(&CXMLOWL2StreamHandler::jumpFunctionUnsupportedAnnotationNode));
599 mBaseParseFunctionJumpHash.insert(CStringRefStringHasher("AnnotationAssertion"),CStreamParseFunctionData(&CXMLOWL2StreamHandler::jumpFunctionUnsupportedAnnotationNode));
600 mBaseParseFunctionJumpHash.insert(CStringRefStringHasher("Annotation"),CStreamParseFunctionData(&CXMLOWL2StreamHandler::jumpFunctionUnsupportedAnnotationNode));
601
602 mBaseParseFunctionJumpHash.insert(CStringRefStringHasher("RDF"),CStreamParseFunctionData(&CXMLOWL2StreamHandler::jumpFunctionUnsupportedRDFNode));
603
604 mCurrentParseFunctionJumpHash = &mBaseParseFunctionJumpHash;
605 CQtHash<CStringRefStringHasher,CStreamParseFunctionData>* newParseHash = new CQtHash<CStringRefStringHasher,CStreamParseFunctionData>(*mCurrentParseFunctionJumpHash);
606 extendParsingHashForNamespace(&mBaseParseFunctionJumpHash,newParseHash,mOWLPrefix);
607 mCurrentParseFunctionJumpHash = newParseHash;
608
609 mCurrentParseFunctionJumpHash->insert(CStringRefStringHasher("rdf:RDF"),CStreamParseFunctionData(&CXMLOWL2StreamHandler::jumpFunctionUnsupportedRDFNode));
610
611 return true;
612 }
613
614
615 CRuleDifferentIndividualsAtomTermExpression* CXMLOWL2StreamHandler::parseRuleDifferentIndividualsAtomNode(CStreamParseStackObject* parseStackObj) {
616 CRuleDifferentIndividualsAtomTermExpression* ruleDiffIndAtomExp = nullptr;
617 if (parseStackObj->hasExpressions()) {
618 CParsingExpressionSplitter mParsingExpSpl(parseStackObj->getExpressions());
619 if (mParsingExpSpl.proofExpressionComposition(0,0,0,2,0)) {
620 ruleDiffIndAtomExp = new CRuleDifferentIndividualsAtomTermExpression(mParsingExpSpl.getFirstClassVariableTermExpression(),mParsingExpSpl.getSecondClassVariableTermExpression());
621 mRuleExpContainer.append(ruleDiffIndAtomExp);
622 }
623 }
624 return ruleDiffIndAtomExp;
625 }
626
627
628 CRuleAtomTermExpression* CXMLOWL2StreamHandler::parseRuleObjectPropertyAtomNode(CStreamParseStackObject* parseStackObj) {
629 CRuleAtomTermExpression* ruleAtomExp = nullptr;
630 if (parseStackObj->hasExpressions()) {
631 CParsingExpressionSplitter mParsingExpSpl(parseStackObj->getExpressions());
632 if (mParsingExpSpl.proofExpressionComposition(0,1,0,1,0)) {
633 if (mParsingExpSpl.getClassVariableTermExpressionList()->size() >= 2) {
634 ruleAtomExp = new CRulePropertyAtomTermExpression(mParsingExpSpl.getFirstClassVariableTermExpression(), mParsingExpSpl.getSecondClassVariableTermExpression(), mParsingExpSpl.getFirstObjectPropertyTermExpression());
635 } else if (!mParsingExpSpl.getIndividualTermExpressionList()->isEmpty()) {
636 ruleAtomExp = new CRuleClassAtomTermExpression(mOntoBuilder->getObjectHasValue(mParsingExpSpl.getFirstObjectPropertyTermExpression(), mParsingExpSpl.getFirstIndividualTermExpression()), mParsingExpSpl.getFirstClassVariableTermExpression());
637 } else {
638 LOG(ERROR, getLogDomain(), logTr("Parsing of possibly unsupported ObjectPropertyAtom failed."), this);
639 }
640 if (ruleAtomExp) {
641 mRuleExpContainer.append(ruleAtomExp);
642 }
643 }
644 }
645 return ruleAtomExp;
646 }
647
648
649
650 CRuleAtomTermExpression* CXMLOWL2StreamHandler::parseRuleDataPropertyAtomNode(CStreamParseStackObject* parseStackObj) {
651 CRuleClassAtomTermExpression* ruleClassAtomExp = nullptr;
652 if (parseStackObj->hasExpressions()) {
653 CParsingExpressionSplitter mParsingExpSpl(parseStackObj->getExpressions());
654 if (mParsingExpSpl.proofExpressionComposition(0, 0, 0, 1, 0, 1)) {
655 if (!mParsingExpSpl.getDataRangeTermExpressionList()->isEmpty()) {
656 ruleClassAtomExp = new CRuleClassAtomTermExpression(mOntoBuilder->getDataSomeValuesFrom(mParsingExpSpl.getFirstDataPropertyTermExpression(), mParsingExpSpl.getFirstDataRangeTermExpression()), mParsingExpSpl.getFirstClassVariableTermExpression());
657 } else if (!mParsingExpSpl.getDataLiteralTermExpressionList()->isEmpty()) {
658 ruleClassAtomExp = new CRuleClassAtomTermExpression(mOntoBuilder->getDataHasValue(mParsingExpSpl.getFirstDataPropertyTermExpression(), mParsingExpSpl.getFirstDataLiteralTermExpression()), mParsingExpSpl.getFirstClassVariableTermExpression());
659 } else {
660 LOG(ERROR, getLogDomain(), logTr("Parsing of possibly unsupported DataPropertyAtom failed."), this);
661 }
662 if (ruleClassAtomExp) {
663 mRuleExpContainer.append(ruleClassAtomExp);
664 }
665 }
666 }
667 return ruleClassAtomExp;
668 }
669
670 CRuleClassAtomTermExpression* CXMLOWL2StreamHandler::parseRuleClassAtomNode(CStreamParseStackObject* parseStackObj) {
671 CRuleClassAtomTermExpression* ruleClassAtomExp = nullptr;
672 if (parseStackObj->hasExpressions()) {
673 CParsingExpressionSplitter mParsingExpSpl(parseStackObj->getExpressions());
674 if (mParsingExpSpl.proofExpressionComposition(2,0,0,1,1)) {
675 ruleClassAtomExp = new CRuleClassAtomTermExpression(mParsingExpSpl.getFirstClassTermExpression(),mParsingExpSpl.getFirstClassVariableTermExpression());
676 mRuleExpContainer.append(ruleClassAtomExp);
677 }
678 }
679 return ruleClassAtomExp;
680 }
681
682
683 CRuleAtomListBodyExpression* CXMLOWL2StreamHandler::parseRuleAtomBodyNode(CStreamParseStackObject* parseStackObj) {
684 CRuleAtomListBodyExpression* ruleAtomBodyExp = nullptr;
685 if (parseStackObj->hasExpressions()) {
686 QList<CBuildExpression*>* expList = &parseStackObj->mExpList;
687 QList<CRuleAtomTermExpression*> atomExpList;
688 for (QList<CBuildExpression*>::const_iterator it = expList->constBegin(), itEnd = expList->constEnd(); it != itEnd; ++it) {
689 CRuleAtomTermExpression* ruleAtTeExp = dynamic_cast<CRuleAtomTermExpression*>(*it);
690 if (ruleAtTeExp) {
691 atomExpList.append(ruleAtTeExp);
692 }
693 }
694 if (!atomExpList.isEmpty()) {
695 ruleAtomBodyExp = new CRuleAtomListBodyExpression(atomExpList);
696 mRuleExpContainer.append(ruleAtomBodyExp);
697 }
698 }
699 return ruleAtomBodyExp;
700 }
701
702
703 CRuleAtomListHeadExpression* CXMLOWL2StreamHandler::parseRuleAtomHeadNode(CStreamParseStackObject* parseStackObj) {
704 CRuleAtomListHeadExpression* ruleAtomHeadExp = nullptr;
705 if (parseStackObj->hasExpressions()) {
706 QList<CBuildExpression*>* expList = &parseStackObj->mExpList;
707 QList<CRuleAtomTermExpression*> atomExpList;
708 for (QList<CBuildExpression*>::const_iterator it = expList->constBegin(), itEnd = expList->constEnd(); it != itEnd; ++it) {
709 CRuleAtomTermExpression* ruleAtTeExp = dynamic_cast<CRuleAtomTermExpression*>(*it);
710 if (ruleAtTeExp) {
711 atomExpList.append(ruleAtTeExp);
712 }
713 }
714 if (!atomExpList.isEmpty()) {
715 ruleAtomHeadExp = new CRuleAtomListHeadExpression(atomExpList);
716 mRuleExpContainer.append(ruleAtomHeadExp);
717 }
718 }
719 return ruleAtomHeadExp;
720 }
721
722
723
724 QHash<QString,CParseRuleAtom*> CXMLOWL2StreamHandler::createVariableAtomHash(const QList<CParseRuleAtom*>& atomList) {
725 QHash<QString,CParseRuleAtom*> variableAtomHash;
726 foreach (CParseRuleAtom* atom, atomList) {
727 if (!atom->mVariableName1.isEmpty()) {
728 variableAtomHash.insertMulti(atom->mVariableName1,atom);
729 }
730 if (!atom->mVariableName2.isEmpty()) {
731 variableAtomHash.insertMulti(atom->mVariableName2,atom);
732 }
733 }
734 return variableAtomHash;
735 }
736
737
738
739 QMap<cint64,QString> CXMLOWL2StreamHandler::createVariableCountMap(const QList<CParseRuleAtom*>& atomList) {
740 QHash<QString,cint64> variableCountHash;
741 foreach (CParseRuleAtom* atom, atomList) {
742 if (!atom->mVariableName1.isEmpty()) {
743 cint64 prevCount = variableCountHash.value(atom->mVariableName1,0);
744 variableCountHash.insert(atom->mVariableName1,prevCount+1);
745 }
746 if (!atom->mVariableName2.isEmpty()) {
747 cint64 prevCount = variableCountHash.value(atom->mVariableName2,0);
748 variableCountHash.insert(atom->mVariableName2,prevCount+1);
749 }
750 }
751 QMap<cint64,QString> countVariableMap;
752 for (QHash<QString,cint64>::const_iterator it = variableCountHash.constBegin(), itEnd = variableCountHash.constEnd(); it != itEnd; ++it) {
753 const QString& variableName = it.key();
754 cint64 variableAtomCount = it.value();
755 countVariableMap.insertMulti(variableAtomCount,variableName);
756 }
757 return countVariableMap;
758 }
759
760
761
762 QList<CParseRuleAtom*> CXMLOWL2StreamHandler::parseRuleAtomNodes(CStreamParseStackObject* parseStackObj, const CQtList<CBuildExpression*>& buildExpList, bool parseHeadAtoms) {
763 QList<CParseRuleAtom*> atomList;
764 for (CQtList<CBuildExpression*>::const_iterator it1 = buildExpList.constBegin(), it1End = buildExpList.constEnd(); it1 != it1End; ++it1) {
765 CRuleAtomListExpression* buildListExp = nullptr;
766 CRuleAtomListBodyExpression* buildBodyListExp = dynamic_cast<CRuleAtomListBodyExpression*>(*it1);
767 CRuleAtomListHeadExpression* buildHeadListExp = dynamic_cast<CRuleAtomListHeadExpression*>(*it1);
768 if (parseHeadAtoms) {
769 buildListExp = buildHeadListExp;
770 }
771 if (!parseHeadAtoms) {
772 buildListExp = buildBodyListExp;
773 }
774 if (buildListExp) {
775 CEXPRESSIONLIST<CRuleAtomTermExpression*>* ruleAtomExpList = buildListExp->getRuleAtomTermExpressionList();
776 for (CEXPRESSIONLIST<CRuleAtomTermExpression*>::const_iterator it2 = ruleAtomExpList->constBegin(), it2End = ruleAtomExpList->constEnd(); it2 != it2End; ++it2) {
777 CRuleAtomTermExpression* ruleAtomExp = *it2;
778
779 CParseRuleAtom* ruleAtom = nullptr;
780
781 if (ruleAtomExp->getType() == CBuildExpression::BETRULEPROPERTYATOM) {
782 CRulePropertyAtomTermExpression* rulePropertyAtomExp = (CRulePropertyAtomTermExpression*)ruleAtomExp;
783 CEXPRESSIONLIST<CObjectIndividualVariableExpression*>* varList = rulePropertyAtomExp->getClassVariableTermExpressionList();
784 ruleAtom = new CParseRuleAtom(CParseRuleAtom::PROPERTYATOM);
785 ruleAtom->mVariableName1 = varList->first()->getName();
786 ruleAtom->mVariableName2 = varList->last()->getName();
787 ruleAtom->mAtomExpression = rulePropertyAtomExp->getObjectPropertyTermExpression();
788 atomList.append(ruleAtom);
789 } else if (ruleAtomExp->getType() == CBuildExpression::BETRULECLASSATOM) {
790 CRuleClassAtomTermExpression* ruleClassAtomExp = (CRuleClassAtomTermExpression*)ruleAtomExp;
791 ruleAtom = new CParseRuleAtom(CParseRuleAtom::CLASSATOM);
792 ruleAtom->mVariableName1 = ruleClassAtomExp->getClassVariableExpression()->getName();
793 ruleAtom->mAtomExpression = ruleClassAtomExp->getClassTermExpression();
794 atomList.append(ruleAtom);
795 } else if (ruleAtomExp->getType() == CBuildExpression::BETRULEDIFFERENTINDIVIDUALSATOM) {
796 CRuleDifferentIndividualsAtomTermExpression* diffIndAtomExp = (CRuleDifferentIndividualsAtomTermExpression*)ruleAtomExp;
797 ruleAtom = new CParseRuleAtom(CParseRuleAtom::DIFFERENTINDIVIDUALSATOM);
798 CEXPRESSIONLIST<CObjectIndividualVariableExpression*>* varList = diffIndAtomExp->getClassVariableTermExpressionList();
799 ruleAtom->mVariableName1 = varList->first()->getName();
800 ruleAtom->mVariableName2 = varList->last()->getName();
801 atomList.append(ruleAtom);
802 }
803
804 }
805 }
806
807 }
808
809 return atomList;
810 }
811
812
813
814
815 void CXMLOWL2StreamHandler::parseRuleNode(CStreamParseStackObject* parseStackObj) {
816 if (parseStackObj->hasExpressions()) {
817 QList<CBuildExpression*> expressionList;
818
819 QHash<QString,CParseRuleAtom*> bodyVariableAtomHash;
820 QHash<QString,CParseRuleAtom*> headVariableAtomHash;
821
822 CQtList<CBuildExpression*> buildExpList(*parseStackObj->getExpressions());
823
824 QList<CParseRuleAtom*> bodyVariableAtomList = parseRuleAtomNodes(parseStackObj,buildExpList,false);
825 QList<CParseRuleAtom*> headVariableAtomList = parseRuleAtomNodes(parseStackObj,buildExpList,true);
826
827 bodyVariableAtomHash = createVariableAtomHash(bodyVariableAtomList);
828 headVariableAtomHash = createVariableAtomHash(headVariableAtomList);
829
830 QMap<cint64,QString> headCountVariableMap = createVariableCountMap(headVariableAtomList);
831
832
833 QSet<CParseRuleAtom*> headProcessedAtomSet;
834
835 QList<QString> reversHeadCountVariableList;
836 for (QMap<cint64,QString>::const_iterator it = headCountVariableMap.constBegin(), itEnd = headCountVariableMap.constEnd(); it != itEnd; ++it) {
837 const QString& varString = it.value();
838 reversHeadCountVariableList.prepend(varString);
839 }
840
841 for (QList<QString>::const_iterator it = reversHeadCountVariableList.constBegin(), itEnd = reversHeadCountVariableList.constEnd(); it != itEnd; ++it) {
842 const QString& varString = *it;
843
844 QSet<CParseRuleAtom*> processedBodyAtoms;
845 QList<CParseRuleAtom*> headAtomList = headVariableAtomHash.values(varString);
846 QList<CBuildExpression*> headExpressionList;
847 foreach (CParseRuleAtom* headAtom, headAtomList) {
848 if (!headProcessedAtomSet.contains(headAtom)) {
849 headProcessedAtomSet.insert(headAtom);
850
851 if (headAtom->mAtomType == CParseRuleAtom::PROPERTYATOM) {
852 bool inversed = false;
853 QString otherVarString = headAtom->getOtherVariable(varString,inversed);
854 CBuildExpression* otherVarExp = mOntoBuilder->getNominalIndividualVariable(otherVarString,mAxiomNumber);
855 CBuildExpression* someExp = mOntoBuilder->getObjectSomeValuesFrom(getNeighbourAtomObjectPropertyExpression(headAtom,inversed),otherVarExp);
856 headExpressionList.append(someExp);
857 } else if (headAtom->mAtomType == CParseRuleAtom::CLASSATOM) {
858 headExpressionList.append(headAtom->mAtomExpression);
859 } else if (headAtom->mAtomType == CParseRuleAtom::DIFFERENTINDIVIDUALSATOM) {
860 bool inversed = false;
861 QString otherVarString = headAtom->getOtherVariable(varString,inversed);
862 CBuildExpression* otherVarExp = mOntoBuilder->getNominalIndividualVariable(otherVarString,mAxiomNumber);
863 CBuildExpression* complExp = mOntoBuilder->getObjectComplementOf(otherVarExp);
864 headExpressionList.append(complExp);
865 }
866
867 }
868 }
869
870 if (!headExpressionList.isEmpty()) {
871 CBuildExpression* headExp = nullptr;
872 if (headExpressionList.count() >= 2) {
873 headExp = mOntoBuilder->getObjectIntersectionOf(headExpressionList);
874 } else {
875 headExp = headExpressionList.first();
876 }
877
878 CBuildExpression* bodyExp = createBodyExpresions(varString,bodyVariableAtomHash,headVariableAtomHash);
879 CBuildExpression* axiomExp = mOntoBuilder->getSubClassOf(bodyExp,headExp);
880 expressionList.append(axiomExp);
881 }
882
883 ++mAxiomNumber;
884 }
885
886 addTemporaryBuildExpressions(&expressionList);
887 }
888 }
889
890
891 CBuildExpression* CXMLOWL2StreamHandler::createBodyExpresions(const QString& varString, QHash<QString,CParseRuleAtom*>& bodyVariableAtomHash, QHash<QString,CParseRuleAtom*>& headVariableAtomHash) {
892 QSet<QString> processedVarSet;
893 QSet<CParseRuleAtom*> processedAtomSet;
894 QList<CBuildExpression*> expList;
895 CBuildExpression* mainExp = createBodyExpresions(varString,true,bodyVariableAtomHash,processedVarSet,processedAtomSet,headVariableAtomHash);
896 expList.append(mainExp);
897
898 for (QHash<QString,CParseRuleAtom*>::const_iterator it = bodyVariableAtomHash.constBegin(), itEnd = bodyVariableAtomHash.constEnd(); it != itEnd; ++it) {
899 QString nextVarString = it.key();
900 if (!processedVarSet.contains(nextVarString)) {
901 CBuildExpression* topPropExp = mOntoBuilder->getTopObjectProberty();
902 CBuildExpression* succExp = createBodyExpresions(nextVarString,true,bodyVariableAtomHash,processedVarSet,processedAtomSet,headVariableAtomHash);
903 CBuildExpression* someExp = mOntoBuilder->getObjectSomeValuesFrom(topPropExp,succExp);
904 expList.append(someExp);
905 }
906 }
907
908 if (expList.count() >= 2) {
909 return mOntoBuilder->getObjectIntersectionOf(expList);
910 }
911 return expList.first();
912 }
913
914 CBuildExpression* CXMLOWL2StreamHandler::getNeighbourAtomObjectPropertyExpression(CParseRuleAtom* ruleAtom, bool inversed) {
915 if (!inversed) {
916 return ruleAtom->mAtomExpression;
917 } else {
918 return mOntoBuilder->getInverseObjectPropertyOf(ruleAtom->mAtomExpression);
919 }
920 }
921
922
923
924 bool CXMLOWL2StreamHandler::hasBackExpressionLinks(const QString& varString, CParseRuleAtom* notRuleAtom, QHash<QString,CParseRuleAtom*>& bodyVariableAtomHash, QSet<QString>& processedVarSet,
925 QSet<CParseRuleAtom*>& processedAtomSet, QHash<QString,CParseRuleAtom*>& headVariableAtomHash) {
926
927 QSet<QString> backTestProcessedVarSet;
928 QSet<CParseRuleAtom*> backTestProcessedAtomSet;
929
930 return hasBackExpressionLinks(varString,notRuleAtom,bodyVariableAtomHash,processedVarSet,processedAtomSet,headVariableAtomHash,backTestProcessedVarSet,backTestProcessedAtomSet);
931 }
932
933
934
935 bool CXMLOWL2StreamHandler::hasBackExpressionLinks(const QString& varString, CParseRuleAtom* notRuleAtom, QHash<QString,CParseRuleAtom*>& bodyVariableAtomHash, QSet<QString>& processedVarSet,
936 QSet<CParseRuleAtom*>& processedAtomSet, QHash<QString,CParseRuleAtom*>& headVariableAtomHash, QSet<QString>& backTestProcessedVarSet, QSet<CParseRuleAtom*>& backTestProcessedAtomSet) {
937
938 if (processedVarSet.contains(varString)) {
939 return false;
940 }
941 if (!backTestProcessedVarSet.contains(varString)) {
942 backTestProcessedVarSet.insert(varString);
943
944 QList<CParseRuleAtom*> atomList = bodyVariableAtomHash.values(varString);
945 foreach (CParseRuleAtom* ruleAtom, atomList) {
946 if (ruleAtom->mAtomType == CParseRuleAtom::PROPERTYATOM) {
947 if (ruleAtom != notRuleAtom) {
948 if (processedAtomSet.contains(ruleAtom)) {
949 return true;
950 }
951 if (!backTestProcessedAtomSet.contains(ruleAtom)) {
952 backTestProcessedAtomSet.insert(ruleAtom);
953 bool inversed = false;
954 QString otherVarString = ruleAtom->getOtherVariable(varString,inversed);
955 if (hasBackExpressionLinks(otherVarString,ruleAtom,bodyVariableAtomHash,processedVarSet,processedAtomSet,headVariableAtomHash,backTestProcessedVarSet,backTestProcessedAtomSet)) {
956 return true;
957 }
958 }
959 }
960 }
961 }
962 }
963 return false;
964 }
965
966
967 CBuildExpression* CXMLOWL2StreamHandler::createBodyExpresions(const QString& varString, bool direct, QHash<QString,CParseRuleAtom*>& bodyVariableAtomHash, QSet<QString>& processedVarSet, QSet<CParseRuleAtom*>& processedAtomSet, QHash<QString,CParseRuleAtom*>& headVariableAtomHash) {
968 QList<CBuildExpression*> expList;
969 expList.append(mOntoBuilder->getNominalIndividualVariable(varString,mAxiomNumber));
970
971 if (!processedVarSet.contains(varString)) {
972 processedVarSet.insert(varString);
973
974 QList<CParseRuleAtom*> atomList = bodyVariableAtomHash.values(varString);
975 QList<CParseRuleAtom*> processList;
976 foreach (CParseRuleAtom* ruleAtom, atomList) {
977 if (ruleAtom->mAtomType == CParseRuleAtom::PROPERTYATOM) {
978 if (!processedAtomSet.contains(ruleAtom)) {
979
980 bool inversed = false;
981 QString otherVarString = ruleAtom->getOtherVariable(varString,inversed);
982
983 if (direct || !headVariableAtomHash.contains(varString) || !hasBackExpressionLinks(otherVarString,ruleAtom,bodyVariableAtomHash,processedVarSet,processedAtomSet,headVariableAtomHash)) {
984
985 processedAtomSet.insert(ruleAtom);
986 processList.append(ruleAtom);
987 }
988 }
989 } else if (ruleAtom->mAtomType == CParseRuleAtom::CLASSATOM) {
990 processList.append(ruleAtom);
991 } else if (ruleAtom->mAtomType == CParseRuleAtom::DIFFERENTINDIVIDUALSATOM) {
992 if (!processedAtomSet.contains(ruleAtom)) {
993 processedAtomSet.insert(ruleAtom);
994 processList.append(ruleAtom);
995 }
996 }
997 }
998 foreach (CParseRuleAtom* ruleAtom, processList) {
999
1000 if (ruleAtom->mAtomType == CParseRuleAtom::PROPERTYATOM) {
1001 bool inversed = false;
1002 QString otherVarString = ruleAtom->getOtherVariable(varString,inversed);
1003 CBuildExpression* succExp = createBodyExpresions(otherVarString,false,bodyVariableAtomHash,processedVarSet,processedAtomSet,headVariableAtomHash);
1004 CBuildExpression* someExp = mOntoBuilder->getObjectSomeValuesFrom(getNeighbourAtomObjectPropertyExpression(ruleAtom,inversed),succExp);
1005 expList.append(someExp);
1006 } else if (ruleAtom->mAtomType == CParseRuleAtom::CLASSATOM) {
1007 expList.append(ruleAtom->mAtomExpression);
1008 } else if (ruleAtom->mAtomType == CParseRuleAtom::DIFFERENTINDIVIDUALSATOM) {
1009 bool inversed = false;
1010 QString otherVarString = ruleAtom->getOtherVariable(varString,inversed);
1011 CBuildExpression* otherVarExp = mOntoBuilder->getNominalIndividualVariable(otherVarString,mAxiomNumber);
1012 CBuildExpression* complExp = mOntoBuilder->getObjectComplementOf(otherVarExp);
1013 expList.append(complExp);
1014 }
1015
1016 }
1017 }
1018 if (expList.count() >= 2) {
1019 return mOntoBuilder->getObjectIntersectionOf(expList);
1020 }
1021 return expList.first();
1022 }
1023
1024
1025
1026
1027 CDeclarationAxiomExpression* CXMLOWL2StreamHandler::parseDeclarationNode(CStreamParseStackObject* parseStackObj) {
1028 CDeclarationAxiomExpression* declarationExpression = nullptr;
1029 if (parseStackObj->hasExpressions()) {
1030 declarationExpression = mOntoBuilder->getDeclaration(*parseStackObj->getExpressions());
1031 ++mAxiomNumber;
1032 }
1033 return declarationExpression;
1034 }
1035
1036
1037 CObjectPropertyExpression *CXMLOWL2StreamHandler::parseObjectPropertyNode(const QXmlStreamAttributes& attributes) {
1038 const CStringRefStringHasher& probName = getEntityName(attributes);
1039 CObjectPropertyExpression *objectExpression = 0;
1040 if (!probName.isEmpty()) {
1041 objectExpression = mOntoBuilder->getObjectProberty(probName.toStringRefernce());
1042 }
1043 return objectExpression;
1044 }
1045
1046
1047 CClassExpression *CXMLOWL2StreamHandler::parseClassNode(const QXmlStreamAttributes& attributes) {
1048 const CStringRefStringHasher& className = getEntityName(attributes);
1049 CClassExpression *classExpression = 0;
1050 if (!className.isEmpty()) {
1051 classExpression = mOntoBuilder->getClass(className.toStringRefernce());
1052 }
1053 return classExpression;
1054 }
1055
1056
1057 CObjectIndividualVariableExpression* CXMLOWL2StreamHandler::parseIndividualVariableNode(const QXmlStreamAttributes& attributes) {
1058 const CStringRefStringHasher& indiVarName = getEntityName(attributes);
1059 CObjectIndividualVariableExpression *indiVarExpression = 0;
1060 if (!indiVarName.isEmpty()) {
1061 indiVarExpression = mOntoBuilder->getNominalIndividualVariable(indiVarName.toStringRefernce(),mAxiomNumber);
1062 }
1063 return indiVarExpression;
1064 }
1065
1066
1067
1068
1069 CEquivalentClassesExpression *CXMLOWL2StreamHandler::parseEquivalentClassesNode(CStreamParseStackObject* parseStackObj) {
1070 CEquivalentClassesExpression *ecExp = 0;
1071 if (parseStackObj->hasExpressions()) {
1072 ecExp = mOntoBuilder->getEquivalentClasses(*parseStackObj->getExpressions());
1073 ++mAxiomNumber;
1074 }
1075 return ecExp;
1076 }
1077
1078
1079 CSubClassOfExpression *CXMLOWL2StreamHandler::parseSubClassOfNode(CStreamParseStackObject* parseStackObj) {
1080 CSubClassOfExpression *scoExp = 0;
1081 if (parseStackObj->hasExpressions()) {
1082 scoExp = mOntoBuilder->getSubClassOf(*parseStackObj->getExpressions());
1083 ++mAxiomNumber;
1084 }
1085 return scoExp;
1086 }
1087
1088
1089 CObjectPropertyDomainExpression *CXMLOWL2StreamHandler::parseObjectPropertyDomainNode(CStreamParseStackObject* parseStackObj) {
1090 CObjectPropertyDomainExpression *obPrDoExp = 0;
1091 if (parseStackObj->hasExpressions()) {
1092 obPrDoExp = mOntoBuilder->getObjectPropertyDomainExpression(*parseStackObj->getExpressions());
1093 ++mAxiomNumber;
1094 }
1095 return obPrDoExp;
1096 }
1097
1098 CObjectPropertyRangeExpression *CXMLOWL2StreamHandler::parseObjectPropertyRangeNode(CStreamParseStackObject* parseStackObj) {
1099 CObjectPropertyRangeExpression *obPrRaExp = 0;
1100 if (parseStackObj->hasExpressions()) {
1101 obPrRaExp = mOntoBuilder->getObjectPropertyRangeExpression(*parseStackObj->getExpressions());
1102 ++mAxiomNumber;
1103 }
1104 return obPrRaExp;
1105 }
1106
1107
1108 CSubObjectPropertyOfExpression *CXMLOWL2StreamHandler::parseSubObjectPropertyOfNode(CStreamParseStackObject* parseStackObj) {
1109 CSubObjectPropertyOfExpression *sopoExp = 0;
1110 if (parseStackObj->hasExpressions()) {
1111 sopoExp = mOntoBuilder->getSubObjectPropertyOf(*parseStackObj->getExpressions());
1112 ++mAxiomNumber;
1113 }
1114 return sopoExp;
1115 }
1116
1117 CObjectPropertyChainExpression *CXMLOWL2StreamHandler::parseObjectPropertyChainNode(CStreamParseStackObject* parseStackObj) {
1118 CObjectPropertyChainExpression *sopoExp = 0;
1119 if (parseStackObj->hasExpressions()) {
1120 sopoExp = mOntoBuilder->getObjectPropertyChain(*parseStackObj->getExpressions());
1121 }
1122 return sopoExp;
1123 }
1124
1125 CEquivalentObjectPropertiesExpression *CXMLOWL2StreamHandler::parseEquivalentObjectPropertiesNode(CStreamParseStackObject* parseStackObj) {
1126 CEquivalentObjectPropertiesExpression *sopoExp = 0;
1127 if (parseStackObj->hasExpressions()) {
1128 sopoExp = mOntoBuilder->getEquivalentObjectProperties(*parseStackObj->getExpressions());
1129 ++mAxiomNumber;
1130 }
1131 return sopoExp;
1132 }
1133
1134 CDisjointObjectPropertiesExpression *CXMLOWL2StreamHandler::parseDisjointObjectPropertiesNode(CStreamParseStackObject* parseStackObj) {
1135 CDisjointObjectPropertiesExpression *sopoExp = 0;
1136 if (parseStackObj->hasExpressions()) {
1137 sopoExp = mOntoBuilder->getDisjointObjectProperties(*parseStackObj->getExpressions());
1138 ++mAxiomNumber;
1139 }
1140 return sopoExp;
1141 }
1142
1143 CInverseObjectPropertyOfExpression *CXMLOWL2StreamHandler::parseInverseObjectPropertyOfNode(CStreamParseStackObject* parseStackObj) {
1144 CInverseObjectPropertyOfExpression *iopoExp = 0;
1145 if (parseStackObj->hasExpressions()) {
1146 iopoExp = mOntoBuilder->getInverseObjectPropertyOf(*parseStackObj->getExpressions());
1147 }
1148 return iopoExp;
1149 }
1150
1151 CInverseObjectPropertiesExpression *CXMLOWL2StreamHandler::parseInverseObjectPropertiesNode(CStreamParseStackObject* parseStackObj) {
1152 CInverseObjectPropertiesExpression *iopoExp = 0;
1153 if (parseStackObj->hasExpressions()) {
1154 iopoExp = mOntoBuilder->getInverseObjectProperties(*parseStackObj->getExpressions());
1155 ++mAxiomNumber;
1156 }
1157 return iopoExp;
1158 }
1159
1160
1161 CDisjointClassesExpression *CXMLOWL2StreamHandler::parseDisjontClassesNode(CStreamParseStackObject* parseStackObj) {
1162 CDisjointClassesExpression *disClassExp = 0;
1163 if (parseStackObj->hasExpressions()) {
1164 disClassExp = mOntoBuilder->getDisjointClasses(*parseStackObj->getExpressions());
1165 ++mAxiomNumber;
1166 }
1167 return disClassExp;
1168 }
1169
1170 CDisjointUnionExpression *CXMLOWL2StreamHandler::parseDisjontUnionNode(CStreamParseStackObject* parseStackObj) {
1171 CDisjointUnionExpression *disClassExp = 0;
1172 if (parseStackObj->hasExpressions()) {
1173 disClassExp = mOntoBuilder->getDisjointUnion(*parseStackObj->getExpressions());
1174 }
1175 return disClassExp;
1176 }
1177
1178
1179
1180 CObjectIntersectionOfExpression *CXMLOWL2StreamHandler::parseObjectIntersectionOfNode(CStreamParseStackObject* parseStackObj) {
1181 CObjectIntersectionOfExpression *exp = 0;
1182 if (parseStackObj->hasExpressions()) {
1183 exp = mOntoBuilder->getObjectIntersectionOf(*parseStackObj->getExpressions());
1184 }
1185 return exp;
1186 }
1187
1188 CObjectUnionOfExpression *CXMLOWL2StreamHandler::parseObjectUnionOfNode(CStreamParseStackObject* parseStackObj) {
1189 CObjectUnionOfExpression *exp = 0;
1190 if (parseStackObj->hasExpressions()) {
1191 exp = mOntoBuilder->getObjectUnionOf(*parseStackObj->getExpressions());
1192 }
1193 return exp;
1194 }
1195
1196 CObjectMaxCardinalityExpression *CXMLOWL2StreamHandler::parseObjectMaxCardinalityNode(CStreamParseStackObject* parseStackObj) {
1197 cint64 cardinality = parseStackObj->mCardinality;
1198 CObjectMaxCardinalityExpression *exp = 0;
1199 if (parseStackObj->mCardinalityParsed) {
1200 exp = mOntoBuilder->getObjectMaxCardinality(*parseStackObj->getExpressions(),cardinality);
1201 }
1202 return exp;
1203 }
1204
1205 CObjectMinCardinalityExpression *CXMLOWL2StreamHandler::parseObjectMinCardinalityNode(CStreamParseStackObject* parseStackObj) {
1206 cint64 cardinality = parseStackObj->mCardinality;
1207 CObjectMinCardinalityExpression *exp = 0;
1208 if (parseStackObj->mCardinalityParsed) {
1209 exp = mOntoBuilder->getObjectMinCardinality(*parseStackObj->getExpressions(),cardinality);
1210 }
1211 return exp;
1212 }
1213
1214 CObjectExactlyCardinalityExpression *CXMLOWL2StreamHandler::parseObjectExactlyCardinalityNode(CStreamParseStackObject* parseStackObj) {
1215 cint64 cardinality = parseStackObj->mCardinality;
1216 CObjectExactlyCardinalityExpression *exp = 0;
1217 if (parseStackObj->mCardinalityParsed) {
1218 exp = mOntoBuilder->getObjectExactlyCardinality(*parseStackObj->getExpressions(),cardinality);
1219 }
1220 return exp;
1221 }
1222
1223 CObjectSomeValuesFromExpression *CXMLOWL2StreamHandler::parseObjectSomeValuesFromNode(CStreamParseStackObject* parseStackObj) {
1224 CObjectSomeValuesFromExpression *exp = 0;
1225 if (parseStackObj->hasExpressions()) {
1226 exp = mOntoBuilder->getObjectSomeValuesFrom(*parseStackObj->getExpressions());
1227 }
1228 return exp;
1229 }
1230
1231 CObjectHasValueExpression* CXMLOWL2StreamHandler::parseObjectHasValueNode(CStreamParseStackObject* parseStackObj) {
1232 CObjectHasValueExpression *exp = 0;
1233 if (parseStackObj->hasExpressions()) {
1234 exp = mOntoBuilder->getObjectHasValue(*parseStackObj->getExpressions());
1235 }
1236 return exp;
1237 }
1238
1239 CObjectHasSelfExpression* CXMLOWL2StreamHandler::parseObjectHasSelfNode(CStreamParseStackObject* parseStackObj) {
1240 CObjectHasSelfExpression *exp = 0;
1241 if (parseStackObj->hasExpressions()) {
1242 exp = mOntoBuilder->getObjectHasSelf(*parseStackObj->getExpressions());
1243 }
1244 return exp;
1245 }
1246
1247
1248 CObjectAllValuesFromExpression *CXMLOWL2StreamHandler::parseObjectAllValuesFromNode(CStreamParseStackObject* parseStackObj) {
1249 CObjectAllValuesFromExpression *exp = 0;
1250 if (parseStackObj->hasExpressions()) {
1251 exp = mOntoBuilder->getObjectAllValuesFrom(*parseStackObj->getExpressions());
1252 }
1253 return exp;
1254 }
1255
1256
1257 CObjectComplementOfExpression *CXMLOWL2StreamHandler::parseObjectComplementOfNode(CStreamParseStackObject* parseStackObj) {
1258 CObjectComplementOfExpression *exp = 0;
1259 if (parseStackObj->hasExpressions()) {
1260 exp = mOntoBuilder->getObjectComplementOf(*parseStackObj->getExpressions());
1261 }
1262 return exp;
1263 }
1264
1265 CObjectOneOfExpression *CXMLOWL2StreamHandler::parseObjectOneOfNode(CStreamParseStackObject* parseStackObj) {
1266 CObjectOneOfExpression *exp = 0;
1267 if (parseStackObj->hasExpressions()) {
1268 exp = mOntoBuilder->getObjectOneOf(*parseStackObj->getExpressions());
1269 }
1270 return exp;
1271 }
1272
1273
1274 CTransetiveObjectPropertyExpression *CXMLOWL2StreamHandler::parseTransetiveObjectPropertyNode(CStreamParseStackObject* parseStackObj) {
1275 CTransetiveObjectPropertyExpression *exp = 0;
1276 if (parseStackObj->hasExpressions()) {
1277 exp = mOntoBuilder->getTransetiveObjectProperty(*parseStackObj->getExpressions());
1278 ++mAxiomNumber;
1279 }
1280 return exp;
1281 }
1282
1283
1284 CFunctionalObjectPropertyExpression *CXMLOWL2StreamHandler::parseFunctionalObjectPropertyNode(CStreamParseStackObject* parseStackObj) {
1285 CFunctionalObjectPropertyExpression *exp = 0;
1286 if (parseStackObj->hasExpressions()) {
1287 exp = mOntoBuilder->getFunctionalObjectProperty(*parseStackObj->getExpressions());
1288 ++mAxiomNumber;
1289 }
1290 return exp;
1291 }
1292
1293
1294 CSymmetricObjectPropertyExpression* CXMLOWL2StreamHandler::parseSymmetricObjectPropertyNode(CStreamParseStackObject* parseStackObj) {
1295 CSymmetricObjectPropertyExpression *exp = 0;
1296 if (parseStackObj->hasExpressions()) {
1297 exp = mOntoBuilder->getSymmetricObjectProperty(*parseStackObj->getExpressions());
1298 ++mAxiomNumber;
1299 }
1300 return exp;
1301 }
1302
1303 CAsymmetricObjectPropertyExpression* CXMLOWL2StreamHandler::parseAsymmetricObjectPropertyNode(CStreamParseStackObject* parseStackObj) {
1304 CAsymmetricObjectPropertyExpression *exp = 0;
1305 if (parseStackObj->hasExpressions()) {
1306 exp = mOntoBuilder->getAsymmetricObjectProperty(*parseStackObj->getExpressions());
1307 ++mAxiomNumber;
1308 }
1309 return exp;
1310 }
1311
1312 CReflexiveObjectPropertyExpression* CXMLOWL2StreamHandler::parseReflexiveObjectPropertyNode(CStreamParseStackObject* parseStackObj) {
1313 CReflexiveObjectPropertyExpression *exp = 0;
1314 if (parseStackObj->hasExpressions()) {
1315 exp = mOntoBuilder->getReflexiveObjectProperty(*parseStackObj->getExpressions());
1316 ++mAxiomNumber;
1317 }
1318 return exp;
1319 }
1320
1321 CIrreflexiveObjectPropertyExpression* CXMLOWL2StreamHandler::parseIrreflexiveObjectPropertyNode(CStreamParseStackObject* parseStackObj) {
1322 CIrreflexiveObjectPropertyExpression *exp = 0;
1323 if (parseStackObj->hasExpressions()) {
1324 exp = mOntoBuilder->getIrreflexiveObjectProperty(*parseStackObj->getExpressions());
1325 ++mAxiomNumber;
1326 }
1327 return exp;
1328 }
1329
1330 CInverseFunctionalObjectPropertyExpression* CXMLOWL2StreamHandler::parseInverseFunctionalObjectPropertyNode(CStreamParseStackObject* parseStackObj) {
1331 CInverseFunctionalObjectPropertyExpression *exp = 0;
1332 if (parseStackObj->hasExpressions()) {
1333 exp = mOntoBuilder->getInverseFunctionalObjectProperty(*parseStackObj->getExpressions());
1334 ++mAxiomNumber;
1335 }
1336 return exp;
1337 }
1338
1339
1340
1341
1342
1343 CClassAssertionExpression *CXMLOWL2StreamHandler::parseClassAssertionNode(CStreamParseStackObject* parseStackObj) {
1344 CClassAssertionExpression *exp = 0;
1345 if (parseStackObj->hasExpressions()) {
1346 exp = mOntoBuilder->getClassAssertion(*parseStackObj->getExpressions());
1347 ++mAxiomNumber;
1348 }
1349 return exp;
1350 }
1351
1352
1353 CSameIndividualExpression *CXMLOWL2StreamHandler::parseSameIndividualNode(CStreamParseStackObject* parseStackObj) {
1354 CSameIndividualExpression *exp = 0;
1355 if (mOntoBuilder && parseStackObj->hasExpressions()) {
1356 exp = mOntoBuilder->getSameIndividual(*parseStackObj->getExpressions());
1357 ++mAxiomNumber;
1358 }
1359 return exp;
1360 }
1361
1362 CDifferentIndividualsExpression *CXMLOWL2StreamHandler::parseDifferentIndividualsNode(CStreamParseStackObject* parseStackObj) {
1363 CDifferentIndividualsExpression *exp = 0;
1364 if (mOntoBuilder && parseStackObj->hasExpressions()) {
1365 exp = mOntoBuilder->getDifferentIndividuals(*parseStackObj->getExpressions());
1366 ++mAxiomNumber;
1367 }
1368 return exp;
1369 }
1370
1371
1372 CNamedIndividualExpression *CXMLOWL2StreamHandler::parseNamedIndividualNode(const QXmlStreamAttributes& attributes) {
1373 const CStringRefStringHasher& indiNameName = getEntityName(attributes);
1374 CNamedIndividualExpression *exp = 0;
1375 if (!indiNameName.isEmpty()) {
1376 if (mOntoBuilder) {
1377 exp = mOntoBuilder->getNamedIndividual(indiNameName.toStringRefernce());
1378 }
1379 }
1380 return exp;
1381 }
1382
1383
1384 CAnonymousIndividualExpression *CXMLOWL2StreamHandler::parseAnonymousIndividualNode(const QXmlStreamAttributes& attributes) {
1385 if (mOntologyIdentifier.isEmpty()) {
1386 mOntologyIdentifier = mOntoBuilder->getOntologyAnonymousIdentifier(mOntoBuilder->getOntologyName());
1387 }
1388 QStringRef indiNameName = getNodeID(attributes);
1389 CAnonymousIndividualExpression *exp = 0;
1390 if (!indiNameName.isEmpty()) {
1391 if (mOntoBuilder) {
1392 exp = mOntoBuilder->getAnonymousIndividual(QStringRef(&mOntologyIdentifier),indiNameName);
1393 }
1394 }
1395 return exp;
1396 }
1397
1398 CObjectPropertyAssertionExpression *CXMLOWL2StreamHandler::parseObjectPropertyAssertionNode(CStreamParseStackObject* parseStackObj) {
1399 CObjectPropertyAssertionExpression *exp = 0;
1400 if (mOntoBuilder && parseStackObj->hasExpressions()) {
1401 exp = mOntoBuilder->getObjectPropertyAssertion(*parseStackObj->getExpressions());
1402 ++mAxiomNumber;
1403 }
1404 return exp;
1405 }
1406
1407 CNegativeObjectPropertyAssertionExpression *CXMLOWL2StreamHandler::parseNegativeObjectPropertyAssertionNode(CStreamParseStackObject* parseStackObj) {
1408 CNegativeObjectPropertyAssertionExpression *exp = 0;
1409 if (mOntoBuilder && parseStackObj->hasExpressions()) {
1410 exp = mOntoBuilder->getNegativeObjectPropertyAssertion(*parseStackObj->getExpressions());
1411 ++mAxiomNumber;
1412 }
1413 return exp;
1414 }
1415
1416
1417
1418
1419
1420
1421
1422
1423
1424
1425
1426
1427
1428 CDatatypeExpression *CXMLOWL2StreamHandler::parseDatatypeNode(const QXmlStreamAttributes& attributes) {
1429 const CStringRefStringHasher& datatypeIRIName = getEntityName(attributes);
1430 CDatatypeExpression* exp = nullptr;
1431 if (!datatypeIRIName.isEmpty()) {
1432 if (mOntoBuilder) {
1433 exp = mOntoBuilder->getDatatype(datatypeIRIName.toStringRefernce());
1434 }
1435 }
1436 return exp;
1437 }
1438
1439
1440 CDataSomeValuesFromExpression *CXMLOWL2StreamHandler::parseDataSomeValuesFromNode(CStreamParseStackObject* parseStackObj) {
1441 CDataSomeValuesFromExpression* exp = nullptr;
1442 if (mOntoBuilder && parseStackObj->hasExpressions()) {
1443 exp = mOntoBuilder->getDataSomeValuesFrom(*parseStackObj->getExpressions());
1444 }
1445 return exp;
1446 }
1447
1448
1449
1450
1451 CDataAllValuesFromExpression *CXMLOWL2StreamHandler::parseDataAllValuesFromNode(CStreamParseStackObject* parseStackObj) {
1452 CDataAllValuesFromExpression* exp = nullptr;
1453 if (mOntoBuilder && parseStackObj->hasExpressions()) {
1454 exp = mOntoBuilder->getDataAllValuesFrom(*parseStackObj->getExpressions());
1455 }
1456 return exp;
1457 }
1458
1459 CDataHasValueExpression *CXMLOWL2StreamHandler::parseDataHasValueNode(CStreamParseStackObject* parseStackObj) {
1460 CDataHasValueExpression* exp = nullptr;
1461 if (mOntoBuilder && parseStackObj->hasExpressions()) {
1462 exp = mOntoBuilder->getDataHasValue(*parseStackObj->getExpressions());
1463 }
1464 return exp;
1465 }
1466
1467 CDataIntersectionOfExpression *CXMLOWL2StreamHandler::parseDataIntersectionOfNode(CStreamParseStackObject* parseStackObj) {
1468 CDataIntersectionOfExpression* exp = nullptr;
1469 if (mOntoBuilder && parseStackObj->hasExpressions()) {
1470 exp = mOntoBuilder->getDataIntersectionOf(*parseStackObj->getExpressions());
1471 }
1472 return exp;
1473 }
1474
1475 CDataOneOfExpression *CXMLOWL2StreamHandler::parseDataOneOfNode(CStreamParseStackObject* parseStackObj) {
1476 CDataOneOfExpression* exp = nullptr;
1477 if (mOntoBuilder && parseStackObj->hasExpressions()) {
1478 exp = mOntoBuilder->getDataOneOf(*parseStackObj->getExpressions());
1479 }
1480 return exp;
1481 }
1482
1483 CDataUnionOfExpression *CXMLOWL2StreamHandler::parseDataUnionOfNode(CStreamParseStackObject* parseStackObj) {
1484 CDataUnionOfExpression* exp = nullptr;
1485 if (mOntoBuilder && parseStackObj->hasExpressions()) {
1486 exp = mOntoBuilder->getDataUnionOf(*parseStackObj->getExpressions());
1487 }
1488 return exp;
1489 }
1490
1491 CDataComplementOfExpression *CXMLOWL2StreamHandler::parseDataComplementOfNode(CStreamParseStackObject* parseStackObj) {
1492 CDataComplementOfExpression* exp = nullptr;
1493 if (mOntoBuilder && parseStackObj->hasExpressions()) {
1494 exp = mOntoBuilder->getDataComplementOf(*parseStackObj->getExpressions());
1495 }
1496 return exp;
1497 }
1498
1499 CDatatypeRestrictionExpression *CXMLOWL2StreamHandler::parseDatatypeRestrictionNode(CStreamParseStackObject* parseStackObj) {
1500 CDatatypeRestrictionExpression* exp = nullptr;
1501 if (mOntoBuilder && parseStackObj->hasExpressions()) {
1502 exp = mOntoBuilder->getDatatypeRestriction(*parseStackObj->getExpressions());
1503 }
1504 return exp;
1505 }
1506
1507 CDataMaxCardinalityExpression *CXMLOWL2StreamHandler::parseDataMaxCardinalityNode(CStreamParseStackObject* parseStackObj) {
1508 CDataMaxCardinalityExpression* exp = nullptr;
1509 if (mOntoBuilder && parseStackObj->hasExpressions() && parseStackObj->mCardinalityParsed) {
1510 exp = mOntoBuilder->getDataMaxCardinality(*parseStackObj->getExpressions(),parseStackObj->mCardinality);
1511 }
1512 return exp;
1513 }
1514
1515 CDataMinCardinalityExpression *CXMLOWL2StreamHandler::parseDataMinCardinalityNode(CStreamParseStackObject* parseStackObj) {
1516 CDataMinCardinalityExpression* exp = nullptr;
1517 if (mOntoBuilder && parseStackObj->hasExpressions() && parseStackObj->mCardinalityParsed) {
1518 exp = mOntoBuilder->getDataMinCardinality(*parseStackObj->getExpressions(),parseStackObj->mCardinality);
1519 }
1520 return exp;
1521 }
1522
1523 CDataExactCardinalityExpression *CXMLOWL2StreamHandler::parseDataExactCardinalityNode(CStreamParseStackObject* parseStackObj) {
1524 CDataExactCardinalityExpression* exp = nullptr;
1525 if (mOntoBuilder && parseStackObj->hasExpressions() && parseStackObj->mCardinalityParsed) {
1526 exp = mOntoBuilder->getDataExactCardinality(*parseStackObj->getExpressions(),parseStackObj->mCardinality);
1527 }
1528 return exp;
1529 }
1530
1531 CDataPropertyAssertionExpression *CXMLOWL2StreamHandler::parseDataPropertyAssertionNode(CStreamParseStackObject* parseStackObj) {
1532 CDataPropertyAssertionExpression* exp = nullptr;
1533 if (mOntoBuilder && parseStackObj->hasExpressions()) {
1534 exp = mOntoBuilder->getDataPropertyAssertion(*parseStackObj->getExpressions());
1535 }
1536 return exp;
1537 }
1538
1539 CNegativeDataPropertyAssertionExpression *CXMLOWL2StreamHandler::parseNegativeDataPropertyAssertionNode(CStreamParseStackObject* parseStackObj) {
1540 CNegativeDataPropertyAssertionExpression* exp = nullptr;
1541 if (mOntoBuilder && parseStackObj->hasExpressions()) {
1542 exp = mOntoBuilder->getNegativeDataPropertyAssertion(*parseStackObj->getExpressions());
1543 }
1544 return exp;
1545 }
1546
1547 CSubDataPropertyOfExpression *CXMLOWL2StreamHandler::parseSubDataPropertyOfNode(CStreamParseStackObject* parseStackObj) {
1548 CSubDataPropertyOfExpression* exp = nullptr;
1549 if (mOntoBuilder && parseStackObj->hasExpressions()) {
1550 exp = mOntoBuilder->getSubDataPropertyOf(*parseStackObj->getExpressions());
1551 }
1552 return exp;
1553 }
1554
1555 CEquivalentDataPropertiesExpression *CXMLOWL2StreamHandler::parseEquivalentDataPropertiesNode(CStreamParseStackObject* parseStackObj) {
1556 CEquivalentDataPropertiesExpression* exp = nullptr;
1557 if (mOntoBuilder && parseStackObj->hasExpressions()) {
1558 exp = mOntoBuilder->getEquivalentDataProperties(*parseStackObj->getExpressions());
1559 }
1560 return exp;
1561 }
1562
1563 CDisjointDataPropertiesExpression *CXMLOWL2StreamHandler::parseDisjointDataPropertiesNode(CStreamParseStackObject* parseStackObj) {
1564 CDisjointDataPropertiesExpression* exp = nullptr;
1565 if (mOntoBuilder && parseStackObj->hasExpressions()) {
1566 exp = mOntoBuilder->getDisjointDataProperties(*parseStackObj->getExpressions());
1567 }
1568 return exp;
1569 }
1570
1571 CDataPropertyDomainExpression *CXMLOWL2StreamHandler::parseDataPropertyDomainNode(CStreamParseStackObject* parseStackObj) {
1572 CDataPropertyDomainExpression* exp = nullptr;
1573 if (mOntoBuilder && parseStackObj->hasExpressions()) {
1574 exp = mOntoBuilder->getDataPropertyDomainExpression(*parseStackObj->getExpressions());
1575 }
1576 return exp;
1577 }
1578
1579 CDataPropertyRangeExpression *CXMLOWL2StreamHandler::parseDataPropertyRangeNode(CStreamParseStackObject* parseStackObj) {
1580 CDataPropertyRangeExpression* exp = nullptr;
1581 if (mOntoBuilder && parseStackObj->hasExpressions()) {
1582 exp = mOntoBuilder->getDataPropertyRangeExpression(*parseStackObj->getExpressions());
1583 }
1584 return exp;
1585 }
1586
1587 CFunctionalDataPropertyExpression *CXMLOWL2StreamHandler::parseFunctionalDataPropertyNode(CStreamParseStackObject* parseStackObj) {
1588 CFunctionalDataPropertyExpression* exp = nullptr;
1589 if (mOntoBuilder && parseStackObj->hasExpressions()) {
1590 exp = mOntoBuilder->getFunctionalDataProperty(*parseStackObj->getExpressions());
1591 }
1592 return exp;
1593 }
1594
1595 CDataFacetRestrictionExpression* CXMLOWL2StreamHandler::parseDataFacetRestrictionNode(CStreamParseStackObject* parseStackObj) {
1596 CDataFacetRestrictionExpression* exp = nullptr;
1597 if (mOntoBuilder && parseStackObj->hasExpressions()) {
1598 CQtList<CBuildExpression*> expList(*parseStackObj->getExpressions());
1599 CDataFacetExpression* dataFacetExp = mOntoBuilder->getDataFacet(parseStackObj->getParsedIRI());
1600 expList.append(dataFacetExp);
1601 exp = mOntoBuilder->getDataFacetRestriction(expList);
1602 }
1603 return exp;
1604 }
1605
1606
1607
1608
1609
1610
1611
1612
1613
1614
1615
1616 CDataLiteralExpression *CXMLOWL2StreamHandler::parseDataLiteralNode(CStreamParseStackObject* parseStackObj) {
1617 CDataLiteralExpression* exp = nullptr;
1618 if (mOntoBuilder && parseStackObj->mIRIParsed) {
1619 QString datatypeIRIString = parseStackObj->getParsedIRI();
1620 if (datatypeIRIString.isEmpty()) {
1621 datatypeIRIString = mDefaultDatatype;
1622 }
1623 CDatatypeExpression* datatypeExpression = mOntoBuilder->getDatatype(datatypeIRIString);
1624 QString valueString = mLastReadText;
1625 if (!mLastTextAppendix.isEmpty()) {
1626 valueString = mLastReadText+"@"+mLastTextAppendix;
1627 }
1628 CDataLexicalValueExpression* dataLexicalValueExpression = mOntoBuilder->getDataLexicalValue(valueString);
1629 exp = mOntoBuilder->getDataLiteral(dataLexicalValueExpression,datatypeExpression);
1630 }
1631 return exp;
1632 }
1633
1634
1635
1636 CDataPropertyExpression *CXMLOWL2StreamHandler::parseDataPropertyNode(const QXmlStreamAttributes& attributes) {
1637 const CStringRefStringHasher& probName = getEntityName(attributes);
1638 CDataPropertyExpression *objectExpression = 0;
1639 if (!probName.isEmpty()) {
1640 objectExpression = mOntoBuilder->getDataProberty(probName.toStringRefernce());
1641 }
1642 return objectExpression;
1643 }
1644
1645
1646
1647
1648
1649
1650
1651
1652
1653
1654
1655
1656
1657
1658 void CXMLOWL2StreamHandler::jumpFunctionParseRuleNode(CStreamParseStackObject* parseStackObj) {
1659 parseRuleNode(parseStackObj);
1660 }
1661
1662 void CXMLOWL2StreamHandler::jumpFunctionParseRuleObjectPropertyAtomNode(CStreamParseStackObject* parseStackObj) {
1663 addTemporaryBuildExpression(parseRuleObjectPropertyAtomNode(parseStackObj));
1664 }
1665
1666 void CXMLOWL2StreamHandler::jumpFunctionParseRuleDataPropertyAtomNode(CStreamParseStackObject* parseStackObj) {
1667 addTemporaryBuildExpression(parseRuleDataPropertyAtomNode(parseStackObj));
1668 }
1669
1670 void CXMLOWL2StreamHandler::jumpFunctionParseRuleClassAtomNode(CStreamParseStackObject* parseStackObj) {
1671 addTemporaryBuildExpression(parseRuleClassAtomNode(parseStackObj));
1672 }
1673
1674
1675 void CXMLOWL2StreamHandler::jumpFunctionParseDifferentIndividualsAtomNode(CStreamParseStackObject* parseStackObj) {
1676 addTemporaryBuildExpression(parseRuleDifferentIndividualsAtomNode(parseStackObj));
1677 }
1678
1679 void CXMLOWL2StreamHandler::jumpFunctionParseDataPropertyNode(const QXmlStreamAttributes& attributes) {
1680 addTemporaryBuildExpression(parseDataPropertyNode(attributes));
1681 }
1682
1683
1684
1685
1686
1687
1688 void CXMLOWL2StreamHandler::jumpFunctionParseRuleAtomBodyNode(CStreamParseStackObject* parseStackObj) {
1689 addTemporaryBuildExpression(parseRuleAtomBodyNode(parseStackObj));
1690 }
1691
1692 void CXMLOWL2StreamHandler::jumpFunctionParseRuleAtomHeadNode(CStreamParseStackObject* parseStackObj) {
1693 addTemporaryBuildExpression(parseRuleAtomHeadNode(parseStackObj));
1694 }
1695
1696
1697 bool CXMLOWL2StreamHandler::hasOntologyNodeFound() {
1698 return mOntologyNodeFound;
1699 }
1700
1701
1702
1703
1704 void CXMLOWL2StreamHandler::jumpFunctionTellOntologyAxiomNode(CStreamParseStackObject* parseStackObj) {
1705 mOntologyNodeFound = true;
1706 parseTellOntologyAxiomNode(parseStackObj);
1707 }
1708
1709 void CXMLOWL2StreamHandler::jumpFunctionRetractOntologyAxiomNode(CStreamParseStackObject* parseStackObj) {
1710 parseRetractOntologyAxiomNode(parseStackObj);
1711 }
1712
1713 void CXMLOWL2StreamHandler::jumpFunctionParsePrefixNode(const QXmlStreamAttributes& attributes) {
1714 parsePrefixNode(attributes);
1715 }
1716
1717
1718
1719
1720
1721
1722 void CXMLOWL2StreamHandler::addTemporaryBuildExpression(CBuildExpression* buildExp) {
1723 if (buildExp) {
1724 mTmpExpList.append(buildExp);
1725 }
1726 }
1727
1728 void CXMLOWL2StreamHandler::addTemporaryBuildExpressions(QList<CBuildExpression*>* buildExps) {
1729 if (buildExps) {
1730 for (QList<CBuildExpression*>::const_iterator it = buildExps->constBegin(), itEnd = buildExps->constEnd(); it != itEnd; ++it) {
1731 CBuildExpression* buildExp = *it;
1732 if (buildExp) {
1733 mTmpExpList.append(buildExp);
1734 }
1735 }
1736 }
1737 }
1738
1739
1740
1741
1742
1743 void CXMLOWL2StreamHandler::jumpFunctionParseClassNode(const QXmlStreamAttributes& attributes) {
1744 addTemporaryBuildExpression(parseClassNode(attributes));
1745 }
1746
1747 void CXMLOWL2StreamHandler::jumpFunctionParseObjectPropertyNode(const QXmlStreamAttributes& attributes) {
1748 addTemporaryBuildExpression(parseObjectPropertyNode(attributes));
1749 }
1750
1751
1752 void CXMLOWL2StreamHandler::jumpFunctionParseIndividualVariable(const QXmlStreamAttributes& attributes) {
1753 addTemporaryBuildExpression(parseIndividualVariableNode(attributes));
1754 }
1755
1756
1757 void CXMLOWL2StreamHandler::jumpFunctionParseDeclarationNode(CStreamParseStackObject* parseStackObj) {
1758 addTemporaryBuildExpression(parseDeclarationNode(parseStackObj));
1759 }
1760
1761
1762 void CXMLOWL2StreamHandler::jumpFunctionParseEquivalentClassesNode(CStreamParseStackObject* parseStackObj) {
1763 addTemporaryBuildExpression(parseEquivalentClassesNode(parseStackObj));
1764 }
1765
1766 void CXMLOWL2StreamHandler::jumpFunctionParseSubClassOfNode(CStreamParseStackObject* parseStackObj) {
1767 addTemporaryBuildExpression(parseSubClassOfNode(parseStackObj));
1768 }
1769
1770 void CXMLOWL2StreamHandler::jumpFunctionParseDisjontClassesNode(CStreamParseStackObject* parseStackObj) {
1771 addTemporaryBuildExpression(parseDisjontClassesNode(parseStackObj));
1772 }
1773
1774 void CXMLOWL2StreamHandler::jumpFunctionParseDisjontUnionNode(CStreamParseStackObject* parseStackObj) {
1775 addTemporaryBuildExpression(parseDisjontUnionNode(parseStackObj));
1776 }
1777
1778
1779 void CXMLOWL2StreamHandler::jumpFunctionParseSubObjectPropertyOfNode(CStreamParseStackObject* parseStackObj) {
1780 addTemporaryBuildExpression(parseSubObjectPropertyOfNode(parseStackObj));
1781 }
1782
1783 void CXMLOWL2StreamHandler::jumpFunctionParseObjectPropertyChainNode(CStreamParseStackObject* parseStackObj) {
1784 addTemporaryBuildExpression(parseObjectPropertyChainNode(parseStackObj));
1785 }
1786
1787 void CXMLOWL2StreamHandler::jumpFunctionParseEquivalentObjectPropertiesNode(CStreamParseStackObject* parseStackObj) {
1788 addTemporaryBuildExpression(parseEquivalentObjectPropertiesNode(parseStackObj));
1789 }
1790
1791 void CXMLOWL2StreamHandler::jumpFunctionParseDisjointObjectPropertiesNode(CStreamParseStackObject* parseStackObj) {
1792 addTemporaryBuildExpression(parseDisjointObjectPropertiesNode(parseStackObj));
1793 }
1794
1795
1796 void CXMLOWL2StreamHandler::jumpFunctionParseObjectIntersectionOfNode(CStreamParseStackObject* parseStackObj) {
1797 addTemporaryBuildExpression(parseObjectIntersectionOfNode(parseStackObj));
1798 }
1799
1800 void CXMLOWL2StreamHandler::jumpFunctionParseObjectUnionOfNode(CStreamParseStackObject* parseStackObj) {
1801 addTemporaryBuildExpression(parseObjectUnionOfNode(parseStackObj));
1802 }
1803
1804 void CXMLOWL2StreamHandler::jumpFunctionParseObjectMaxCardinalityNode(CStreamParseStackObject* parseStackObj) {
1805 addTemporaryBuildExpression(parseObjectMaxCardinalityNode(parseStackObj));
1806 }
1807
1808 void CXMLOWL2StreamHandler::jumpFunctionParseObjectMinCardinalityNode(CStreamParseStackObject* parseStackObj) {
1809 addTemporaryBuildExpression(parseObjectMinCardinalityNode(parseStackObj));
1810 }
1811
1812 void CXMLOWL2StreamHandler::jumpFunctionParseObjectExactlyCardinalityNode(CStreamParseStackObject* parseStackObj) {
1813 addTemporaryBuildExpression(parseObjectExactlyCardinalityNode(parseStackObj));
1814 }
1815
1816 void CXMLOWL2StreamHandler::jumpFunctionParseObjectSomeValuesFromNode(CStreamParseStackObject* parseStackObj) {
1817 addTemporaryBuildExpression(parseObjectSomeValuesFromNode(parseStackObj));
1818 }
1819
1820 void CXMLOWL2StreamHandler::jumpFunctionParseObjectAllValuesFromNode(CStreamParseStackObject* parseStackObj) {
1821 addTemporaryBuildExpression(parseObjectAllValuesFromNode(parseStackObj));
1822 }
1823
1824 void CXMLOWL2StreamHandler::jumpFunctionParseObjectComplementOfNode(CStreamParseStackObject* parseStackObj) {
1825 addTemporaryBuildExpression(parseObjectComplementOfNode(parseStackObj));
1826 }
1827
1828 void CXMLOWL2StreamHandler::jumpFunctionParseObjectOneOfNode(CStreamParseStackObject* parseStackObj) {
1829 addTemporaryBuildExpression(parseObjectOneOfNode(parseStackObj));
1830 }
1831
1832 void CXMLOWL2StreamHandler::jumpFunctionParseObjectHasValueNode(CStreamParseStackObject* parseStackObj) {
1833 addTemporaryBuildExpression(parseObjectHasValueNode(parseStackObj));
1834 }
1835
1836 void CXMLOWL2StreamHandler::jumpFunctionParseObjectHasSelfNode(CStreamParseStackObject* parseStackObj) {
1837 addTemporaryBuildExpression(parseObjectHasSelfNode(parseStackObj));
1838 }
1839
1840
1841 void CXMLOWL2StreamHandler::jumpFunctionParseClassAssertionNode(CStreamParseStackObject* parseStackObj) {
1842 addTemporaryBuildExpression(parseClassAssertionNode(parseStackObj));
1843 }
1844
1845 void CXMLOWL2StreamHandler::jumpFunctionParseNamedIndividualNode(const QXmlStreamAttributes& attributes) {
1846 addTemporaryBuildExpression(parseNamedIndividualNode(attributes));
1847 }
1848
1849
1850
1851 void CXMLOWL2StreamHandler::jumpFunctionParseDatatypeNode(const QXmlStreamAttributes& attributes) {
1852 addTemporaryBuildExpression(parseDatatypeNode(attributes));
1853 }
1854
1855 void CXMLOWL2StreamHandler::jumpFunctionParseDataSomeValuesFromNode(CStreamParseStackObject* parseStackObj) {
1856 addTemporaryBuildExpression(parseDataSomeValuesFromNode(parseStackObj));
1857 }
1858
1859
1860
1861 void CXMLOWL2StreamHandler::jumpFunctionParseDataAllValuesFromNode(CStreamParseStackObject* parseStackObj) {
1862 addTemporaryBuildExpression(parseDataAllValuesFromNode(parseStackObj));
1863 }
1864
1865 void CXMLOWL2StreamHandler::jumpFunctionParseDataHasValueNode(CStreamParseStackObject* parseStackObj) {
1866 addTemporaryBuildExpression(parseDataHasValueNode(parseStackObj));
1867 }
1868
1869 void CXMLOWL2StreamHandler::jumpFunctionParseDataIntersectionOfNode(CStreamParseStackObject* parseStackObj) {
1870 addTemporaryBuildExpression(parseDataIntersectionOfNode(parseStackObj));
1871 }
1872
1873 void CXMLOWL2StreamHandler::jumpFunctionParseDataOneOfNode(CStreamParseStackObject* parseStackObj) {
1874 addTemporaryBuildExpression(parseDataOneOfNode(parseStackObj));
1875 }
1876
1877 void CXMLOWL2StreamHandler::jumpFunctionParseDataUnionOfNode(CStreamParseStackObject* parseStackObj) {
1878 addTemporaryBuildExpression(parseDataUnionOfNode(parseStackObj));
1879 }
1880
1881 void CXMLOWL2StreamHandler::jumpFunctionParseDataComplementOfNode(CStreamParseStackObject* parseStackObj) {
1882 addTemporaryBuildExpression(parseDataComplementOfNode(parseStackObj));
1883 }
1884
1885 void CXMLOWL2StreamHandler::jumpFunctionParseDatatypeRestrictionNode(CStreamParseStackObject* parseStackObj) {
1886 addTemporaryBuildExpression(parseDatatypeRestrictionNode(parseStackObj));
1887 }
1888
1889 void CXMLOWL2StreamHandler::jumpFunctionParseDataMaxCardinalityNode(CStreamParseStackObject* parseStackObj) {
1890 addTemporaryBuildExpression(parseDataMaxCardinalityNode(parseStackObj));
1891 }
1892
1893 void CXMLOWL2StreamHandler::jumpFunctionParseDataMinCardinalityNode(CStreamParseStackObject* parseStackObj) {
1894 addTemporaryBuildExpression(parseDataMinCardinalityNode(parseStackObj));
1895 }
1896
1897 void CXMLOWL2StreamHandler::jumpFunctionParseDataExactCardinalityNode(CStreamParseStackObject* parseStackObj) {
1898 addTemporaryBuildExpression(parseDataExactCardinalityNode(parseStackObj));
1899 }
1900
1901 void CXMLOWL2StreamHandler::jumpFunctionParseDataPropertyAssertionNode(CStreamParseStackObject* parseStackObj) {
1902 addTemporaryBuildExpression(parseDataPropertyAssertionNode(parseStackObj));
1903 }
1904
1905 void CXMLOWL2StreamHandler::jumpFunctionParseNegativeDataPropertyAssertionNode(CStreamParseStackObject* parseStackObj) {
1906 addTemporaryBuildExpression(parseNegativeDataPropertyAssertionNode(parseStackObj));
1907 }
1908
1909 void CXMLOWL2StreamHandler::jumpFunctionParseSubDataPropertyOfNode(CStreamParseStackObject* parseStackObj) {
1910 addTemporaryBuildExpression(parseSubDataPropertyOfNode(parseStackObj));
1911 }
1912
1913 void CXMLOWL2StreamHandler::jumpFunctionParseEquivalentDataPropertiesNode(CStreamParseStackObject* parseStackObj) {
1914 addTemporaryBuildExpression(parseEquivalentDataPropertiesNode(parseStackObj));
1915 }
1916
1917 void CXMLOWL2StreamHandler::jumpFunctionParseDisjointDataPropertiesNode(CStreamParseStackObject* parseStackObj) {
1918 addTemporaryBuildExpression(parseDisjointDataPropertiesNode(parseStackObj));
1919 }
1920
1921 void CXMLOWL2StreamHandler::jumpFunctionParseDataPropertyDomainNode(CStreamParseStackObject* parseStackObj) {
1922 addTemporaryBuildExpression(parseDataPropertyDomainNode(parseStackObj));
1923 }
1924
1925 void CXMLOWL2StreamHandler::jumpFunctionParseDataPropertyRangeNode(CStreamParseStackObject* parseStackObj) {
1926 addTemporaryBuildExpression(parseDataPropertyRangeNode(parseStackObj));
1927 }
1928
1929 void CXMLOWL2StreamHandler::jumpFunctionParseFunctionalDataPropertyNode(CStreamParseStackObject* parseStackObj) {
1930 addTemporaryBuildExpression(parseFunctionalDataPropertyNode(parseStackObj));
1931 }
1932
1933 void CXMLOWL2StreamHandler::jumpFunctionParseDataFacetRestrictionNode(CStreamParseStackObject* parseStackObj) {
1934 addTemporaryBuildExpression(parseDataFacetRestrictionNode(parseStackObj));
1935 }
1936
1937
1938
1939
1940
1941
1942
1943
1944
1945
1946
1947
1948
1949
1950
1951
1952
1953
1954
1955
1956
1957
1958
1959
1960
1961
1962
1963
1964
1965 void CXMLOWL2StreamHandler::jumpFunctionParseDataLiteralNode(CStreamParseStackObject* parseStackObj) {
1966 addTemporaryBuildExpression(parseDataLiteralNode(parseStackObj));
1967 }
1968
1969 void CXMLOWL2StreamHandler::jumpFunctionParseAnonymousIndividualNode(const QXmlStreamAttributes& attributes) {
1970 addTemporaryBuildExpression(parseAnonymousIndividualNode(attributes));
1971 }
1972
1973 void CXMLOWL2StreamHandler::jumpFunctionParseObjectPropertyAssertionNode(CStreamParseStackObject* parseStackObj) {
1974 addTemporaryBuildExpression(parseObjectPropertyAssertionNode(parseStackObj));
1975 }
1976
1977 void CXMLOWL2StreamHandler::jumpFunctionParseNegativeObjectPropertyAssertionNode(CStreamParseStackObject* parseStackObj) {
1978 addTemporaryBuildExpression(parseNegativeObjectPropertyAssertionNode(parseStackObj));
1979 }
1980
1981 void CXMLOWL2StreamHandler::jumpFunctionParseSameIndividualNode(CStreamParseStackObject* parseStackObj) {
1982 addTemporaryBuildExpression(parseSameIndividualNode(parseStackObj));
1983 }
1984
1985 void CXMLOWL2StreamHandler::jumpFunctionParseDifferentIndividualsNode(CStreamParseStackObject* parseStackObj) {
1986 addTemporaryBuildExpression(parseDifferentIndividualsNode(parseStackObj));
1987 }
1988
1989
1990 void CXMLOWL2StreamHandler::jumpFunctionParseObjectPropertyDomainNode(CStreamParseStackObject* parseStackObj) {
1991 addTemporaryBuildExpression(parseObjectPropertyDomainNode(parseStackObj));
1992 }
1993
1994 void CXMLOWL2StreamHandler::jumpFunctionParseObjectPropertyRangeNode(CStreamParseStackObject* parseStackObj) {
1995 addTemporaryBuildExpression(parseObjectPropertyRangeNode(parseStackObj));
1996 }
1997
1998 void CXMLOWL2StreamHandler::jumpFunctionParseInverseObjectPropertyOfNode(CStreamParseStackObject* parseStackObj) {
1999 addTemporaryBuildExpression(parseInverseObjectPropertyOfNode(parseStackObj));
2000 }
2001
2002 void CXMLOWL2StreamHandler::jumpFunctionParseInverseObjectPropertiesNode(CStreamParseStackObject* parseStackObj) {
2003 addTemporaryBuildExpression(parseInverseObjectPropertiesNode(parseStackObj));
2004 }
2005
2006 void CXMLOWL2StreamHandler::jumpFunctionParseTransetiveObjectPropertyNode(CStreamParseStackObject* parseStackObj) {
2007 addTemporaryBuildExpression(parseTransetiveObjectPropertyNode(parseStackObj));
2008 }
2009
2010 void CXMLOWL2StreamHandler::jumpFunctionParseFunctionalObjectPropertyNode(CStreamParseStackObject* parseStackObj) {
2011 addTemporaryBuildExpression(parseFunctionalObjectPropertyNode(parseStackObj));
2012 }
2013
2014 void CXMLOWL2StreamHandler::jumpFunctionParseSymmetricObjectPropertyNode(CStreamParseStackObject* parseStackObj) {
2015 addTemporaryBuildExpression(parseSymmetricObjectPropertyNode(parseStackObj));
2016 }
2017
2018 void CXMLOWL2StreamHandler::jumpFunctionParseAsymmetricObjectPropertyNode(CStreamParseStackObject* parseStackObj) {
2019 addTemporaryBuildExpression(parseAsymmetricObjectPropertyNode(parseStackObj));
2020 }
2021
2022 void CXMLOWL2StreamHandler::jumpFunctionParseReflexiveObjectPropertyNode(CStreamParseStackObject* parseStackObj) {
2023 addTemporaryBuildExpression(parseReflexiveObjectPropertyNode(parseStackObj));
2024 }
2025
2026 void CXMLOWL2StreamHandler::jumpFunctionParseIrreflexiveObjectPropertyNode(CStreamParseStackObject* parseStackObj) {
2027 addTemporaryBuildExpression(parseIrreflexiveObjectPropertyNode(parseStackObj));
2028 }
2029
2030 void CXMLOWL2StreamHandler::jumpFunctionParseInverseFunctionalObjectPropertyNode(CStreamParseStackObject* parseStackObj) {
2031 addTemporaryBuildExpression(parseInverseFunctionalObjectPropertyNode(parseStackObj));
2032 }
2033
2034 void CXMLOWL2StreamHandler::jumpFunctionParseIgnoredNode(CStreamParseStackObject* parseStackObj) {
2035 }
2036
2037 void CXMLOWL2StreamHandler::jumpFunctionUnsupportedDatatypeNode(CStreamParseStackObject* parseStackObj) {
2038 if (mDataTypeReportErrorCount > 0) {
2039 --mDataTypeReportErrorCount;
2040 LOG(ERROR,getLogDomain(),logTr("Skipped parsing of not supported datatype expression/axiom."),this);
2041 } else if (mDataTypeReportErrorCount == 0) {
2042 --mDataTypeReportErrorCount;
2043 LOG(ERROR,getLogDomain(),logTr("Remaining not supported datatype expressions/axioms are ignored."),this);
2044 }
2045 }
2046
2047 void CXMLOWL2StreamHandler::jumpFunctionUnsupportedRDFNode(CStreamParseStackObject* parseStackObj) {
2048 }
2049
2050
2051 void CXMLOWL2StreamHandler::jumpFunctionParseImportNode(CStreamParseStackObject* parseStackObj) {
2052 if (!mLastReadText.isEmpty()) {
2053 mOntoBuilder->addOntologyImport(mLastReadText);
2054 }
2055 }
2056
2057
2058 void CXMLOWL2StreamHandler::jumpFunctionUnsupportedImportNode(CStreamParseStackObject* parseStackObj) {
2059 if (!mUnsupportedImportError) {
2060 mUnsupportedImportError = true;
2061 LOG(WARNING,getLogDomain(),logTr("Imports are currently not supported."),this);
2062 }
2063 }
2064
2065 void CXMLOWL2StreamHandler::jumpFunctionUnsupportedAnnotationNode(const QXmlStreamAttributes& attributes) {
2066 mIgnoreParsingSubElements = true;
2067 mParseIgnoreDepth = mStack.count();
2068 if (!mUnsupportedAnnotationError) {
2069 mUnsupportedAnnotationError = true;
2070 LOG(WARNING,getLogDomain(),logTr("Annotations are currently not handled."),this);
2071 }
2072 }
2073
2074 }; // end namespace Parser
2075
2076 }; // end namespace Konclude