/*
* Copyright (C) 2013-2015, 2019 by the Konclude Developer Team.
*
* This file is part of the reasoning system Konclude.
* For details and support, see .
*
* Konclude is free software: you can redistribute it and/or modify
* it under the terms of version 3 of the GNU Lesser General Public
* License (LGPLv3) as published by the Free Software Foundation.
*
* Konclude is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU (Lesser) General Public License for more details.
*
* You should have received a copy of the GNU (Lesser) General Public
* License along with Konclude. If not, see .
*
*/
#include "CXMLOWL2StreamHandler.h"
namespace Konclude {
namespace Parser {
CXMLOWL2StreamHandler::CXMLOWL2StreamHandler(COntologyBuilder* ontoBuilder)
: CLogIdentifier("::Konclude::Parser::OWL2QtXMLStreamOntologyParser",this),recordRouter(0,this) {
mOntoBuilder = ontoBuilder;
mAxiomNumber = 0;
mHasCurrentXMLBase = false;
mIgnoreParsingSubElements = false;
mParseIgnoreDepth = 0;
mCurrentXMLBaseValidDepth = 0;
mCurrentXMLNamespaceValidDepth = 0;
mDataTypeReportErrorCount = 100;
mAnnotationReportErrorCount = 100;
mUnsupportedAnnotationError = false;
mUnsupportedImportError = false;
mOntologyNodeFound = false;
mParseTextElement = false;
mPunctChar = QChar('.');
mDoublePunctChar = QChar(':');
initializeParseFunctionJumpHash();
LOG(INFO,getLogDomain(),logTr("OWL 2 XML Qt stream parser initialized."),this);
}
CXMLOWL2StreamHandler::CXMLOWL2StreamHandler(COntologyBuilder* ontoBuilder, CCommandRecordRouter *commandRecordRouter)
: CLogIdentifier("::Konclude::Parser::OWL2QtXMLStreamOntologyParser",this),recordRouter(*commandRecordRouter,this) {
mOntoBuilder = ontoBuilder;
mAxiomNumber = 0;
mHasCurrentXMLBase = false;
mIgnoreParsingSubElements = false;
mParseIgnoreDepth = 0;
mCurrentXMLBaseValidDepth = 0;
mCurrentXMLNamespaceValidDepth = 0;
mDataTypeReportErrorCount = 100;
mAnnotationReportErrorCount = 100;
mUnsupportedAnnotationError = false;
mUnsupportedImportError = false;
mOntologyNodeFound = false;
mParseTextElement = false;
mPunctChar = QChar('.');
mDoublePunctChar = QChar(':');
initializeParseFunctionJumpHash();
LOG(INFO,getLogDomain(),logTr("OWL 2 XML Qt stream parser initialized."),this);
}
bool CXMLOWL2StreamHandler::parseXMLAttributs(const QXmlStreamAttributes& atts) {
QStringRef xmlBaseStringRef(atts.value(baseAttributeNamespace, baseAttributeName));
if (!xmlBaseStringRef.isEmpty()) {
if (mHasCurrentXMLBase) {
mXMLBaseStack.push(CStreamXMLBaseStackObject(mCurrentXMLBaseValidDepth,mCurrentXMLBase));
}
mCurrentXMLBase = xmlBaseStringRef.toString();
mCurrentXMLBaseValidDepth = mStack.count();
mHasCurrentXMLBase = true;
}
QStringRef xmlNamespaceStringRef(atts.value(xmlnsAttributeNamespace, xmlnsAttributeName));
if (!xmlNamespaceStringRef.isEmpty()) {
QHash newOWLNamespaceHash;
if (!newOWLNamespaceHash.isEmpty()) {
CQtHash* newParseHash = new CQtHash(*mCurrentParseFunctionJumpHash);
for (QHash::const_iterator it = newOWLNamespaceHash.constBegin(), itEnd = newOWLNamespaceHash.constEnd(); it != itEnd; ++it) {
const QString& abbreviationString(it.key());
bool abbreviationAdded(it.value());
if (abbreviationAdded) {
extendParsingHashForNamespace(&mBaseParseFunctionJumpHash,newParseHash,abbreviationString);
} else {
reduceParsingHashForNamespace(&mBaseParseFunctionJumpHash,newParseHash,abbreviationString);
}
}
mXMLNamespaceStack.push(CStreamXMLNamespaceStackObject(mCurrentXMLNamespaceValidDepth,newParseHash));
mCurrentParseFunctionJumpHash = newParseHash;
}
mCurrentXMLNamespaceValidDepth = mStack.count();
}
return true;
}
bool CXMLOWL2StreamHandler::startElement(const QStringRef& namespaceURI, const QStringRef& localName, const QStringRef& qName, const QXmlStreamAttributes& atts) {
mParseTextElement = false;
if (mIgnoreParsingSubElements) {
mStack.push(&mDummyFunctionData);
} else {
parseXMLAttributs(atts);
const CStreamParseFunctionData& functionData = mCurrentParseFunctionJumpHash->value(qName);
if (functionData.mParseDirectFunction) {
StreamParseFunctionDirect function = functionData.mParseDirectFunction;
(this->*function)(atts);
if (!mStack.isEmpty() && !mTmpExpList.isEmpty()) {
CStreamParseStackObject* topParsStackObj = mStack.top();
topParsStackObj->addBuildExpressions(&mTmpExpList);
}
mStack.push(&mDummyFunctionData);
} else if (functionData.mParseDelayedFunction) {
StreamParseFunctionDelayed function = functionData.mParseDelayedFunction;
bool requiredCardinality = functionData.mExtraParsingFlags & CStreamParseFunctionData::EPF_CARDINALITY;
bool requiredDatatypeIRI = functionData.mExtraParsingFlags & CStreamParseFunctionData::EPF_DATATYPE_IRI;
bool requiredFacetIRI = functionData.mExtraParsingFlags & CStreamParseFunctionData::EPF_FACET_IRI;
mParseTextElement = functionData.mExtraParsingFlags & CStreamParseFunctionData::EPF_TEXT_ELEMENT;
if (requiredCardinality) {
cint64 cardinality = 0;
bool cardinalityParsed = getCardinality(&cardinality,atts);
mStack.push(new CStreamParseStackObject(function,cardinality));
} else if (requiredDatatypeIRI) {
QString datatypeIRI;
bool datatypeParsed = getDatatypeIRI(&datatypeIRI,atts);
bool appendixParsed = getLiteralAppendix(&mLastTextAppendix,atts);
mParseTextElement = true;
mStack.push(new CStreamParseStackObject(function,datatypeIRI));
} else if (requiredFacetIRI) {
QString facetIRI;
bool facetParsed = getFacetIRI(&facetIRI,atts);
mStack.push(new CStreamParseStackObject(function,facetIRI));
} else {
mStack.push(new CStreamParseStackObject(function));
}
} else {
mStack.push(&mDummyFunctionData);
}
}
return true;
}
bool CXMLOWL2StreamHandler::endElement(const QStringRef& namespaceURI, const QStringRef& localName, const QStringRef& qName) {
if (!mStack.isEmpty()) {
CStreamParseStackObject* parseStackObject = mStack.pop();
if (mIgnoreParsingSubElements && mStack.count() <= mParseIgnoreDepth) {
mIgnoreParsingSubElements = false;
mParseIgnoreDepth = 0;
} else {
if (parseStackObject != &mDummyFunctionData) {
StreamParseFunctionDelayed function = parseStackObject->mParseFunction;
if (function) {
(this->*function)(parseStackObject);
if (!mStack.isEmpty() && !mTmpExpList.isEmpty()) {
CStreamParseStackObject* topParsStackObj = mStack.top();
topParsStackObj->addBuildExpressions(&mTmpExpList);
}
}
delete parseStackObject;
}
}
}
mTmpExpList.clear();
mLastReadText.clear();
mLastTextAppendix.clear();
if (mHasCurrentXMLBase) {
if (mStack.count() <= mCurrentXMLBaseValidDepth) {
if (mXMLBaseStack.isEmpty()) {
mHasCurrentXMLBase = false;
} else {
CStreamXMLBaseStackObject prevXMLBaseObject = mXMLBaseStack.pop();
mCurrentXMLBase = prevXMLBaseObject.mXMLBaseString;
mCurrentXMLBaseValidDepth = prevXMLBaseObject.mStackValidDepth;
}
}
}
if (mStack.count() <= mCurrentXMLNamespaceValidDepth) {
if (mXMLNamespaceStack.isEmpty()) {
mCurrentParseFunctionJumpHash = &mBaseParseFunctionJumpHash;
} else {
CStreamXMLNamespaceStackObject prevXMLNSObject = mXMLNamespaceStack.pop();
mCurrentParseFunctionJumpHash = prevXMLNSObject.mParseHash;
mCurrentXMLNamespaceValidDepth = prevXMLNSObject.mStackValidDepth;
}
}
return true;
}
bool CXMLOWL2StreamHandler::readText(const QStringRef& text) {
if (mParseTextElement) {
mLastReadText = text.toString();
}
return true;
}
bool CXMLOWL2StreamHandler::startDocument() {
mStack.push(&mDummyFunctionData);
return true;
}
bool CXMLOWL2StreamHandler::endDocument() {
if (mStack.count() > 0) {
CStreamParseStackObject* parseStackObject = mStack.pop();
parseTellOntologyAxiomNode(parseStackObject);
delete parseStackObject;
}
return true;
}
void CXMLOWL2StreamHandler::parseTellOntologyAxiomNode(CStreamParseStackObject* parseStackObj) {
if (mOntoBuilder && parseStackObj->hasExpressions()) {
QList* expList = parseStackObj->getExpressions();
for (QList::const_iterator it = expList->constBegin(), itEnd = expList->constEnd(); it != itEnd; ++it) {
CAxiomExpression* axiomExpression = dynamic_cast(*it);
if (axiomExpression) {
mOntoBuilder->tellOntologyAxiom(axiomExpression);
}
}
}
}
void CXMLOWL2StreamHandler::parseRetractOntologyAxiomNode(CStreamParseStackObject* parseStackObj) {
if (mOntoBuilder && parseStackObj->hasExpressions()) {
QList* expList = parseStackObj->getExpressions();
for (QList::const_iterator it = expList->constBegin(), itEnd = expList->constEnd(); it != itEnd; ++it) {
CAxiomExpression* axiomExpression = dynamic_cast(*it);
if (axiomExpression) {
mOntoBuilder->retractOntologyAxiom(axiomExpression);
}
}
}
}
void CXMLOWL2StreamHandler::parsePrefixNode(const QXmlStreamAttributes& attributes) {
QStringRef abbName = attributes.value(mNameString);
QStringRef totalIRIName = attributes.value(mIRIString);
if (abbName.isEmpty()) {
abbName = attributes.value(mOWLPrefixNameString);
}
if (totalIRIName.isEmpty()) {
totalIRIName = attributes.value(mOWLPrefixIRIString);
}
if (!totalIRIName.isEmpty()) {
mOntoBuilder->addNameAbbreviation(totalIRIName.toString(),abbName.toString());
}
}
bool CXMLOWL2StreamHandler::startsWithScheme(const QStringRef& uriString) {
for (int i = 0; i < uriString.count()-1; ++i) {
const QChar& c = uriString.at(i);
if (!c.isLetterOrNumber() && c != mPunctChar) {
if (c == mDoublePunctChar) {
return i != 0;
}
return false;
}
}
return false;
}
CStringRefStringHasher CXMLOWL2StreamHandler::getEntityName(const QXmlStreamAttributes& attributes) {
CStringRefStringHasher entityName;
bool abbreviated = false;
QStringRef attrNameString;
attrNameString = attributes.value(mIRIString);
if (attrNameString.isEmpty()) {
attrNameString = attributes.value(mOWLPrefixIRIString);
}
if (attrNameString.isEmpty()) {
attrNameString = attributes.value(mAbbreviatedIRIString);
abbreviated = true;
}
if (attrNameString.isEmpty()) {
attrNameString = attributes.value(mOWLPrefixAbbreviatedIRIString);
abbreviated = true;
}
if (attrNameString.isEmpty()) {
attrNameString = attributes.value(mURIString);
}
if (attrNameString.isEmpty()) {
attrNameString = attributes.value(mOWLPrefixURIString);
}
if (attrNameString.isEmpty()) {
abbreviated = false;
}
if (abbreviated) {
entityName = CStringRefStringHasher(mOntoBuilder->resolveAbbreviationName(attrNameString));
} else {
if (mHasCurrentXMLBase) {
if (!startsWithScheme(attrNameString)) {
entityName = CStringRefStringHasher(mCurrentXMLBase+attrNameString.toString());
}
}
if (entityName.isEmpty()) {
entityName = CStringRefStringHasher(attrNameString);
}
}
return entityName;
}
bool CXMLOWL2StreamHandler::getLiteralAppendix(QString* literalAppendix, const QXmlStreamAttributes& attributes) {
QStringRef literalAppendixString;
literalAppendixString = attributes.value("lang");
if (literalAppendixString.isEmpty()) {
literalAppendixString = attributes.value("xml:lang");
}
if (literalAppendix) {
*literalAppendix = literalAppendixString.toString();
}
return !literalAppendixString.isEmpty();
}
bool CXMLOWL2StreamHandler::getDatatypeIRI(QString* datatypeIRI, const QXmlStreamAttributes& attributes) {
QStringRef datatypeIRIString;
datatypeIRIString = attributes.value(mDatatypeIRIString);
if (datatypeIRIString.isEmpty()) {
datatypeIRIString = attributes.value(mOWLPrefixDatatypeIRIString);
}
if (datatypeIRI) {
*datatypeIRI = datatypeIRIString.toString();
}
return !datatypeIRIString.isEmpty();
}
bool CXMLOWL2StreamHandler::getFacetIRI(QString* facetIRI, const QXmlStreamAttributes& attributes) {
QStringRef facetIRIString;
facetIRIString = attributes.value(mFacetIRIString);
if (facetIRIString.isEmpty()) {
facetIRIString = attributes.value(mOWLPrefixFacetIRIString);
}
if (facetIRI) {
*facetIRI = facetIRIString.toString();
}
return !facetIRIString.isEmpty();
}
bool CXMLOWL2StreamHandler::getCardinality(cint64* cardinality, const QXmlStreamAttributes& attributes) {
QStringRef cardinalityString;
cardinalityString = attributes.value(mCardinalityString);
if (cardinalityString.isEmpty()) {
cardinalityString = attributes.value(mOWLPrefixCardinalityString);
}
if (!cardinalityString.isEmpty()) {
bool succParsed = false;
*cardinality = cardinalityString.toString().toLongLong(&succParsed);
return succParsed;
}
return false;
}
QStringRef CXMLOWL2StreamHandler::getNodeID(const QXmlStreamAttributes& attributes) {
QStringRef nodeIDString;
nodeIDString = attributes.value(mNodeIDString);
if (nodeIDString.isEmpty()) {
nodeIDString = attributes.value(mOWLPrefixNodeIDString);
}
return nodeIDString;
}
bool CXMLOWL2StreamHandler::extendParsingHashForNamespace(CQtHash* baseParseFunctionJumpHash, CQtHash* extendParseFunctionJumpHash, const QString& namespaceExtendString) {
bool extendHash = false;
for (CQtHash::const_iterator it = baseParseFunctionJumpHash->constBegin(), itEnd = baseParseFunctionJumpHash->constEnd(); it != itEnd; ++it) {
const CStringRefStringHasher& stringRefStringHasher(it.key());
const CStreamParseFunctionData& streamParseFunctionData(it.value());
const QString& keyParseString = stringRefStringHasher.getString();
QString extendedKeyParseString = namespaceExtendString+keyParseString;
extendParseFunctionJumpHash->insert(CStringRefStringHasher(extendedKeyParseString),streamParseFunctionData);
extendHash = true;
}
return extendHash;
}
bool CXMLOWL2StreamHandler::reduceParsingHashForNamespace(CQtHash* baseParseFunctionJumpHash, CQtHash* reduceParseFunctionJumpHash, const QString& namespaceReduceString) {
bool reducedHash = false;
for (CQtHash::const_iterator it = baseParseFunctionJumpHash->constBegin(), itEnd = baseParseFunctionJumpHash->constEnd(); it != itEnd; ++it) {
const CStringRefStringHasher& stringRefStringHasher(it.key());
const CStreamParseFunctionData& streamParseFunctionData(it.value());
const QString& keyParseString = stringRefStringHasher.getString();
QString reduceKeyParseString = namespaceReduceString+keyParseString;
reduceParseFunctionJumpHash->insert(CStringRefStringHasher(reduceKeyParseString),CStreamParseFunctionData(&CXMLOWL2StreamHandler::jumpFunctionParseIgnoredNode));
reducedHash = true;
}
return reducedHash;
}
bool CXMLOWL2StreamHandler::initializeParseFunctionJumpHash() {
mOWLString = QString("http://www.w3.org/2002/07/owl#");
mOWLPrefixString = QString("owl");
mURIString = QString("URI");
mOWLPrefixURIString = mOWLPrefixString+QString(":")+mURIString;
mIRIString = QString("IRI");
mOWLPrefixIRIString = mOWLPrefixString+QString(":")+mIRIString;
mAbbreviatedIRIString = QString("abbreviatedIRI");
mOWLPrefixAbbreviatedIRIString = mOWLPrefixString+QString(":")+mAbbreviatedIRIString;
mCardinalityString = QString("cardinality");
mOWLPrefixCardinalityString = mOWLPrefixString+QString(":")+mCardinalityString;
mDatatypeIRIString = QString("datatypeIRI");
mOWLPrefixDatatypeIRIString = mOWLPrefixString+QString(":")+mDatatypeIRIString;
mFacetIRIString = QString("facet");
mOWLPrefixFacetIRIString = mOWLPrefixString+QString(":")+mFacetIRIString;
mNodeIDString = QString("nodeID");
mOWLPrefixNodeIDString = mOWLPrefixString+QString(":")+mNodeIDString;
mNameString = QString("name");
mOWLPrefixNameString = mOWLPrefixString+QString(":")+mNameString;
mBaseParseFunctionJumpHash.insert(CStringRefStringHasher("Prefix"),CStreamParseFunctionData(&CXMLOWL2StreamHandler::jumpFunctionParsePrefixNode));
mBaseParseFunctionJumpHash.insert(CStringRefStringHasher("Class"),CStreamParseFunctionData(&CXMLOWL2StreamHandler::jumpFunctionParseClassNode));
mBaseParseFunctionJumpHash.insert(CStringRefStringHasher("OWLClass"),CStreamParseFunctionData(&CXMLOWL2StreamHandler::jumpFunctionParseClassNode));
mBaseParseFunctionJumpHash.insert(CStringRefStringHasher("ObjectProperty"),CStreamParseFunctionData(&CXMLOWL2StreamHandler::jumpFunctionParseObjectPropertyNode));
mBaseParseFunctionJumpHash.insert(CStringRefStringHasher("IndividualVariable"),CStreamParseFunctionData(&CXMLOWL2StreamHandler::jumpFunctionParseIndividualVariable));
mBaseParseFunctionJumpHash.insert(CStringRefStringHasher("Variable"),CStreamParseFunctionData(&CXMLOWL2StreamHandler::jumpFunctionParseIndividualVariable));
mBaseParseFunctionJumpHash.insert(CStringRefStringHasher("Declaration"),CStreamParseFunctionData(&CXMLOWL2StreamHandler::jumpFunctionParseDeclarationNode));
mBaseParseFunctionJumpHash.insert(CStringRefStringHasher("SubClassOf"),CStreamParseFunctionData(&CXMLOWL2StreamHandler::jumpFunctionParseSubClassOfNode));
mBaseParseFunctionJumpHash.insert(CStringRefStringHasher("EquivalentClasses"),CStreamParseFunctionData(&CXMLOWL2StreamHandler::jumpFunctionParseEquivalentClassesNode));
mBaseParseFunctionJumpHash.insert(CStringRefStringHasher("DisjointClasses"),CStreamParseFunctionData(&CXMLOWL2StreamHandler::jumpFunctionParseDisjontClassesNode));
mBaseParseFunctionJumpHash.insert(CStringRefStringHasher("DisjointUnion"),CStreamParseFunctionData(&CXMLOWL2StreamHandler::jumpFunctionParseDisjontUnionNode));
mBaseParseFunctionJumpHash.insert(CStringRefStringHasher("SubObjectPropertyOf"),CStreamParseFunctionData(&CXMLOWL2StreamHandler::jumpFunctionParseSubObjectPropertyOfNode));
mBaseParseFunctionJumpHash.insert(CStringRefStringHasher("ObjectPropertyChain"),CStreamParseFunctionData(&CXMLOWL2StreamHandler::jumpFunctionParseObjectPropertyChainNode));
mBaseParseFunctionJumpHash.insert(CStringRefStringHasher("EquivalentObjectProperties"),CStreamParseFunctionData(&CXMLOWL2StreamHandler::jumpFunctionParseEquivalentObjectPropertiesNode));
mBaseParseFunctionJumpHash.insert(CStringRefStringHasher("DisjointObjectProperties"),CStreamParseFunctionData(&CXMLOWL2StreamHandler::jumpFunctionParseDisjointObjectPropertiesNode));
mBaseParseFunctionJumpHash.insert(CStringRefStringHasher("ObjectInverseOf"),CStreamParseFunctionData(&CXMLOWL2StreamHandler::jumpFunctionParseInverseObjectPropertyOfNode));
mBaseParseFunctionJumpHash.insert(CStringRefStringHasher("InverseObjectProperties"),CStreamParseFunctionData(&CXMLOWL2StreamHandler::jumpFunctionParseInverseObjectPropertiesNode));
mBaseParseFunctionJumpHash.insert(CStringRefStringHasher("ObjectPropertyRange"),CStreamParseFunctionData(&CXMLOWL2StreamHandler::jumpFunctionParseObjectPropertyRangeNode));
mBaseParseFunctionJumpHash.insert(CStringRefStringHasher("ObjectPropertyDomain"),CStreamParseFunctionData(&CXMLOWL2StreamHandler::jumpFunctionParseObjectPropertyDomainNode));
mBaseParseFunctionJumpHash.insert(CStringRefStringHasher("TransitiveObjectProperty"),CStreamParseFunctionData(&CXMLOWL2StreamHandler::jumpFunctionParseTransetiveObjectPropertyNode));
mBaseParseFunctionJumpHash.insert(CStringRefStringHasher("FunctionalObjectProperty"),CStreamParseFunctionData(&CXMLOWL2StreamHandler::jumpFunctionParseFunctionalObjectPropertyNode));
mBaseParseFunctionJumpHash.insert(CStringRefStringHasher("SymmetricObjectProperty"),CStreamParseFunctionData(&CXMLOWL2StreamHandler::jumpFunctionParseSymmetricObjectPropertyNode));
mBaseParseFunctionJumpHash.insert(CStringRefStringHasher("AsymmetricObjectProperty"),CStreamParseFunctionData(&CXMLOWL2StreamHandler::jumpFunctionParseAsymmetricObjectPropertyNode));
mBaseParseFunctionJumpHash.insert(CStringRefStringHasher("ReflexiveObjectProperty"),CStreamParseFunctionData(&CXMLOWL2StreamHandler::jumpFunctionParseReflexiveObjectPropertyNode));
mBaseParseFunctionJumpHash.insert(CStringRefStringHasher("IrreflexiveObjectProperty"),CStreamParseFunctionData(&CXMLOWL2StreamHandler::jumpFunctionParseIrreflexiveObjectPropertyNode));
mBaseParseFunctionJumpHash.insert(CStringRefStringHasher("InverseFunctionalObjectProperty"),CStreamParseFunctionData(&CXMLOWL2StreamHandler::jumpFunctionParseInverseFunctionalObjectPropertyNode));
mBaseParseFunctionJumpHash.insert(CStringRefStringHasher("ObjectIntersectionOf"),CStreamParseFunctionData(&CXMLOWL2StreamHandler::jumpFunctionParseObjectIntersectionOfNode));
mBaseParseFunctionJumpHash.insert(CStringRefStringHasher("ObjectUnionOf"),CStreamParseFunctionData(&CXMLOWL2StreamHandler::jumpFunctionParseObjectUnionOfNode));
mBaseParseFunctionJumpHash.insert(CStringRefStringHasher("ObjectMaxCardinality"),CStreamParseFunctionData(&CXMLOWL2StreamHandler::jumpFunctionParseObjectMaxCardinalityNode,CStreamParseFunctionData::EPF_CARDINALITY));
mBaseParseFunctionJumpHash.insert(CStringRefStringHasher("ObjectMinCardinality"),CStreamParseFunctionData(&CXMLOWL2StreamHandler::jumpFunctionParseObjectMinCardinalityNode,CStreamParseFunctionData::EPF_CARDINALITY));
mBaseParseFunctionJumpHash.insert(CStringRefStringHasher("ObjectExactCardinality"),CStreamParseFunctionData(&CXMLOWL2StreamHandler::jumpFunctionParseObjectExactlyCardinalityNode,CStreamParseFunctionData::EPF_CARDINALITY));
mBaseParseFunctionJumpHash.insert(CStringRefStringHasher("ObjectSomeValuesFrom"),CStreamParseFunctionData(&CXMLOWL2StreamHandler::jumpFunctionParseObjectSomeValuesFromNode));
mBaseParseFunctionJumpHash.insert(CStringRefStringHasher("ObjectAllValuesFrom"),CStreamParseFunctionData(&CXMLOWL2StreamHandler::jumpFunctionParseObjectAllValuesFromNode));
mBaseParseFunctionJumpHash.insert(CStringRefStringHasher("ObjectComplementOf"),CStreamParseFunctionData(&CXMLOWL2StreamHandler::jumpFunctionParseObjectComplementOfNode));
mBaseParseFunctionJumpHash.insert(CStringRefStringHasher("ObjectOneOf"),CStreamParseFunctionData(&CXMLOWL2StreamHandler::jumpFunctionParseObjectOneOfNode));
mBaseParseFunctionJumpHash.insert(CStringRefStringHasher("ObjectHasValue"),CStreamParseFunctionData(&CXMLOWL2StreamHandler::jumpFunctionParseObjectHasValueNode));
mBaseParseFunctionJumpHash.insert(CStringRefStringHasher("ObjectHasSelf"),CStreamParseFunctionData(&CXMLOWL2StreamHandler::jumpFunctionParseObjectHasSelfNode));
mBaseParseFunctionJumpHash.insert(CStringRefStringHasher("NamedIndividual"),CStreamParseFunctionData(&CXMLOWL2StreamHandler::jumpFunctionParseNamedIndividualNode));
mBaseParseFunctionJumpHash.insert(CStringRefStringHasher("AnonymousIndividual"),CStreamParseFunctionData(&CXMLOWL2StreamHandler::jumpFunctionParseAnonymousIndividualNode));
mBaseParseFunctionJumpHash.insert(CStringRefStringHasher("ClassAssertion"),CStreamParseFunctionData(&CXMLOWL2StreamHandler::jumpFunctionParseClassAssertionNode));
mBaseParseFunctionJumpHash.insert(CStringRefStringHasher("ObjectPropertyAssertion"),CStreamParseFunctionData(&CXMLOWL2StreamHandler::jumpFunctionParseObjectPropertyAssertionNode));
mBaseParseFunctionJumpHash.insert(CStringRefStringHasher(mOWLPrefixString+":ObjectPropertyAssertion"),CStreamParseFunctionData(&CXMLOWL2StreamHandler::jumpFunctionParseObjectPropertyAssertionNode));
mBaseParseFunctionJumpHash.insert(CStringRefStringHasher("NegativeObjectPropertyAssertion"),CStreamParseFunctionData(&CXMLOWL2StreamHandler::jumpFunctionParseNegativeObjectPropertyAssertionNode));
mBaseParseFunctionJumpHash.insert(CStringRefStringHasher(mOWLPrefixString+":NegativeObjectPropertyAssertion"),CStreamParseFunctionData(&CXMLOWL2StreamHandler::jumpFunctionParseNegativeObjectPropertyAssertionNode));
mBaseParseFunctionJumpHash.insert(CStringRefStringHasher("SameIndividual"),CStreamParseFunctionData(&CXMLOWL2StreamHandler::jumpFunctionParseSameIndividualNode));
mBaseParseFunctionJumpHash.insert(CStringRefStringHasher(mOWLPrefixString+":SameIndividual"),CStreamParseFunctionData(&CXMLOWL2StreamHandler::jumpFunctionParseSameIndividualNode));
mBaseParseFunctionJumpHash.insert(CStringRefStringHasher("DifferentIndividuals"),CStreamParseFunctionData(&CXMLOWL2StreamHandler::jumpFunctionParseDifferentIndividualsNode));
mBaseParseFunctionJumpHash.insert(CStringRefStringHasher(mOWLPrefixString+":DifferentIndividuals"),CStreamParseFunctionData(&CXMLOWL2StreamHandler::jumpFunctionParseDifferentIndividualsNode));
mBaseParseFunctionJumpHash.insert(CStringRefStringHasher("#text"),CStreamParseFunctionData(&CXMLOWL2StreamHandler::jumpFunctionParseIgnoredNode));
mBaseParseFunctionJumpHash.insert(CStringRefStringHasher("#comment"),CStreamParseFunctionData(&CXMLOWL2StreamHandler::jumpFunctionParseIgnoredNode));
mBaseParseFunctionJumpHash.insert(CStringRefStringHasher("ExpectedResult"),CStreamParseFunctionData(&CXMLOWL2StreamHandler::jumpFunctionParseIgnoredNode));
mBaseParseFunctionJumpHash.insert(CStringRefStringHasher("Datatype"),CStreamParseFunctionData(&CXMLOWL2StreamHandler::jumpFunctionParseDatatypeNode));
mBaseParseFunctionJumpHash.insert(CStringRefStringHasher("DataSomeValuesFrom"),CStreamParseFunctionData(&CXMLOWL2StreamHandler::jumpFunctionParseDataSomeValuesFromNode));
mBaseParseFunctionJumpHash.insert(CStringRefStringHasher("Literal"),CStreamParseFunctionData(&CXMLOWL2StreamHandler::jumpFunctionParseDataLiteralNode,CStreamParseFunctionData::EPF_DATATYPE_IRI | CStreamParseFunctionData::EPF_LITERAL_APPENDIX | CStreamParseFunctionData::EPF_TEXT_ELEMENT));
mBaseParseFunctionJumpHash.insert(CStringRefStringHasher("DataProperty"),CStreamParseFunctionData(&CXMLOWL2StreamHandler::jumpFunctionParseDataPropertyNode));
mBaseParseFunctionJumpHash.insert(CStringRefStringHasher("DataAllValuesFrom"),CStreamParseFunctionData(&CXMLOWL2StreamHandler::jumpFunctionParseDataAllValuesFromNode));
mBaseParseFunctionJumpHash.insert(CStringRefStringHasher("DataHasValue"),CStreamParseFunctionData(&CXMLOWL2StreamHandler::jumpFunctionParseDataHasValueNode));
mBaseParseFunctionJumpHash.insert(CStringRefStringHasher("DataIntersectionOf"),CStreamParseFunctionData(&CXMLOWL2StreamHandler::jumpFunctionParseDataIntersectionOfNode));
mBaseParseFunctionJumpHash.insert(CStringRefStringHasher("DataOneOf"),CStreamParseFunctionData(&CXMLOWL2StreamHandler::jumpFunctionParseDataOneOfNode));
mBaseParseFunctionJumpHash.insert(CStringRefStringHasher("DataUnionOf"),CStreamParseFunctionData(&CXMLOWL2StreamHandler::jumpFunctionParseDataUnionOfNode));
mBaseParseFunctionJumpHash.insert(CStringRefStringHasher("DataComplementOf"),CStreamParseFunctionData(&CXMLOWL2StreamHandler::jumpFunctionParseDataComplementOfNode));
mBaseParseFunctionJumpHash.insert(CStringRefStringHasher("DatatypeRestriction"),CStreamParseFunctionData(&CXMLOWL2StreamHandler::jumpFunctionParseDatatypeRestrictionNode));
mBaseParseFunctionJumpHash.insert(CStringRefStringHasher("DataMinCardinality"),CStreamParseFunctionData(&CXMLOWL2StreamHandler::jumpFunctionParseDataMinCardinalityNode,CStreamParseFunctionData::EPF_CARDINALITY));
mBaseParseFunctionJumpHash.insert(CStringRefStringHasher("DataMaxCardinality"),CStreamParseFunctionData(&CXMLOWL2StreamHandler::jumpFunctionParseDataMaxCardinalityNode,CStreamParseFunctionData::EPF_CARDINALITY));
mBaseParseFunctionJumpHash.insert(CStringRefStringHasher("DataExactCardinality"),CStreamParseFunctionData(&CXMLOWL2StreamHandler::jumpFunctionParseDataExactCardinalityNode,CStreamParseFunctionData::EPF_CARDINALITY));
mBaseParseFunctionJumpHash.insert(CStringRefStringHasher("SubDataPropertyOf"),CStreamParseFunctionData(&CXMLOWL2StreamHandler::jumpFunctionParseSubDataPropertyOfNode));
mBaseParseFunctionJumpHash.insert(CStringRefStringHasher("EquivalentDataProperties"),CStreamParseFunctionData(&CXMLOWL2StreamHandler::jumpFunctionParseEquivalentDataPropertiesNode));
mBaseParseFunctionJumpHash.insert(CStringRefStringHasher("DisjointDataProperties"),CStreamParseFunctionData(&CXMLOWL2StreamHandler::jumpFunctionParseDisjointDataPropertiesNode));
mBaseParseFunctionJumpHash.insert(CStringRefStringHasher("DataPropertyDomain"),CStreamParseFunctionData(&CXMLOWL2StreamHandler::jumpFunctionParseDataPropertyDomainNode));
mBaseParseFunctionJumpHash.insert(CStringRefStringHasher("DataPropertyRange"),CStreamParseFunctionData(&CXMLOWL2StreamHandler::jumpFunctionParseDataPropertyRangeNode));
mBaseParseFunctionJumpHash.insert(CStringRefStringHasher("FunctionalDataProperty"),CStreamParseFunctionData(&CXMLOWL2StreamHandler::jumpFunctionParseFunctionalDataPropertyNode));
mBaseParseFunctionJumpHash.insert(CStringRefStringHasher("DataPropertyAssertion"),CStreamParseFunctionData(&CXMLOWL2StreamHandler::jumpFunctionParseDataPropertyAssertionNode));
mBaseParseFunctionJumpHash.insert(CStringRefStringHasher("NegativeDataPropertyAssertion"),CStreamParseFunctionData(&CXMLOWL2StreamHandler::jumpFunctionParseNegativeDataPropertyAssertionNode));
mBaseParseFunctionJumpHash.insert(CStringRefStringHasher("FacetRestriction"),CStreamParseFunctionData(&CXMLOWL2StreamHandler::jumpFunctionParseDataFacetRestrictionNode,CStreamParseFunctionData::EPF_FACET_IRI));
mBaseParseFunctionJumpHash.insert(CStringRefStringHasher("HasKey"),CStreamParseFunctionData(&CXMLOWL2StreamHandler::jumpFunctionUnsupportedDatatypeNode));
mBaseParseFunctionJumpHash.insert(CStringRefStringHasher("DatatypeDefinition"),CStreamParseFunctionData(&CXMLOWL2StreamHandler::jumpFunctionUnsupportedDatatypeNode));
mBaseParseFunctionJumpHash.insert(CStringRefStringHasher("Ontology"),CStreamParseFunctionData(&CXMLOWL2StreamHandler::jumpFunctionTellOntologyAxiomNode));
mBaseParseFunctionJumpHash.insert(CStringRefStringHasher("Tell"),CStreamParseFunctionData(&CXMLOWL2StreamHandler::jumpFunctionTellOntologyAxiomNode));
mBaseParseFunctionJumpHash.insert(CStringRefStringHasher("Whereby"),CStreamParseFunctionData(&CXMLOWL2StreamHandler::jumpFunctionTellOntologyAxiomNode));
mBaseParseFunctionJumpHash.insert(CStringRefStringHasher("Retract"),CStreamParseFunctionData(&CXMLOWL2StreamHandler::jumpFunctionRetractOntologyAxiomNode));
mBaseParseFunctionJumpHash.insert(CStringRefStringHasher("DLSafeRule"),CStreamParseFunctionData(&CXMLOWL2StreamHandler::jumpFunctionParseRuleNode));
mBaseParseFunctionJumpHash.insert(CStringRefStringHasher("Head"),CStreamParseFunctionData(&CXMLOWL2StreamHandler::jumpFunctionParseRuleAtomHeadNode));
mBaseParseFunctionJumpHash.insert(CStringRefStringHasher("Body"),CStreamParseFunctionData(&CXMLOWL2StreamHandler::jumpFunctionParseRuleAtomBodyNode));
mBaseParseFunctionJumpHash.insert(CStringRefStringHasher("ObjectPropertyAtom"), CStreamParseFunctionData(&CXMLOWL2StreamHandler::jumpFunctionParseRuleObjectPropertyAtomNode));
mBaseParseFunctionJumpHash.insert(CStringRefStringHasher("DataPropertyAtom"), CStreamParseFunctionData(&CXMLOWL2StreamHandler::jumpFunctionParseRuleDataPropertyAtomNode));
mBaseParseFunctionJumpHash.insert(CStringRefStringHasher("ClassAtom"),CStreamParseFunctionData(&CXMLOWL2StreamHandler::jumpFunctionParseRuleClassAtomNode));
mBaseParseFunctionJumpHash.insert(CStringRefStringHasher("DifferentIndividualsAtom"),CStreamParseFunctionData(&CXMLOWL2StreamHandler::jumpFunctionParseDifferentIndividualsAtomNode));
mBaseParseFunctionJumpHash.insert(CStringRefStringHasher("Import"),CStreamParseFunctionData(&CXMLOWL2StreamHandler::jumpFunctionParseImportNode,CStreamParseFunctionData::EPF_TEXT_ELEMENT));
mBaseParseFunctionJumpHash.insert(CStringRefStringHasher("AnnotationProperty"),CStreamParseFunctionData(&CXMLOWL2StreamHandler::jumpFunctionUnsupportedAnnotationNode));
mBaseParseFunctionJumpHash.insert(CStringRefStringHasher("AnnotationPropertyRange"),CStreamParseFunctionData(&CXMLOWL2StreamHandler::jumpFunctionUnsupportedAnnotationNode));
mBaseParseFunctionJumpHash.insert(CStringRefStringHasher("AnnotationPropertyDomain"),CStreamParseFunctionData(&CXMLOWL2StreamHandler::jumpFunctionUnsupportedAnnotationNode));
mBaseParseFunctionJumpHash.insert(CStringRefStringHasher("SubAnnotationPropertyOf"),CStreamParseFunctionData(&CXMLOWL2StreamHandler::jumpFunctionUnsupportedAnnotationNode));
mBaseParseFunctionJumpHash.insert(CStringRefStringHasher("AnnotationAssertion"),CStreamParseFunctionData(&CXMLOWL2StreamHandler::jumpFunctionUnsupportedAnnotationNode));
mBaseParseFunctionJumpHash.insert(CStringRefStringHasher("Annotation"),CStreamParseFunctionData(&CXMLOWL2StreamHandler::jumpFunctionUnsupportedAnnotationNode));
mBaseParseFunctionJumpHash.insert(CStringRefStringHasher("RDF"),CStreamParseFunctionData(&CXMLOWL2StreamHandler::jumpFunctionUnsupportedRDFNode));
mCurrentParseFunctionJumpHash = &mBaseParseFunctionJumpHash;
CQtHash* newParseHash = new CQtHash(*mCurrentParseFunctionJumpHash);
extendParsingHashForNamespace(&mBaseParseFunctionJumpHash,newParseHash,mOWLPrefix);
mCurrentParseFunctionJumpHash = newParseHash;
mCurrentParseFunctionJumpHash->insert(CStringRefStringHasher("rdf:RDF"),CStreamParseFunctionData(&CXMLOWL2StreamHandler::jumpFunctionUnsupportedRDFNode));
return true;
}
CRuleDifferentIndividualsAtomTermExpression* CXMLOWL2StreamHandler::parseRuleDifferentIndividualsAtomNode(CStreamParseStackObject* parseStackObj) {
CRuleDifferentIndividualsAtomTermExpression* ruleDiffIndAtomExp = nullptr;
if (parseStackObj->hasExpressions()) {
CParsingExpressionSplitter mParsingExpSpl(parseStackObj->getExpressions());
if (mParsingExpSpl.proofExpressionComposition(0,0,0,2,0)) {
ruleDiffIndAtomExp = new CRuleDifferentIndividualsAtomTermExpression(mParsingExpSpl.getFirstClassVariableTermExpression(),mParsingExpSpl.getSecondClassVariableTermExpression());
mRuleExpContainer.append(ruleDiffIndAtomExp);
}
}
return ruleDiffIndAtomExp;
}
CRuleAtomTermExpression* CXMLOWL2StreamHandler::parseRuleObjectPropertyAtomNode(CStreamParseStackObject* parseStackObj) {
CRuleAtomTermExpression* ruleAtomExp = nullptr;
if (parseStackObj->hasExpressions()) {
CParsingExpressionSplitter mParsingExpSpl(parseStackObj->getExpressions());
if (mParsingExpSpl.proofExpressionComposition(0,1,0,1,0)) {
if (mParsingExpSpl.getClassVariableTermExpressionList()->size() >= 2) {
ruleAtomExp = new CRulePropertyAtomTermExpression(mParsingExpSpl.getFirstClassVariableTermExpression(), mParsingExpSpl.getSecondClassVariableTermExpression(), mParsingExpSpl.getFirstObjectPropertyTermExpression());
} else if (!mParsingExpSpl.getIndividualTermExpressionList()->isEmpty()) {
ruleAtomExp = new CRuleClassAtomTermExpression(mOntoBuilder->getObjectHasValue(mParsingExpSpl.getFirstObjectPropertyTermExpression(), mParsingExpSpl.getFirstIndividualTermExpression()), mParsingExpSpl.getFirstClassVariableTermExpression());
} else {
LOG(ERROR, getLogDomain(), logTr("Parsing of possibly unsupported ObjectPropertyAtom failed."), this);
}
if (ruleAtomExp) {
mRuleExpContainer.append(ruleAtomExp);
}
}
}
return ruleAtomExp;
}
CRuleAtomTermExpression* CXMLOWL2StreamHandler::parseRuleDataPropertyAtomNode(CStreamParseStackObject* parseStackObj) {
CRuleClassAtomTermExpression* ruleClassAtomExp = nullptr;
if (parseStackObj->hasExpressions()) {
CParsingExpressionSplitter mParsingExpSpl(parseStackObj->getExpressions());
if (mParsingExpSpl.proofExpressionComposition(0, 0, 0, 1, 0, 1)) {
if (!mParsingExpSpl.getDataRangeTermExpressionList()->isEmpty()) {
ruleClassAtomExp = new CRuleClassAtomTermExpression(mOntoBuilder->getDataSomeValuesFrom(mParsingExpSpl.getFirstDataPropertyTermExpression(), mParsingExpSpl.getFirstDataRangeTermExpression()), mParsingExpSpl.getFirstClassVariableTermExpression());
} else if (!mParsingExpSpl.getDataLiteralTermExpressionList()->isEmpty()) {
ruleClassAtomExp = new CRuleClassAtomTermExpression(mOntoBuilder->getDataHasValue(mParsingExpSpl.getFirstDataPropertyTermExpression(), mParsingExpSpl.getFirstDataLiteralTermExpression()), mParsingExpSpl.getFirstClassVariableTermExpression());
} else {
LOG(ERROR, getLogDomain(), logTr("Parsing of possibly unsupported DataPropertyAtom failed."), this);
}
if (ruleClassAtomExp) {
mRuleExpContainer.append(ruleClassAtomExp);
}
}
}
return ruleClassAtomExp;
}
CRuleClassAtomTermExpression* CXMLOWL2StreamHandler::parseRuleClassAtomNode(CStreamParseStackObject* parseStackObj) {
CRuleClassAtomTermExpression* ruleClassAtomExp = nullptr;
if (parseStackObj->hasExpressions()) {
CParsingExpressionSplitter mParsingExpSpl(parseStackObj->getExpressions());
if (mParsingExpSpl.proofExpressionComposition(2,0,0,1,1)) {
ruleClassAtomExp = new CRuleClassAtomTermExpression(mParsingExpSpl.getFirstClassTermExpression(),mParsingExpSpl.getFirstClassVariableTermExpression());
mRuleExpContainer.append(ruleClassAtomExp);
}
}
return ruleClassAtomExp;
}
CRuleAtomListBodyExpression* CXMLOWL2StreamHandler::parseRuleAtomBodyNode(CStreamParseStackObject* parseStackObj) {
CRuleAtomListBodyExpression* ruleAtomBodyExp = nullptr;
if (parseStackObj->hasExpressions()) {
QList* expList = &parseStackObj->mExpList;
QList atomExpList;
for (QList::const_iterator it = expList->constBegin(), itEnd = expList->constEnd(); it != itEnd; ++it) {
CRuleAtomTermExpression* ruleAtTeExp = dynamic_cast(*it);
if (ruleAtTeExp) {
atomExpList.append(ruleAtTeExp);
}
}
if (!atomExpList.isEmpty()) {
ruleAtomBodyExp = new CRuleAtomListBodyExpression(atomExpList);
mRuleExpContainer.append(ruleAtomBodyExp);
}
}
return ruleAtomBodyExp;
}
CRuleAtomListHeadExpression* CXMLOWL2StreamHandler::parseRuleAtomHeadNode(CStreamParseStackObject* parseStackObj) {
CRuleAtomListHeadExpression* ruleAtomHeadExp = nullptr;
if (parseStackObj->hasExpressions()) {
QList* expList = &parseStackObj->mExpList;
QList atomExpList;
for (QList::const_iterator it = expList->constBegin(), itEnd = expList->constEnd(); it != itEnd; ++it) {
CRuleAtomTermExpression* ruleAtTeExp = dynamic_cast(*it);
if (ruleAtTeExp) {
atomExpList.append(ruleAtTeExp);
}
}
if (!atomExpList.isEmpty()) {
ruleAtomHeadExp = new CRuleAtomListHeadExpression(atomExpList);
mRuleExpContainer.append(ruleAtomHeadExp);
}
}
return ruleAtomHeadExp;
}
QHash CXMLOWL2StreamHandler::createVariableAtomHash(const QList& atomList) {
QHash variableAtomHash;
foreach (CParseRuleAtom* atom, atomList) {
if (!atom->mVariableName1.isEmpty()) {
variableAtomHash.insertMulti(atom->mVariableName1,atom);
}
if (!atom->mVariableName2.isEmpty()) {
variableAtomHash.insertMulti(atom->mVariableName2,atom);
}
}
return variableAtomHash;
}
QMap CXMLOWL2StreamHandler::createVariableCountMap(const QList& atomList) {
QHash variableCountHash;
foreach (CParseRuleAtom* atom, atomList) {
if (!atom->mVariableName1.isEmpty()) {
cint64 prevCount = variableCountHash.value(atom->mVariableName1,0);
variableCountHash.insert(atom->mVariableName1,prevCount+1);
}
if (!atom->mVariableName2.isEmpty()) {
cint64 prevCount = variableCountHash.value(atom->mVariableName2,0);
variableCountHash.insert(atom->mVariableName2,prevCount+1);
}
}
QMap countVariableMap;
for (QHash::const_iterator it = variableCountHash.constBegin(), itEnd = variableCountHash.constEnd(); it != itEnd; ++it) {
const QString& variableName = it.key();
cint64 variableAtomCount = it.value();
countVariableMap.insertMulti(variableAtomCount,variableName);
}
return countVariableMap;
}
QList CXMLOWL2StreamHandler::parseRuleAtomNodes(CStreamParseStackObject* parseStackObj, const CQtList& buildExpList, bool parseHeadAtoms) {
QList atomList;
for (CQtList::const_iterator it1 = buildExpList.constBegin(), it1End = buildExpList.constEnd(); it1 != it1End; ++it1) {
CRuleAtomListExpression* buildListExp = nullptr;
CRuleAtomListBodyExpression* buildBodyListExp = dynamic_cast(*it1);
CRuleAtomListHeadExpression* buildHeadListExp = dynamic_cast(*it1);
if (parseHeadAtoms) {
buildListExp = buildHeadListExp;
}
if (!parseHeadAtoms) {
buildListExp = buildBodyListExp;
}
if (buildListExp) {
CEXPRESSIONLIST* ruleAtomExpList = buildListExp->getRuleAtomTermExpressionList();
for (CEXPRESSIONLIST::const_iterator it2 = ruleAtomExpList->constBegin(), it2End = ruleAtomExpList->constEnd(); it2 != it2End; ++it2) {
CRuleAtomTermExpression* ruleAtomExp = *it2;
CParseRuleAtom* ruleAtom = nullptr;
if (ruleAtomExp->getType() == CBuildExpression::BETRULEPROPERTYATOM) {
CRulePropertyAtomTermExpression* rulePropertyAtomExp = (CRulePropertyAtomTermExpression*)ruleAtomExp;
CEXPRESSIONLIST* varList = rulePropertyAtomExp->getClassVariableTermExpressionList();
ruleAtom = new CParseRuleAtom(CParseRuleAtom::PROPERTYATOM);
ruleAtom->mVariableName1 = varList->first()->getName();
ruleAtom->mVariableName2 = varList->last()->getName();
ruleAtom->mAtomExpression = rulePropertyAtomExp->getObjectPropertyTermExpression();
atomList.append(ruleAtom);
} else if (ruleAtomExp->getType() == CBuildExpression::BETRULECLASSATOM) {
CRuleClassAtomTermExpression* ruleClassAtomExp = (CRuleClassAtomTermExpression*)ruleAtomExp;
ruleAtom = new CParseRuleAtom(CParseRuleAtom::CLASSATOM);
ruleAtom->mVariableName1 = ruleClassAtomExp->getClassVariableExpression()->getName();
ruleAtom->mAtomExpression = ruleClassAtomExp->getClassTermExpression();
atomList.append(ruleAtom);
} else if (ruleAtomExp->getType() == CBuildExpression::BETRULEDIFFERENTINDIVIDUALSATOM) {
CRuleDifferentIndividualsAtomTermExpression* diffIndAtomExp = (CRuleDifferentIndividualsAtomTermExpression*)ruleAtomExp;
ruleAtom = new CParseRuleAtom(CParseRuleAtom::DIFFERENTINDIVIDUALSATOM);
CEXPRESSIONLIST* varList = diffIndAtomExp->getClassVariableTermExpressionList();
ruleAtom->mVariableName1 = varList->first()->getName();
ruleAtom->mVariableName2 = varList->last()->getName();
atomList.append(ruleAtom);
}
}
}
}
return atomList;
}
void CXMLOWL2StreamHandler::parseRuleNode(CStreamParseStackObject* parseStackObj) {
if (parseStackObj->hasExpressions()) {
QList expressionList;
QHash bodyVariableAtomHash;
QHash headVariableAtomHash;
CQtList buildExpList(*parseStackObj->getExpressions());
QList bodyVariableAtomList = parseRuleAtomNodes(parseStackObj,buildExpList,false);
QList headVariableAtomList = parseRuleAtomNodes(parseStackObj,buildExpList,true);
bodyVariableAtomHash = createVariableAtomHash(bodyVariableAtomList);
headVariableAtomHash = createVariableAtomHash(headVariableAtomList);
QMap headCountVariableMap = createVariableCountMap(headVariableAtomList);
QSet headProcessedAtomSet;
QList reversHeadCountVariableList;
for (QMap::const_iterator it = headCountVariableMap.constBegin(), itEnd = headCountVariableMap.constEnd(); it != itEnd; ++it) {
const QString& varString = it.value();
reversHeadCountVariableList.prepend(varString);
}
for (QList::const_iterator it = reversHeadCountVariableList.constBegin(), itEnd = reversHeadCountVariableList.constEnd(); it != itEnd; ++it) {
const QString& varString = *it;
QSet processedBodyAtoms;
QList headAtomList = headVariableAtomHash.values(varString);
QList headExpressionList;
foreach (CParseRuleAtom* headAtom, headAtomList) {
if (!headProcessedAtomSet.contains(headAtom)) {
headProcessedAtomSet.insert(headAtom);
if (headAtom->mAtomType == CParseRuleAtom::PROPERTYATOM) {
bool inversed = false;
QString otherVarString = headAtom->getOtherVariable(varString,inversed);
CBuildExpression* otherVarExp = mOntoBuilder->getNominalIndividualVariable(otherVarString,mAxiomNumber);
CBuildExpression* someExp = mOntoBuilder->getObjectSomeValuesFrom(getNeighbourAtomObjectPropertyExpression(headAtom,inversed),otherVarExp);
headExpressionList.append(someExp);
} else if (headAtom->mAtomType == CParseRuleAtom::CLASSATOM) {
headExpressionList.append(headAtom->mAtomExpression);
} else if (headAtom->mAtomType == CParseRuleAtom::DIFFERENTINDIVIDUALSATOM) {
bool inversed = false;
QString otherVarString = headAtom->getOtherVariable(varString,inversed);
CBuildExpression* otherVarExp = mOntoBuilder->getNominalIndividualVariable(otherVarString,mAxiomNumber);
CBuildExpression* complExp = mOntoBuilder->getObjectComplementOf(otherVarExp);
headExpressionList.append(complExp);
}
}
}
if (!headExpressionList.isEmpty()) {
CBuildExpression* headExp = nullptr;
if (headExpressionList.count() >= 2) {
headExp = mOntoBuilder->getObjectIntersectionOf(headExpressionList);
} else {
headExp = headExpressionList.first();
}
CBuildExpression* bodyExp = createBodyExpresions(varString,bodyVariableAtomHash,headVariableAtomHash);
CBuildExpression* axiomExp = mOntoBuilder->getSubClassOf(bodyExp,headExp);
expressionList.append(axiomExp);
}
++mAxiomNumber;
}
addTemporaryBuildExpressions(&expressionList);
}
}
CBuildExpression* CXMLOWL2StreamHandler::createBodyExpresions(const QString& varString, QHash& bodyVariableAtomHash, QHash& headVariableAtomHash) {
QSet processedVarSet;
QSet processedAtomSet;
QList expList;
CBuildExpression* mainExp = createBodyExpresions(varString,true,bodyVariableAtomHash,processedVarSet,processedAtomSet,headVariableAtomHash);
expList.append(mainExp);
for (QHash::const_iterator it = bodyVariableAtomHash.constBegin(), itEnd = bodyVariableAtomHash.constEnd(); it != itEnd; ++it) {
QString nextVarString = it.key();
if (!processedVarSet.contains(nextVarString)) {
CBuildExpression* topPropExp = mOntoBuilder->getTopObjectProberty();
CBuildExpression* succExp = createBodyExpresions(nextVarString,true,bodyVariableAtomHash,processedVarSet,processedAtomSet,headVariableAtomHash);
CBuildExpression* someExp = mOntoBuilder->getObjectSomeValuesFrom(topPropExp,succExp);
expList.append(someExp);
}
}
if (expList.count() >= 2) {
return mOntoBuilder->getObjectIntersectionOf(expList);
}
return expList.first();
}
CBuildExpression* CXMLOWL2StreamHandler::getNeighbourAtomObjectPropertyExpression(CParseRuleAtom* ruleAtom, bool inversed) {
if (!inversed) {
return ruleAtom->mAtomExpression;
} else {
return mOntoBuilder->getInverseObjectPropertyOf(ruleAtom->mAtomExpression);
}
}
bool CXMLOWL2StreamHandler::hasBackExpressionLinks(const QString& varString, CParseRuleAtom* notRuleAtom, QHash& bodyVariableAtomHash, QSet& processedVarSet,
QSet& processedAtomSet, QHash& headVariableAtomHash) {
QSet backTestProcessedVarSet;
QSet backTestProcessedAtomSet;
return hasBackExpressionLinks(varString,notRuleAtom,bodyVariableAtomHash,processedVarSet,processedAtomSet,headVariableAtomHash,backTestProcessedVarSet,backTestProcessedAtomSet);
}
bool CXMLOWL2StreamHandler::hasBackExpressionLinks(const QString& varString, CParseRuleAtom* notRuleAtom, QHash& bodyVariableAtomHash, QSet& processedVarSet,
QSet& processedAtomSet, QHash& headVariableAtomHash, QSet& backTestProcessedVarSet, QSet& backTestProcessedAtomSet) {
if (processedVarSet.contains(varString)) {
return false;
}
if (!backTestProcessedVarSet.contains(varString)) {
backTestProcessedVarSet.insert(varString);
QList atomList = bodyVariableAtomHash.values(varString);
foreach (CParseRuleAtom* ruleAtom, atomList) {
if (ruleAtom->mAtomType == CParseRuleAtom::PROPERTYATOM) {
if (ruleAtom != notRuleAtom) {
if (processedAtomSet.contains(ruleAtom)) {
return true;
}
if (!backTestProcessedAtomSet.contains(ruleAtom)) {
backTestProcessedAtomSet.insert(ruleAtom);
bool inversed = false;
QString otherVarString = ruleAtom->getOtherVariable(varString,inversed);
if (hasBackExpressionLinks(otherVarString,ruleAtom,bodyVariableAtomHash,processedVarSet,processedAtomSet,headVariableAtomHash,backTestProcessedVarSet,backTestProcessedAtomSet)) {
return true;
}
}
}
}
}
}
return false;
}
CBuildExpression* CXMLOWL2StreamHandler::createBodyExpresions(const QString& varString, bool direct, QHash& bodyVariableAtomHash, QSet& processedVarSet, QSet& processedAtomSet, QHash& headVariableAtomHash) {
QList expList;
expList.append(mOntoBuilder->getNominalIndividualVariable(varString,mAxiomNumber));
if (!processedVarSet.contains(varString)) {
processedVarSet.insert(varString);
QList atomList = bodyVariableAtomHash.values(varString);
QList processList;
foreach (CParseRuleAtom* ruleAtom, atomList) {
if (ruleAtom->mAtomType == CParseRuleAtom::PROPERTYATOM) {
if (!processedAtomSet.contains(ruleAtom)) {
bool inversed = false;
QString otherVarString = ruleAtom->getOtherVariable(varString,inversed);
if (direct || !headVariableAtomHash.contains(varString) || !hasBackExpressionLinks(otherVarString,ruleAtom,bodyVariableAtomHash,processedVarSet,processedAtomSet,headVariableAtomHash)) {
processedAtomSet.insert(ruleAtom);
processList.append(ruleAtom);
}
}
} else if (ruleAtom->mAtomType == CParseRuleAtom::CLASSATOM) {
processList.append(ruleAtom);
} else if (ruleAtom->mAtomType == CParseRuleAtom::DIFFERENTINDIVIDUALSATOM) {
if (!processedAtomSet.contains(ruleAtom)) {
processedAtomSet.insert(ruleAtom);
processList.append(ruleAtom);
}
}
}
foreach (CParseRuleAtom* ruleAtom, processList) {
if (ruleAtom->mAtomType == CParseRuleAtom::PROPERTYATOM) {
bool inversed = false;
QString otherVarString = ruleAtom->getOtherVariable(varString,inversed);
CBuildExpression* succExp = createBodyExpresions(otherVarString,false,bodyVariableAtomHash,processedVarSet,processedAtomSet,headVariableAtomHash);
CBuildExpression* someExp = mOntoBuilder->getObjectSomeValuesFrom(getNeighbourAtomObjectPropertyExpression(ruleAtom,inversed),succExp);
expList.append(someExp);
} else if (ruleAtom->mAtomType == CParseRuleAtom::CLASSATOM) {
expList.append(ruleAtom->mAtomExpression);
} else if (ruleAtom->mAtomType == CParseRuleAtom::DIFFERENTINDIVIDUALSATOM) {
bool inversed = false;
QString otherVarString = ruleAtom->getOtherVariable(varString,inversed);
CBuildExpression* otherVarExp = mOntoBuilder->getNominalIndividualVariable(otherVarString,mAxiomNumber);
CBuildExpression* complExp = mOntoBuilder->getObjectComplementOf(otherVarExp);
expList.append(complExp);
}
}
}
if (expList.count() >= 2) {
return mOntoBuilder->getObjectIntersectionOf(expList);
}
return expList.first();
}
CDeclarationAxiomExpression* CXMLOWL2StreamHandler::parseDeclarationNode(CStreamParseStackObject* parseStackObj) {
CDeclarationAxiomExpression* declarationExpression = nullptr;
if (parseStackObj->hasExpressions()) {
declarationExpression = mOntoBuilder->getDeclaration(*parseStackObj->getExpressions());
++mAxiomNumber;
}
return declarationExpression;
}
CObjectPropertyExpression *CXMLOWL2StreamHandler::parseObjectPropertyNode(const QXmlStreamAttributes& attributes) {
const CStringRefStringHasher& probName = getEntityName(attributes);
CObjectPropertyExpression *objectExpression = 0;
if (!probName.isEmpty()) {
objectExpression = mOntoBuilder->getObjectProberty(probName.toStringRefernce());
}
return objectExpression;
}
CClassExpression *CXMLOWL2StreamHandler::parseClassNode(const QXmlStreamAttributes& attributes) {
const CStringRefStringHasher& className = getEntityName(attributes);
CClassExpression *classExpression = 0;
if (!className.isEmpty()) {
classExpression = mOntoBuilder->getClass(className.toStringRefernce());
}
return classExpression;
}
CObjectIndividualVariableExpression* CXMLOWL2StreamHandler::parseIndividualVariableNode(const QXmlStreamAttributes& attributes) {
const CStringRefStringHasher& indiVarName = getEntityName(attributes);
CObjectIndividualVariableExpression *indiVarExpression = 0;
if (!indiVarName.isEmpty()) {
indiVarExpression = mOntoBuilder->getNominalIndividualVariable(indiVarName.toStringRefernce(),mAxiomNumber);
}
return indiVarExpression;
}
CEquivalentClassesExpression *CXMLOWL2StreamHandler::parseEquivalentClassesNode(CStreamParseStackObject* parseStackObj) {
CEquivalentClassesExpression *ecExp = 0;
if (parseStackObj->hasExpressions()) {
ecExp = mOntoBuilder->getEquivalentClasses(*parseStackObj->getExpressions());
++mAxiomNumber;
}
return ecExp;
}
CSubClassOfExpression *CXMLOWL2StreamHandler::parseSubClassOfNode(CStreamParseStackObject* parseStackObj) {
CSubClassOfExpression *scoExp = 0;
if (parseStackObj->hasExpressions()) {
scoExp = mOntoBuilder->getSubClassOf(*parseStackObj->getExpressions());
++mAxiomNumber;
}
return scoExp;
}
CObjectPropertyDomainExpression *CXMLOWL2StreamHandler::parseObjectPropertyDomainNode(CStreamParseStackObject* parseStackObj) {
CObjectPropertyDomainExpression *obPrDoExp = 0;
if (parseStackObj->hasExpressions()) {
obPrDoExp = mOntoBuilder->getObjectPropertyDomainExpression(*parseStackObj->getExpressions());
++mAxiomNumber;
}
return obPrDoExp;
}
CObjectPropertyRangeExpression *CXMLOWL2StreamHandler::parseObjectPropertyRangeNode(CStreamParseStackObject* parseStackObj) {
CObjectPropertyRangeExpression *obPrRaExp = 0;
if (parseStackObj->hasExpressions()) {
obPrRaExp = mOntoBuilder->getObjectPropertyRangeExpression(*parseStackObj->getExpressions());
++mAxiomNumber;
}
return obPrRaExp;
}
CSubObjectPropertyOfExpression *CXMLOWL2StreamHandler::parseSubObjectPropertyOfNode(CStreamParseStackObject* parseStackObj) {
CSubObjectPropertyOfExpression *sopoExp = 0;
if (parseStackObj->hasExpressions()) {
sopoExp = mOntoBuilder->getSubObjectPropertyOf(*parseStackObj->getExpressions());
++mAxiomNumber;
}
return sopoExp;
}
CObjectPropertyChainExpression *CXMLOWL2StreamHandler::parseObjectPropertyChainNode(CStreamParseStackObject* parseStackObj) {
CObjectPropertyChainExpression *sopoExp = 0;
if (parseStackObj->hasExpressions()) {
sopoExp = mOntoBuilder->getObjectPropertyChain(*parseStackObj->getExpressions());
}
return sopoExp;
}
CEquivalentObjectPropertiesExpression *CXMLOWL2StreamHandler::parseEquivalentObjectPropertiesNode(CStreamParseStackObject* parseStackObj) {
CEquivalentObjectPropertiesExpression *sopoExp = 0;
if (parseStackObj->hasExpressions()) {
sopoExp = mOntoBuilder->getEquivalentObjectProperties(*parseStackObj->getExpressions());
++mAxiomNumber;
}
return sopoExp;
}
CDisjointObjectPropertiesExpression *CXMLOWL2StreamHandler::parseDisjointObjectPropertiesNode(CStreamParseStackObject* parseStackObj) {
CDisjointObjectPropertiesExpression *sopoExp = 0;
if (parseStackObj->hasExpressions()) {
sopoExp = mOntoBuilder->getDisjointObjectProperties(*parseStackObj->getExpressions());
++mAxiomNumber;
}
return sopoExp;
}
CInverseObjectPropertyOfExpression *CXMLOWL2StreamHandler::parseInverseObjectPropertyOfNode(CStreamParseStackObject* parseStackObj) {
CInverseObjectPropertyOfExpression *iopoExp = 0;
if (parseStackObj->hasExpressions()) {
iopoExp = mOntoBuilder->getInverseObjectPropertyOf(*parseStackObj->getExpressions());
}
return iopoExp;
}
CInverseObjectPropertiesExpression *CXMLOWL2StreamHandler::parseInverseObjectPropertiesNode(CStreamParseStackObject* parseStackObj) {
CInverseObjectPropertiesExpression *iopoExp = 0;
if (parseStackObj->hasExpressions()) {
iopoExp = mOntoBuilder->getInverseObjectProperties(*parseStackObj->getExpressions());
++mAxiomNumber;
}
return iopoExp;
}
CDisjointClassesExpression *CXMLOWL2StreamHandler::parseDisjontClassesNode(CStreamParseStackObject* parseStackObj) {
CDisjointClassesExpression *disClassExp = 0;
if (parseStackObj->hasExpressions()) {
disClassExp = mOntoBuilder->getDisjointClasses(*parseStackObj->getExpressions());
++mAxiomNumber;
}
return disClassExp;
}
CDisjointUnionExpression *CXMLOWL2StreamHandler::parseDisjontUnionNode(CStreamParseStackObject* parseStackObj) {
CDisjointUnionExpression *disClassExp = 0;
if (parseStackObj->hasExpressions()) {
disClassExp = mOntoBuilder->getDisjointUnion(*parseStackObj->getExpressions());
}
return disClassExp;
}
CObjectIntersectionOfExpression *CXMLOWL2StreamHandler::parseObjectIntersectionOfNode(CStreamParseStackObject* parseStackObj) {
CObjectIntersectionOfExpression *exp = 0;
if (parseStackObj->hasExpressions()) {
exp = mOntoBuilder->getObjectIntersectionOf(*parseStackObj->getExpressions());
}
return exp;
}
CObjectUnionOfExpression *CXMLOWL2StreamHandler::parseObjectUnionOfNode(CStreamParseStackObject* parseStackObj) {
CObjectUnionOfExpression *exp = 0;
if (parseStackObj->hasExpressions()) {
exp = mOntoBuilder->getObjectUnionOf(*parseStackObj->getExpressions());
}
return exp;
}
CObjectMaxCardinalityExpression *CXMLOWL2StreamHandler::parseObjectMaxCardinalityNode(CStreamParseStackObject* parseStackObj) {
cint64 cardinality = parseStackObj->mCardinality;
CObjectMaxCardinalityExpression *exp = 0;
if (parseStackObj->mCardinalityParsed) {
exp = mOntoBuilder->getObjectMaxCardinality(*parseStackObj->getExpressions(),cardinality);
}
return exp;
}
CObjectMinCardinalityExpression *CXMLOWL2StreamHandler::parseObjectMinCardinalityNode(CStreamParseStackObject* parseStackObj) {
cint64 cardinality = parseStackObj->mCardinality;
CObjectMinCardinalityExpression *exp = 0;
if (parseStackObj->mCardinalityParsed) {
exp = mOntoBuilder->getObjectMinCardinality(*parseStackObj->getExpressions(),cardinality);
}
return exp;
}
CObjectExactlyCardinalityExpression *CXMLOWL2StreamHandler::parseObjectExactlyCardinalityNode(CStreamParseStackObject* parseStackObj) {
cint64 cardinality = parseStackObj->mCardinality;
CObjectExactlyCardinalityExpression *exp = 0;
if (parseStackObj->mCardinalityParsed) {
exp = mOntoBuilder->getObjectExactlyCardinality(*parseStackObj->getExpressions(),cardinality);
}
return exp;
}
CObjectSomeValuesFromExpression *CXMLOWL2StreamHandler::parseObjectSomeValuesFromNode(CStreamParseStackObject* parseStackObj) {
CObjectSomeValuesFromExpression *exp = 0;
if (parseStackObj->hasExpressions()) {
exp = mOntoBuilder->getObjectSomeValuesFrom(*parseStackObj->getExpressions());
}
return exp;
}
CObjectHasValueExpression* CXMLOWL2StreamHandler::parseObjectHasValueNode(CStreamParseStackObject* parseStackObj) {
CObjectHasValueExpression *exp = 0;
if (parseStackObj->hasExpressions()) {
exp = mOntoBuilder->getObjectHasValue(*parseStackObj->getExpressions());
}
return exp;
}
CObjectHasSelfExpression* CXMLOWL2StreamHandler::parseObjectHasSelfNode(CStreamParseStackObject* parseStackObj) {
CObjectHasSelfExpression *exp = 0;
if (parseStackObj->hasExpressions()) {
exp = mOntoBuilder->getObjectHasSelf(*parseStackObj->getExpressions());
}
return exp;
}
CObjectAllValuesFromExpression *CXMLOWL2StreamHandler::parseObjectAllValuesFromNode(CStreamParseStackObject* parseStackObj) {
CObjectAllValuesFromExpression *exp = 0;
if (parseStackObj->hasExpressions()) {
exp = mOntoBuilder->getObjectAllValuesFrom(*parseStackObj->getExpressions());
}
return exp;
}
CObjectComplementOfExpression *CXMLOWL2StreamHandler::parseObjectComplementOfNode(CStreamParseStackObject* parseStackObj) {
CObjectComplementOfExpression *exp = 0;
if (parseStackObj->hasExpressions()) {
exp = mOntoBuilder->getObjectComplementOf(*parseStackObj->getExpressions());
}
return exp;
}
CObjectOneOfExpression *CXMLOWL2StreamHandler::parseObjectOneOfNode(CStreamParseStackObject* parseStackObj) {
CObjectOneOfExpression *exp = 0;
if (parseStackObj->hasExpressions()) {
exp = mOntoBuilder->getObjectOneOf(*parseStackObj->getExpressions());
}
return exp;
}
CTransetiveObjectPropertyExpression *CXMLOWL2StreamHandler::parseTransetiveObjectPropertyNode(CStreamParseStackObject* parseStackObj) {
CTransetiveObjectPropertyExpression *exp = 0;
if (parseStackObj->hasExpressions()) {
exp = mOntoBuilder->getTransetiveObjectProperty(*parseStackObj->getExpressions());
++mAxiomNumber;
}
return exp;
}
CFunctionalObjectPropertyExpression *CXMLOWL2StreamHandler::parseFunctionalObjectPropertyNode(CStreamParseStackObject* parseStackObj) {
CFunctionalObjectPropertyExpression *exp = 0;
if (parseStackObj->hasExpressions()) {
exp = mOntoBuilder->getFunctionalObjectProperty(*parseStackObj->getExpressions());
++mAxiomNumber;
}
return exp;
}
CSymmetricObjectPropertyExpression* CXMLOWL2StreamHandler::parseSymmetricObjectPropertyNode(CStreamParseStackObject* parseStackObj) {
CSymmetricObjectPropertyExpression *exp = 0;
if (parseStackObj->hasExpressions()) {
exp = mOntoBuilder->getSymmetricObjectProperty(*parseStackObj->getExpressions());
++mAxiomNumber;
}
return exp;
}
CAsymmetricObjectPropertyExpression* CXMLOWL2StreamHandler::parseAsymmetricObjectPropertyNode(CStreamParseStackObject* parseStackObj) {
CAsymmetricObjectPropertyExpression *exp = 0;
if (parseStackObj->hasExpressions()) {
exp = mOntoBuilder->getAsymmetricObjectProperty(*parseStackObj->getExpressions());
++mAxiomNumber;
}
return exp;
}
CReflexiveObjectPropertyExpression* CXMLOWL2StreamHandler::parseReflexiveObjectPropertyNode(CStreamParseStackObject* parseStackObj) {
CReflexiveObjectPropertyExpression *exp = 0;
if (parseStackObj->hasExpressions()) {
exp = mOntoBuilder->getReflexiveObjectProperty(*parseStackObj->getExpressions());
++mAxiomNumber;
}
return exp;
}
CIrreflexiveObjectPropertyExpression* CXMLOWL2StreamHandler::parseIrreflexiveObjectPropertyNode(CStreamParseStackObject* parseStackObj) {
CIrreflexiveObjectPropertyExpression *exp = 0;
if (parseStackObj->hasExpressions()) {
exp = mOntoBuilder->getIrreflexiveObjectProperty(*parseStackObj->getExpressions());
++mAxiomNumber;
}
return exp;
}
CInverseFunctionalObjectPropertyExpression* CXMLOWL2StreamHandler::parseInverseFunctionalObjectPropertyNode(CStreamParseStackObject* parseStackObj) {
CInverseFunctionalObjectPropertyExpression *exp = 0;
if (parseStackObj->hasExpressions()) {
exp = mOntoBuilder->getInverseFunctionalObjectProperty(*parseStackObj->getExpressions());
++mAxiomNumber;
}
return exp;
}
CClassAssertionExpression *CXMLOWL2StreamHandler::parseClassAssertionNode(CStreamParseStackObject* parseStackObj) {
CClassAssertionExpression *exp = 0;
if (parseStackObj->hasExpressions()) {
exp = mOntoBuilder->getClassAssertion(*parseStackObj->getExpressions());
++mAxiomNumber;
}
return exp;
}
CSameIndividualExpression *CXMLOWL2StreamHandler::parseSameIndividualNode(CStreamParseStackObject* parseStackObj) {
CSameIndividualExpression *exp = 0;
if (mOntoBuilder && parseStackObj->hasExpressions()) {
exp = mOntoBuilder->getSameIndividual(*parseStackObj->getExpressions());
++mAxiomNumber;
}
return exp;
}
CDifferentIndividualsExpression *CXMLOWL2StreamHandler::parseDifferentIndividualsNode(CStreamParseStackObject* parseStackObj) {
CDifferentIndividualsExpression *exp = 0;
if (mOntoBuilder && parseStackObj->hasExpressions()) {
exp = mOntoBuilder->getDifferentIndividuals(*parseStackObj->getExpressions());
++mAxiomNumber;
}
return exp;
}
CNamedIndividualExpression *CXMLOWL2StreamHandler::parseNamedIndividualNode(const QXmlStreamAttributes& attributes) {
const CStringRefStringHasher& indiNameName = getEntityName(attributes);
CNamedIndividualExpression *exp = 0;
if (!indiNameName.isEmpty()) {
if (mOntoBuilder) {
exp = mOntoBuilder->getNamedIndividual(indiNameName.toStringRefernce());
}
}
return exp;
}
CAnonymousIndividualExpression *CXMLOWL2StreamHandler::parseAnonymousIndividualNode(const QXmlStreamAttributes& attributes) {
if (mOntologyIdentifier.isEmpty()) {
mOntologyIdentifier = mOntoBuilder->getOntologyAnonymousIdentifier(mOntoBuilder->getOntologyName());
}
QStringRef indiNameName = getNodeID(attributes);
CAnonymousIndividualExpression *exp = 0;
if (!indiNameName.isEmpty()) {
if (mOntoBuilder) {
exp = mOntoBuilder->getAnonymousIndividual(QStringRef(&mOntologyIdentifier),indiNameName);
}
}
return exp;
}
CObjectPropertyAssertionExpression *CXMLOWL2StreamHandler::parseObjectPropertyAssertionNode(CStreamParseStackObject* parseStackObj) {
CObjectPropertyAssertionExpression *exp = 0;
if (mOntoBuilder && parseStackObj->hasExpressions()) {
exp = mOntoBuilder->getObjectPropertyAssertion(*parseStackObj->getExpressions());
++mAxiomNumber;
}
return exp;
}
CNegativeObjectPropertyAssertionExpression *CXMLOWL2StreamHandler::parseNegativeObjectPropertyAssertionNode(CStreamParseStackObject* parseStackObj) {
CNegativeObjectPropertyAssertionExpression *exp = 0;
if (mOntoBuilder && parseStackObj->hasExpressions()) {
exp = mOntoBuilder->getNegativeObjectPropertyAssertion(*parseStackObj->getExpressions());
++mAxiomNumber;
}
return exp;
}
CDatatypeExpression *CXMLOWL2StreamHandler::parseDatatypeNode(const QXmlStreamAttributes& attributes) {
const CStringRefStringHasher& datatypeIRIName = getEntityName(attributes);
CDatatypeExpression* exp = nullptr;
if (!datatypeIRIName.isEmpty()) {
if (mOntoBuilder) {
exp = mOntoBuilder->getDatatype(datatypeIRIName.toStringRefernce());
}
}
return exp;
}
CDataSomeValuesFromExpression *CXMLOWL2StreamHandler::parseDataSomeValuesFromNode(CStreamParseStackObject* parseStackObj) {
CDataSomeValuesFromExpression* exp = nullptr;
if (mOntoBuilder && parseStackObj->hasExpressions()) {
exp = mOntoBuilder->getDataSomeValuesFrom(*parseStackObj->getExpressions());
}
return exp;
}
CDataAllValuesFromExpression *CXMLOWL2StreamHandler::parseDataAllValuesFromNode(CStreamParseStackObject* parseStackObj) {
CDataAllValuesFromExpression* exp = nullptr;
if (mOntoBuilder && parseStackObj->hasExpressions()) {
exp = mOntoBuilder->getDataAllValuesFrom(*parseStackObj->getExpressions());
}
return exp;
}
CDataHasValueExpression *CXMLOWL2StreamHandler::parseDataHasValueNode(CStreamParseStackObject* parseStackObj) {
CDataHasValueExpression* exp = nullptr;
if (mOntoBuilder && parseStackObj->hasExpressions()) {
exp = mOntoBuilder->getDataHasValue(*parseStackObj->getExpressions());
}
return exp;
}
CDataIntersectionOfExpression *CXMLOWL2StreamHandler::parseDataIntersectionOfNode(CStreamParseStackObject* parseStackObj) {
CDataIntersectionOfExpression* exp = nullptr;
if (mOntoBuilder && parseStackObj->hasExpressions()) {
exp = mOntoBuilder->getDataIntersectionOf(*parseStackObj->getExpressions());
}
return exp;
}
CDataOneOfExpression *CXMLOWL2StreamHandler::parseDataOneOfNode(CStreamParseStackObject* parseStackObj) {
CDataOneOfExpression* exp = nullptr;
if (mOntoBuilder && parseStackObj->hasExpressions()) {
exp = mOntoBuilder->getDataOneOf(*parseStackObj->getExpressions());
}
return exp;
}
CDataUnionOfExpression *CXMLOWL2StreamHandler::parseDataUnionOfNode(CStreamParseStackObject* parseStackObj) {
CDataUnionOfExpression* exp = nullptr;
if (mOntoBuilder && parseStackObj->hasExpressions()) {
exp = mOntoBuilder->getDataUnionOf(*parseStackObj->getExpressions());
}
return exp;
}
CDataComplementOfExpression *CXMLOWL2StreamHandler::parseDataComplementOfNode(CStreamParseStackObject* parseStackObj) {
CDataComplementOfExpression* exp = nullptr;
if (mOntoBuilder && parseStackObj->hasExpressions()) {
exp = mOntoBuilder->getDataComplementOf(*parseStackObj->getExpressions());
}
return exp;
}
CDatatypeRestrictionExpression *CXMLOWL2StreamHandler::parseDatatypeRestrictionNode(CStreamParseStackObject* parseStackObj) {
CDatatypeRestrictionExpression* exp = nullptr;
if (mOntoBuilder && parseStackObj->hasExpressions()) {
exp = mOntoBuilder->getDatatypeRestriction(*parseStackObj->getExpressions());
}
return exp;
}
CDataMaxCardinalityExpression *CXMLOWL2StreamHandler::parseDataMaxCardinalityNode(CStreamParseStackObject* parseStackObj) {
CDataMaxCardinalityExpression* exp = nullptr;
if (mOntoBuilder && parseStackObj->hasExpressions() && parseStackObj->mCardinalityParsed) {
exp = mOntoBuilder->getDataMaxCardinality(*parseStackObj->getExpressions(),parseStackObj->mCardinality);
}
return exp;
}
CDataMinCardinalityExpression *CXMLOWL2StreamHandler::parseDataMinCardinalityNode(CStreamParseStackObject* parseStackObj) {
CDataMinCardinalityExpression* exp = nullptr;
if (mOntoBuilder && parseStackObj->hasExpressions() && parseStackObj->mCardinalityParsed) {
exp = mOntoBuilder->getDataMinCardinality(*parseStackObj->getExpressions(),parseStackObj->mCardinality);
}
return exp;
}
CDataExactCardinalityExpression *CXMLOWL2StreamHandler::parseDataExactCardinalityNode(CStreamParseStackObject* parseStackObj) {
CDataExactCardinalityExpression* exp = nullptr;
if (mOntoBuilder && parseStackObj->hasExpressions() && parseStackObj->mCardinalityParsed) {
exp = mOntoBuilder->getDataExactCardinality(*parseStackObj->getExpressions(),parseStackObj->mCardinality);
}
return exp;
}
CDataPropertyAssertionExpression *CXMLOWL2StreamHandler::parseDataPropertyAssertionNode(CStreamParseStackObject* parseStackObj) {
CDataPropertyAssertionExpression* exp = nullptr;
if (mOntoBuilder && parseStackObj->hasExpressions()) {
exp = mOntoBuilder->getDataPropertyAssertion(*parseStackObj->getExpressions());
}
return exp;
}
CNegativeDataPropertyAssertionExpression *CXMLOWL2StreamHandler::parseNegativeDataPropertyAssertionNode(CStreamParseStackObject* parseStackObj) {
CNegativeDataPropertyAssertionExpression* exp = nullptr;
if (mOntoBuilder && parseStackObj->hasExpressions()) {
exp = mOntoBuilder->getNegativeDataPropertyAssertion(*parseStackObj->getExpressions());
}
return exp;
}
CSubDataPropertyOfExpression *CXMLOWL2StreamHandler::parseSubDataPropertyOfNode(CStreamParseStackObject* parseStackObj) {
CSubDataPropertyOfExpression* exp = nullptr;
if (mOntoBuilder && parseStackObj->hasExpressions()) {
exp = mOntoBuilder->getSubDataPropertyOf(*parseStackObj->getExpressions());
}
return exp;
}
CEquivalentDataPropertiesExpression *CXMLOWL2StreamHandler::parseEquivalentDataPropertiesNode(CStreamParseStackObject* parseStackObj) {
CEquivalentDataPropertiesExpression* exp = nullptr;
if (mOntoBuilder && parseStackObj->hasExpressions()) {
exp = mOntoBuilder->getEquivalentDataProperties(*parseStackObj->getExpressions());
}
return exp;
}
CDisjointDataPropertiesExpression *CXMLOWL2StreamHandler::parseDisjointDataPropertiesNode(CStreamParseStackObject* parseStackObj) {
CDisjointDataPropertiesExpression* exp = nullptr;
if (mOntoBuilder && parseStackObj->hasExpressions()) {
exp = mOntoBuilder->getDisjointDataProperties(*parseStackObj->getExpressions());
}
return exp;
}
CDataPropertyDomainExpression *CXMLOWL2StreamHandler::parseDataPropertyDomainNode(CStreamParseStackObject* parseStackObj) {
CDataPropertyDomainExpression* exp = nullptr;
if (mOntoBuilder && parseStackObj->hasExpressions()) {
exp = mOntoBuilder->getDataPropertyDomainExpression(*parseStackObj->getExpressions());
}
return exp;
}
CDataPropertyRangeExpression *CXMLOWL2StreamHandler::parseDataPropertyRangeNode(CStreamParseStackObject* parseStackObj) {
CDataPropertyRangeExpression* exp = nullptr;
if (mOntoBuilder && parseStackObj->hasExpressions()) {
exp = mOntoBuilder->getDataPropertyRangeExpression(*parseStackObj->getExpressions());
}
return exp;
}
CFunctionalDataPropertyExpression *CXMLOWL2StreamHandler::parseFunctionalDataPropertyNode(CStreamParseStackObject* parseStackObj) {
CFunctionalDataPropertyExpression* exp = nullptr;
if (mOntoBuilder && parseStackObj->hasExpressions()) {
exp = mOntoBuilder->getFunctionalDataProperty(*parseStackObj->getExpressions());
}
return exp;
}
CDataFacetRestrictionExpression* CXMLOWL2StreamHandler::parseDataFacetRestrictionNode(CStreamParseStackObject* parseStackObj) {
CDataFacetRestrictionExpression* exp = nullptr;
if (mOntoBuilder && parseStackObj->hasExpressions()) {
CQtList expList(*parseStackObj->getExpressions());
CDataFacetExpression* dataFacetExp = mOntoBuilder->getDataFacet(parseStackObj->getParsedIRI());
expList.append(dataFacetExp);
exp = mOntoBuilder->getDataFacetRestriction(expList);
}
return exp;
}
CDataLiteralExpression *CXMLOWL2StreamHandler::parseDataLiteralNode(CStreamParseStackObject* parseStackObj) {
CDataLiteralExpression* exp = nullptr;
if (mOntoBuilder && parseStackObj->mIRIParsed) {
QString datatypeIRIString = parseStackObj->getParsedIRI();
if (datatypeIRIString.isEmpty()) {
datatypeIRIString = mDefaultDatatype;
}
CDatatypeExpression* datatypeExpression = mOntoBuilder->getDatatype(datatypeIRIString);
QString valueString = mLastReadText;
if (!mLastTextAppendix.isEmpty()) {
valueString = mLastReadText+"@"+mLastTextAppendix;
}
CDataLexicalValueExpression* dataLexicalValueExpression = mOntoBuilder->getDataLexicalValue(valueString);
exp = mOntoBuilder->getDataLiteral(dataLexicalValueExpression,datatypeExpression);
}
return exp;
}
CDataPropertyExpression *CXMLOWL2StreamHandler::parseDataPropertyNode(const QXmlStreamAttributes& attributes) {
const CStringRefStringHasher& probName = getEntityName(attributes);
CDataPropertyExpression *objectExpression = 0;
if (!probName.isEmpty()) {
objectExpression = mOntoBuilder->getDataProberty(probName.toStringRefernce());
}
return objectExpression;
}
void CXMLOWL2StreamHandler::jumpFunctionParseRuleNode(CStreamParseStackObject* parseStackObj) {
parseRuleNode(parseStackObj);
}
void CXMLOWL2StreamHandler::jumpFunctionParseRuleObjectPropertyAtomNode(CStreamParseStackObject* parseStackObj) {
addTemporaryBuildExpression(parseRuleObjectPropertyAtomNode(parseStackObj));
}
void CXMLOWL2StreamHandler::jumpFunctionParseRuleDataPropertyAtomNode(CStreamParseStackObject* parseStackObj) {
addTemporaryBuildExpression(parseRuleDataPropertyAtomNode(parseStackObj));
}
void CXMLOWL2StreamHandler::jumpFunctionParseRuleClassAtomNode(CStreamParseStackObject* parseStackObj) {
addTemporaryBuildExpression(parseRuleClassAtomNode(parseStackObj));
}
void CXMLOWL2StreamHandler::jumpFunctionParseDifferentIndividualsAtomNode(CStreamParseStackObject* parseStackObj) {
addTemporaryBuildExpression(parseRuleDifferentIndividualsAtomNode(parseStackObj));
}
void CXMLOWL2StreamHandler::jumpFunctionParseDataPropertyNode(const QXmlStreamAttributes& attributes) {
addTemporaryBuildExpression(parseDataPropertyNode(attributes));
}
void CXMLOWL2StreamHandler::jumpFunctionParseRuleAtomBodyNode(CStreamParseStackObject* parseStackObj) {
addTemporaryBuildExpression(parseRuleAtomBodyNode(parseStackObj));
}
void CXMLOWL2StreamHandler::jumpFunctionParseRuleAtomHeadNode(CStreamParseStackObject* parseStackObj) {
addTemporaryBuildExpression(parseRuleAtomHeadNode(parseStackObj));
}
bool CXMLOWL2StreamHandler::hasOntologyNodeFound() {
return mOntologyNodeFound;
}
void CXMLOWL2StreamHandler::jumpFunctionTellOntologyAxiomNode(CStreamParseStackObject* parseStackObj) {
mOntologyNodeFound = true;
parseTellOntologyAxiomNode(parseStackObj);
}
void CXMLOWL2StreamHandler::jumpFunctionRetractOntologyAxiomNode(CStreamParseStackObject* parseStackObj) {
parseRetractOntologyAxiomNode(parseStackObj);
}
void CXMLOWL2StreamHandler::jumpFunctionParsePrefixNode(const QXmlStreamAttributes& attributes) {
parsePrefixNode(attributes);
}
void CXMLOWL2StreamHandler::addTemporaryBuildExpression(CBuildExpression* buildExp) {
if (buildExp) {
mTmpExpList.append(buildExp);
}
}
void CXMLOWL2StreamHandler::addTemporaryBuildExpressions(QList* buildExps) {
if (buildExps) {
for (QList::const_iterator it = buildExps->constBegin(), itEnd = buildExps->constEnd(); it != itEnd; ++it) {
CBuildExpression* buildExp = *it;
if (buildExp) {
mTmpExpList.append(buildExp);
}
}
}
}
void CXMLOWL2StreamHandler::jumpFunctionParseClassNode(const QXmlStreamAttributes& attributes) {
addTemporaryBuildExpression(parseClassNode(attributes));
}
void CXMLOWL2StreamHandler::jumpFunctionParseObjectPropertyNode(const QXmlStreamAttributes& attributes) {
addTemporaryBuildExpression(parseObjectPropertyNode(attributes));
}
void CXMLOWL2StreamHandler::jumpFunctionParseIndividualVariable(const QXmlStreamAttributes& attributes) {
addTemporaryBuildExpression(parseIndividualVariableNode(attributes));
}
void CXMLOWL2StreamHandler::jumpFunctionParseDeclarationNode(CStreamParseStackObject* parseStackObj) {
addTemporaryBuildExpression(parseDeclarationNode(parseStackObj));
}
void CXMLOWL2StreamHandler::jumpFunctionParseEquivalentClassesNode(CStreamParseStackObject* parseStackObj) {
addTemporaryBuildExpression(parseEquivalentClassesNode(parseStackObj));
}
void CXMLOWL2StreamHandler::jumpFunctionParseSubClassOfNode(CStreamParseStackObject* parseStackObj) {
addTemporaryBuildExpression(parseSubClassOfNode(parseStackObj));
}
void CXMLOWL2StreamHandler::jumpFunctionParseDisjontClassesNode(CStreamParseStackObject* parseStackObj) {
addTemporaryBuildExpression(parseDisjontClassesNode(parseStackObj));
}
void CXMLOWL2StreamHandler::jumpFunctionParseDisjontUnionNode(CStreamParseStackObject* parseStackObj) {
addTemporaryBuildExpression(parseDisjontUnionNode(parseStackObj));
}
void CXMLOWL2StreamHandler::jumpFunctionParseSubObjectPropertyOfNode(CStreamParseStackObject* parseStackObj) {
addTemporaryBuildExpression(parseSubObjectPropertyOfNode(parseStackObj));
}
void CXMLOWL2StreamHandler::jumpFunctionParseObjectPropertyChainNode(CStreamParseStackObject* parseStackObj) {
addTemporaryBuildExpression(parseObjectPropertyChainNode(parseStackObj));
}
void CXMLOWL2StreamHandler::jumpFunctionParseEquivalentObjectPropertiesNode(CStreamParseStackObject* parseStackObj) {
addTemporaryBuildExpression(parseEquivalentObjectPropertiesNode(parseStackObj));
}
void CXMLOWL2StreamHandler::jumpFunctionParseDisjointObjectPropertiesNode(CStreamParseStackObject* parseStackObj) {
addTemporaryBuildExpression(parseDisjointObjectPropertiesNode(parseStackObj));
}
void CXMLOWL2StreamHandler::jumpFunctionParseObjectIntersectionOfNode(CStreamParseStackObject* parseStackObj) {
addTemporaryBuildExpression(parseObjectIntersectionOfNode(parseStackObj));
}
void CXMLOWL2StreamHandler::jumpFunctionParseObjectUnionOfNode(CStreamParseStackObject* parseStackObj) {
addTemporaryBuildExpression(parseObjectUnionOfNode(parseStackObj));
}
void CXMLOWL2StreamHandler::jumpFunctionParseObjectMaxCardinalityNode(CStreamParseStackObject* parseStackObj) {
addTemporaryBuildExpression(parseObjectMaxCardinalityNode(parseStackObj));
}
void CXMLOWL2StreamHandler::jumpFunctionParseObjectMinCardinalityNode(CStreamParseStackObject* parseStackObj) {
addTemporaryBuildExpression(parseObjectMinCardinalityNode(parseStackObj));
}
void CXMLOWL2StreamHandler::jumpFunctionParseObjectExactlyCardinalityNode(CStreamParseStackObject* parseStackObj) {
addTemporaryBuildExpression(parseObjectExactlyCardinalityNode(parseStackObj));
}
void CXMLOWL2StreamHandler::jumpFunctionParseObjectSomeValuesFromNode(CStreamParseStackObject* parseStackObj) {
addTemporaryBuildExpression(parseObjectSomeValuesFromNode(parseStackObj));
}
void CXMLOWL2StreamHandler::jumpFunctionParseObjectAllValuesFromNode(CStreamParseStackObject* parseStackObj) {
addTemporaryBuildExpression(parseObjectAllValuesFromNode(parseStackObj));
}
void CXMLOWL2StreamHandler::jumpFunctionParseObjectComplementOfNode(CStreamParseStackObject* parseStackObj) {
addTemporaryBuildExpression(parseObjectComplementOfNode(parseStackObj));
}
void CXMLOWL2StreamHandler::jumpFunctionParseObjectOneOfNode(CStreamParseStackObject* parseStackObj) {
addTemporaryBuildExpression(parseObjectOneOfNode(parseStackObj));
}
void CXMLOWL2StreamHandler::jumpFunctionParseObjectHasValueNode(CStreamParseStackObject* parseStackObj) {
addTemporaryBuildExpression(parseObjectHasValueNode(parseStackObj));
}
void CXMLOWL2StreamHandler::jumpFunctionParseObjectHasSelfNode(CStreamParseStackObject* parseStackObj) {
addTemporaryBuildExpression(parseObjectHasSelfNode(parseStackObj));
}
void CXMLOWL2StreamHandler::jumpFunctionParseClassAssertionNode(CStreamParseStackObject* parseStackObj) {
addTemporaryBuildExpression(parseClassAssertionNode(parseStackObj));
}
void CXMLOWL2StreamHandler::jumpFunctionParseNamedIndividualNode(const QXmlStreamAttributes& attributes) {
addTemporaryBuildExpression(parseNamedIndividualNode(attributes));
}
void CXMLOWL2StreamHandler::jumpFunctionParseDatatypeNode(const QXmlStreamAttributes& attributes) {
addTemporaryBuildExpression(parseDatatypeNode(attributes));
}
void CXMLOWL2StreamHandler::jumpFunctionParseDataSomeValuesFromNode(CStreamParseStackObject* parseStackObj) {
addTemporaryBuildExpression(parseDataSomeValuesFromNode(parseStackObj));
}
void CXMLOWL2StreamHandler::jumpFunctionParseDataAllValuesFromNode(CStreamParseStackObject* parseStackObj) {
addTemporaryBuildExpression(parseDataAllValuesFromNode(parseStackObj));
}
void CXMLOWL2StreamHandler::jumpFunctionParseDataHasValueNode(CStreamParseStackObject* parseStackObj) {
addTemporaryBuildExpression(parseDataHasValueNode(parseStackObj));
}
void CXMLOWL2StreamHandler::jumpFunctionParseDataIntersectionOfNode(CStreamParseStackObject* parseStackObj) {
addTemporaryBuildExpression(parseDataIntersectionOfNode(parseStackObj));
}
void CXMLOWL2StreamHandler::jumpFunctionParseDataOneOfNode(CStreamParseStackObject* parseStackObj) {
addTemporaryBuildExpression(parseDataOneOfNode(parseStackObj));
}
void CXMLOWL2StreamHandler::jumpFunctionParseDataUnionOfNode(CStreamParseStackObject* parseStackObj) {
addTemporaryBuildExpression(parseDataUnionOfNode(parseStackObj));
}
void CXMLOWL2StreamHandler::jumpFunctionParseDataComplementOfNode(CStreamParseStackObject* parseStackObj) {
addTemporaryBuildExpression(parseDataComplementOfNode(parseStackObj));
}
void CXMLOWL2StreamHandler::jumpFunctionParseDatatypeRestrictionNode(CStreamParseStackObject* parseStackObj) {
addTemporaryBuildExpression(parseDatatypeRestrictionNode(parseStackObj));
}
void CXMLOWL2StreamHandler::jumpFunctionParseDataMaxCardinalityNode(CStreamParseStackObject* parseStackObj) {
addTemporaryBuildExpression(parseDataMaxCardinalityNode(parseStackObj));
}
void CXMLOWL2StreamHandler::jumpFunctionParseDataMinCardinalityNode(CStreamParseStackObject* parseStackObj) {
addTemporaryBuildExpression(parseDataMinCardinalityNode(parseStackObj));
}
void CXMLOWL2StreamHandler::jumpFunctionParseDataExactCardinalityNode(CStreamParseStackObject* parseStackObj) {
addTemporaryBuildExpression(parseDataExactCardinalityNode(parseStackObj));
}
void CXMLOWL2StreamHandler::jumpFunctionParseDataPropertyAssertionNode(CStreamParseStackObject* parseStackObj) {
addTemporaryBuildExpression(parseDataPropertyAssertionNode(parseStackObj));
}
void CXMLOWL2StreamHandler::jumpFunctionParseNegativeDataPropertyAssertionNode(CStreamParseStackObject* parseStackObj) {
addTemporaryBuildExpression(parseNegativeDataPropertyAssertionNode(parseStackObj));
}
void CXMLOWL2StreamHandler::jumpFunctionParseSubDataPropertyOfNode(CStreamParseStackObject* parseStackObj) {
addTemporaryBuildExpression(parseSubDataPropertyOfNode(parseStackObj));
}
void CXMLOWL2StreamHandler::jumpFunctionParseEquivalentDataPropertiesNode(CStreamParseStackObject* parseStackObj) {
addTemporaryBuildExpression(parseEquivalentDataPropertiesNode(parseStackObj));
}
void CXMLOWL2StreamHandler::jumpFunctionParseDisjointDataPropertiesNode(CStreamParseStackObject* parseStackObj) {
addTemporaryBuildExpression(parseDisjointDataPropertiesNode(parseStackObj));
}
void CXMLOWL2StreamHandler::jumpFunctionParseDataPropertyDomainNode(CStreamParseStackObject* parseStackObj) {
addTemporaryBuildExpression(parseDataPropertyDomainNode(parseStackObj));
}
void CXMLOWL2StreamHandler::jumpFunctionParseDataPropertyRangeNode(CStreamParseStackObject* parseStackObj) {
addTemporaryBuildExpression(parseDataPropertyRangeNode(parseStackObj));
}
void CXMLOWL2StreamHandler::jumpFunctionParseFunctionalDataPropertyNode(CStreamParseStackObject* parseStackObj) {
addTemporaryBuildExpression(parseFunctionalDataPropertyNode(parseStackObj));
}
void CXMLOWL2StreamHandler::jumpFunctionParseDataFacetRestrictionNode(CStreamParseStackObject* parseStackObj) {
addTemporaryBuildExpression(parseDataFacetRestrictionNode(parseStackObj));
}
void CXMLOWL2StreamHandler::jumpFunctionParseDataLiteralNode(CStreamParseStackObject* parseStackObj) {
addTemporaryBuildExpression(parseDataLiteralNode(parseStackObj));
}
void CXMLOWL2StreamHandler::jumpFunctionParseAnonymousIndividualNode(const QXmlStreamAttributes& attributes) {
addTemporaryBuildExpression(parseAnonymousIndividualNode(attributes));
}
void CXMLOWL2StreamHandler::jumpFunctionParseObjectPropertyAssertionNode(CStreamParseStackObject* parseStackObj) {
addTemporaryBuildExpression(parseObjectPropertyAssertionNode(parseStackObj));
}
void CXMLOWL2StreamHandler::jumpFunctionParseNegativeObjectPropertyAssertionNode(CStreamParseStackObject* parseStackObj) {
addTemporaryBuildExpression(parseNegativeObjectPropertyAssertionNode(parseStackObj));
}
void CXMLOWL2StreamHandler::jumpFunctionParseSameIndividualNode(CStreamParseStackObject* parseStackObj) {
addTemporaryBuildExpression(parseSameIndividualNode(parseStackObj));
}
void CXMLOWL2StreamHandler::jumpFunctionParseDifferentIndividualsNode(CStreamParseStackObject* parseStackObj) {
addTemporaryBuildExpression(parseDifferentIndividualsNode(parseStackObj));
}
void CXMLOWL2StreamHandler::jumpFunctionParseObjectPropertyDomainNode(CStreamParseStackObject* parseStackObj) {
addTemporaryBuildExpression(parseObjectPropertyDomainNode(parseStackObj));
}
void CXMLOWL2StreamHandler::jumpFunctionParseObjectPropertyRangeNode(CStreamParseStackObject* parseStackObj) {
addTemporaryBuildExpression(parseObjectPropertyRangeNode(parseStackObj));
}
void CXMLOWL2StreamHandler::jumpFunctionParseInverseObjectPropertyOfNode(CStreamParseStackObject* parseStackObj) {
addTemporaryBuildExpression(parseInverseObjectPropertyOfNode(parseStackObj));
}
void CXMLOWL2StreamHandler::jumpFunctionParseInverseObjectPropertiesNode(CStreamParseStackObject* parseStackObj) {
addTemporaryBuildExpression(parseInverseObjectPropertiesNode(parseStackObj));
}
void CXMLOWL2StreamHandler::jumpFunctionParseTransetiveObjectPropertyNode(CStreamParseStackObject* parseStackObj) {
addTemporaryBuildExpression(parseTransetiveObjectPropertyNode(parseStackObj));
}
void CXMLOWL2StreamHandler::jumpFunctionParseFunctionalObjectPropertyNode(CStreamParseStackObject* parseStackObj) {
addTemporaryBuildExpression(parseFunctionalObjectPropertyNode(parseStackObj));
}
void CXMLOWL2StreamHandler::jumpFunctionParseSymmetricObjectPropertyNode(CStreamParseStackObject* parseStackObj) {
addTemporaryBuildExpression(parseSymmetricObjectPropertyNode(parseStackObj));
}
void CXMLOWL2StreamHandler::jumpFunctionParseAsymmetricObjectPropertyNode(CStreamParseStackObject* parseStackObj) {
addTemporaryBuildExpression(parseAsymmetricObjectPropertyNode(parseStackObj));
}
void CXMLOWL2StreamHandler::jumpFunctionParseReflexiveObjectPropertyNode(CStreamParseStackObject* parseStackObj) {
addTemporaryBuildExpression(parseReflexiveObjectPropertyNode(parseStackObj));
}
void CXMLOWL2StreamHandler::jumpFunctionParseIrreflexiveObjectPropertyNode(CStreamParseStackObject* parseStackObj) {
addTemporaryBuildExpression(parseIrreflexiveObjectPropertyNode(parseStackObj));
}
void CXMLOWL2StreamHandler::jumpFunctionParseInverseFunctionalObjectPropertyNode(CStreamParseStackObject* parseStackObj) {
addTemporaryBuildExpression(parseInverseFunctionalObjectPropertyNode(parseStackObj));
}
void CXMLOWL2StreamHandler::jumpFunctionParseIgnoredNode(CStreamParseStackObject* parseStackObj) {
}
void CXMLOWL2StreamHandler::jumpFunctionUnsupportedDatatypeNode(CStreamParseStackObject* parseStackObj) {
if (mDataTypeReportErrorCount > 0) {
--mDataTypeReportErrorCount;
LOG(ERROR,getLogDomain(),logTr("Skipped parsing of not supported datatype expression/axiom."),this);
} else if (mDataTypeReportErrorCount == 0) {
--mDataTypeReportErrorCount;
LOG(ERROR,getLogDomain(),logTr("Remaining not supported datatype expressions/axioms are ignored."),this);
}
}
void CXMLOWL2StreamHandler::jumpFunctionUnsupportedRDFNode(CStreamParseStackObject* parseStackObj) {
}
void CXMLOWL2StreamHandler::jumpFunctionParseImportNode(CStreamParseStackObject* parseStackObj) {
if (!mLastReadText.isEmpty()) {
mOntoBuilder->addOntologyImport(mLastReadText);
}
}
void CXMLOWL2StreamHandler::jumpFunctionUnsupportedImportNode(CStreamParseStackObject* parseStackObj) {
if (!mUnsupportedImportError) {
mUnsupportedImportError = true;
LOG(WARNING,getLogDomain(),logTr("Imports are currently not supported."),this);
}
}
void CXMLOWL2StreamHandler::jumpFunctionUnsupportedAnnotationNode(const QXmlStreamAttributes& attributes) {
mIgnoreParsingSubElements = true;
mParseIgnoreDepth = mStack.count();
if (!mUnsupportedAnnotationError) {
mUnsupportedAnnotationError = true;
LOG(WARNING,getLogDomain(),logTr("Annotations are currently not handled."),this);
}
}
}; // end namespace Parser
}; // end namespace Konclude