/*
* 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 "CDataLiteralNormalizerPreProcess.h"
namespace Konclude {
namespace Reasoner {
namespace Preprocess {
bool CDataLiteralNormalizerPreProcess::mConvArraysInitialized = false;
cint64* CDataLiteralNormalizerPreProcess::mHexStringBinaryDataConvArray = nullptr;
cint64* CDataLiteralNormalizerPreProcess::mBase64StringBinaryDataConvArray = nullptr;
CDataLiteralNormalizerPreProcess::CDataLiteralNormalizerPreProcess() {
mLastConceptId = 0;
if (!mConvArraysInitialized) {
cint64* tmpHexStringBinaryDataConvArray = new cint64[127];
for (cint64 i = 0; i < 127; ++i) {
tmpHexStringBinaryDataConvArray[i] = -1;
}
for (cint64 i = '0'; i <= '9'; ++i) {
tmpHexStringBinaryDataConvArray[i] = i - '0';
}
for (cint64 i = 'A'; i <= 'F'; ++i) {
tmpHexStringBinaryDataConvArray[i] = i - 'A' + 10;
}
for (cint64 i = 'a'; i <= 'f'; ++i) {
tmpHexStringBinaryDataConvArray[i] = i - 'a' + 10;
}
mHexStringBinaryDataConvArray = tmpHexStringBinaryDataConvArray;
cint64* tmpBase64StringBinaryDataConvArray = new cint64[127];
for (cint64 i = 0; i < 127; ++i) {
tmpBase64StringBinaryDataConvArray[i] = -1;
}
for (cint64 i = 'A'; i <= 'Z'; ++i) {
tmpBase64StringBinaryDataConvArray[i] = i - 'A';
}
for (cint64 i = 'a'; i <= 'z'; ++i) {
tmpBase64StringBinaryDataConvArray[i] = i - 'a' + 26;
}
for (cint64 i = '0'; i <= '9'; ++i) {
tmpBase64StringBinaryDataConvArray[i] = i - '0' + 52;
}
tmpBase64StringBinaryDataConvArray['+'] = 62;
tmpBase64StringBinaryDataConvArray['/'] = 63;
tmpBase64StringBinaryDataConvArray['-'] = 62;
tmpBase64StringBinaryDataConvArray['_'] = 63;
mBase64StringBinaryDataConvArray = tmpBase64StringBinaryDataConvArray;
mConvArraysInitialized = true;
}
}
CDataLiteralNormalizerPreProcess::~CDataLiteralNormalizerPreProcess() {
}
CConcept *CDataLiteralNormalizerPreProcess::preprocessDataConcept(CConcept* dataConcept, CConcreteOntology *ontology, CPreProcessContext* context) {
if (ontology) {
mTBox = ontology->getDataBoxes()->getTBox();
mABox = ontology->getDataBoxes()->getABox();
mRBox = ontology->getDataBoxes()->getRBox();
mMBox = ontology->getDataBoxes()->getMBox();
mRolesVector = mRBox->getRoleVector();
mConceptVector = mTBox->getConceptVector();
mIndiVec = mABox->getIndividualVector();
mOntology = ontology;
mBoxContext = mOntology->getDataBoxes()->getBoxContext();
mMemMan = mBoxContext->getMemoryAllocationManager();
cint64 conceptCount = mConceptVector->getItemCount();
if (dataConcept) {
CDataLiteral* dataLiteral = dataConcept->getDataLiteral();
if (dataLiteral) {
CDataLiteralValue* dataLiteralValue = dataLiteral->getDataLiteralValue();
if (!dataLiteralValue) {
dataLiteralValue = createDataLiteralValue(dataLiteral, context);
dataLiteral->setDataLiteralValue(dataLiteralValue);
}
}
if (dataConcept->getOperatorCode() == CCDATARESTRICTION) {
if (normalizeDatatypeRestriction(dataConcept, context)) {
conceptCount = mConceptVector->getItemCount();
}
}
else if (dataConcept->getOperatorCode() == CCDATALITERAL) {
normalizeDataLiteral(dataConcept, context);
}
}
}
return dataConcept;
}
CConcreteOntology *CDataLiteralNormalizerPreProcess::preprocess(CConcreteOntology *ontology, CPreProcessContext* context) {
mOntology = ontology;
mContext = context;
mLastConceptId = 0;
if (ontology) {
mTBox = ontology->getDataBoxes()->getTBox();
mABox = ontology->getDataBoxes()->getABox();
mRBox = ontology->getDataBoxes()->getRBox();
mMBox = ontology->getDataBoxes()->getMBox();
mRolesVector = mRBox->getRoleVector();
mConceptVector = mTBox->getConceptVector();
mIndiVec = mABox->getIndividualVector();
mOntology = ontology;
mBoxContext = mOntology->getDataBoxes()->getBoxContext();
mMemMan = mBoxContext->getMemoryAllocationManager();
}
return continuePreprocessing();
}
CConcreteOntology* CDataLiteralNormalizerPreProcess::continuePreprocessing() {
if (mOntology) {
cint64 conceptCount = mConceptVector->getItemCount();
for (cint64 i = mLastConceptId; i < conceptCount; ++i) {
CConcept* concept = mConceptVector->getLocalData(i);
if (concept) {
CDataLiteral* dataLiteral = concept->getDataLiteral();
if (dataLiteral) {
CDataLiteralValue* dataLiteralValue = dataLiteral->getDataLiteralValue();
if (!dataLiteralValue) {
dataLiteralValue = createDataLiteralValue(dataLiteral, mContext);
dataLiteral->setDataLiteralValue(dataLiteralValue);
}
}
if (concept->getOperatorCode() == CCDATARESTRICTION) {
if (normalizeDatatypeRestriction(concept, mContext)) {
conceptCount = mConceptVector->getItemCount();
}
} else if (concept->getOperatorCode() == CCDATALITERAL) {
normalizeDataLiteral(concept, mContext);
}
}
}
mLastConceptId = conceptCount;
cint64 indiCount = mIndiVec->getItemCount();
for (cint64 i = mLastIndiId; i < indiCount; ++i) {
CIndividual* indi = mIndiVec->getLocalData(i);
if (indi) {
for (CDataAssertionLinker* dataAssLinkerIt = indi->getAssertionDataLinker(); dataAssLinkerIt; dataAssLinkerIt = dataAssLinkerIt->getNext()) {
CDataLiteral* dataLiteral = dataAssLinkerIt->getDataLiteral();
if (dataLiteral) {
CDataLiteralValue* dataLiteralValue = dataLiteral->getDataLiteralValue();
if (!dataLiteralValue) {
dataLiteralValue = createDataLiteralValue(dataLiteral, mContext);
dataLiteral->setDataLiteralValue(dataLiteralValue);
}
}
}
}
}
mLastIndiId = indiCount;
}
return mOntology;
}
CDataLiteralValue* CDataLiteralNormalizerPreProcess::createPreprocessedDataLiteralValue(CDataLiteral* dataLiteral, CPreProcessContext* context, CContext* boxContext) {
mOntology = context->getOntology();
mMemMan = context->getMemoryAllocationManager();
mContext = context;
mBoxContext = boxContext;
CDataLiteralValue* dataLiteralValue = dataLiteral->getDataLiteralValue();
if (!dataLiteralValue) {
dataLiteralValue = createDataLiteralValue(dataLiteral, context);
dataLiteral->setDataLiteralValue(dataLiteralValue);
}
return dataLiteralValue;
}
bool CDataLiteralNormalizerPreProcess::normalizeDataLiteral(CConcept* dataLiteralConcept, CPreProcessContext* context) {
bool dataLiteralNormalized = false;
CDatatype* datatype = dataLiteralConcept->getDatatype();
if (!datatype) {
}
return dataLiteralNormalized;
}
bool CDataLiteralNormalizerPreProcess::normalizeDatatypeRestriction(CConcept* datatypeRestrictionConcept, CPreProcessContext* context) {
bool datatypeRestrictionNormalized = false;
cint64 restrictionCode = datatypeRestrictionConcept->getParameter();
CDatatype* datatype = datatypeRestrictionConcept->getDatatype();
if (datatype && !datatype->isBasicDatatype()) {
CDatatype* basicDatatype = datatype->getBasicDatatype();
CConcept* datatypeConcept = datatype->getDatatypeConcept();
if (datatypeConcept && basicDatatype) {
CDataLiteral* dataLiteral = datatypeRestrictionConcept->getDataLiteral();
datatypeRestrictionConcept->setDatatype(nullptr);
datatypeRestrictionConcept->setOperatorCode(CCAND);
datatypeRestrictionConcept->setDataLiteral(nullptr);
datatypeRestrictionConcept->setParameter(0);
datatypeRestrictionConcept->setOperandCount(0);
CConcept* newRestrictionConcept = createConcept();
newRestrictionConcept->setDataLiteral(dataLiteral);
newRestrictionConcept->setOperatorCode(CCDATARESTRICTION);
newRestrictionConcept->setParameter(restrictionCode);
newRestrictionConcept->setDatatype(basicDatatype);
addConceptOperand(datatypeRestrictionConcept,newRestrictionConcept,false);
addConceptOperand(datatypeRestrictionConcept,datatypeConcept,false);
datatypeRestrictionNormalized = true;
}
} else {
if (restrictionCode == CDFC_LENGTH) {
CConcept* datatypeConcept = datatype->getDatatypeConcept();
CDataLiteral* dataLiteral = datatypeRestrictionConcept->getDataLiteral();
datatypeRestrictionConcept->setDatatype(nullptr);
datatypeRestrictionConcept->setOperatorCode(CCAND);
datatypeRestrictionConcept->setDataLiteral(nullptr);
datatypeRestrictionConcept->setParameter(0);
datatypeRestrictionConcept->setOperandCount(0);
CConcept* minLengthRestrictionConcept = createConcept();
minLengthRestrictionConcept->setDataLiteral(dataLiteral);
minLengthRestrictionConcept->setOperatorCode(CCDATARESTRICTION);
minLengthRestrictionConcept->setParameter(CDFC_MIN_LENGTH_INCLUSIVE);
minLengthRestrictionConcept->setDatatype(datatype);
addConceptOperand(datatypeRestrictionConcept,minLengthRestrictionConcept,false);
CConcept* maxLengthRestrictionConcept = createConcept();
maxLengthRestrictionConcept->setDataLiteral(dataLiteral);
maxLengthRestrictionConcept->setOperatorCode(CCDATARESTRICTION);
maxLengthRestrictionConcept->setParameter(CDFC_MAX_LENGTH_INCLUSIVE);
maxLengthRestrictionConcept->setDatatype(datatype);
addConceptOperand(datatypeRestrictionConcept,maxLengthRestrictionConcept,false);
datatypeRestrictionNormalized = true;
} else if (restrictionCode == CDFC_MIN_LENGTH_INCLUSIVE) {
CDataLiteral* dataLiteral = datatypeRestrictionConcept->getDataLiteral();
dataLiteral = getNormalizedDataLiteralForLengthRestriction(datatype,dataLiteral,true,context);
datatypeRestrictionConcept->setParameter(CDFC_MIN_INCLUSIVE);
datatypeRestrictionConcept->setDataLiteral(dataLiteral);
datatypeRestrictionNormalized = true;
} else if (restrictionCode == CDFC_MAX_LENGTH_INCLUSIVE) {
CDataLiteral* dataLiteral = datatypeRestrictionConcept->getDataLiteral();
dataLiteral = getNormalizedDataLiteralForLengthRestriction(datatype,dataLiteral,false,context);
datatypeRestrictionConcept->setParameter(CDFC_MAX_EXCLUSIVE);
datatypeRestrictionConcept->setDataLiteral(dataLiteral);
datatypeRestrictionNormalized = true;
}
}
return datatypeRestrictionNormalized;
}
CDataLiteral* CDataLiteralNormalizerPreProcess::getNormalizedDataLiteralForLengthRestriction(CDatatype* datatype, CDataLiteral* dataLiteral, bool roundUp, CPreProcessContext* context) {
CDataLiteral* adaptedDataLiteral = dataLiteral;
if (dataLiteral->getDatatype() != datatype) {
adaptedDataLiteral = nullptr;
CDataLiteralValue* dataLiteralValue = dataLiteral->getDataLiteralValue();
if (!dataLiteralValue) {
dataLiteralValue = createDataLiteralValue(dataLiteral,context);
dataLiteral->setDataLiteralValue(dataLiteralValue);
}
bool lengthParsed = false;
bool infinite = false;
cint64 length = 0;
CDataLiteralRealValue* realDataLiteralValue = dynamic_cast(dataLiteralValue);
if (realDataLiteralValue && !realDataLiteralValue->isNegative()) {
if (realDataLiteralValue->isInfinite()) {
infinite = true;
lengthParsed = true;
} else {
length = realDataLiteralValue->getInteger();
lengthParsed = true;
if (roundUp && realDataLiteralValue->getNumerator() != 0) {
++length;
}
if (!roundUp) {
++length;
}
}
}
if (lengthParsed) {
if (datatype->getBasicDatatypeType() == CDatatype::DBT_STRING) {
CDataLiteralStringValue* dataLitStringValue = CObjectParameterizingAllocator::allocateAndConstructAndParameterize(mMemMan, mBoxContext);
if (infinite) {
dataLitStringValue->initValueFromInfiniteLength();
} else {
dataLitStringValue->initValueFromLength(length);
}
CDataLiteral* dataLitString = CObjectParameterizingAllocator::allocateAndConstructAndParameterize(mMemMan, mBoxContext);
dataLitString->initDataLiteral("",datatype);
dataLitString->setDataLiteralValue(dataLitStringValue);
adaptedDataLiteral = dataLitString;
} else if (datatype->getBasicDatatypeType() == CDatatype::DBT_IRI) {
CDataLiteralIRIValue* dataLitIRIValue = CObjectAllocator::allocateAndConstruct(mMemMan);
if (infinite) {
dataLitIRIValue->initValueFromInfiniteLength();
} else {
dataLitIRIValue->initValueFromLength(length);
}
CDataLiteral* dataLitIRI = CObjectParameterizingAllocator::allocateAndConstructAndParameterize(mMemMan, mBoxContext);
dataLitIRI->initDataLiteral("",datatype);
dataLitIRI->setDataLiteralValue(dataLitIRIValue);
adaptedDataLiteral = dataLitIRI;
} else if (datatype->getBasicDatatypeType() == CDatatype::DBT_HEXBINARY) {
CDataLiteralBinaryHexDataValue* dataLitHexBinaryValue = CObjectParameterizingAllocator< CDataLiteralBinaryHexDataValue,CContext* >::allocateAndConstructAndParameterize(mMemMan, mBoxContext);
if (infinite) {
dataLitHexBinaryValue->initValueFromInfiniteLength();
} else {
dataLitHexBinaryValue->initValueFromLength(length);
}
CDataLiteral* dataLitIRI = CObjectParameterizingAllocator::allocateAndConstructAndParameterize(mMemMan, mBoxContext);
dataLitIRI->initDataLiteral("", datatype);
dataLitIRI->setDataLiteralValue(dataLitHexBinaryValue);
adaptedDataLiteral = dataLitIRI;
} else if (datatype->getBasicDatatypeType() == CDatatype::DBT_BASE64BINARY) {
CDataLiteralBinaryBase64DataValue* dataLitBase64BinaryValue = CObjectParameterizingAllocator< CDataLiteralBinaryBase64DataValue,CContext* >::allocateAndConstructAndParameterize(mMemMan, mBoxContext);
if (infinite) {
dataLitBase64BinaryValue->initValueFromInfiniteLength();
} else {
dataLitBase64BinaryValue->initValueFromLength(length);
}
CDataLiteral* dataLitIRI = CObjectParameterizingAllocator::allocateAndConstructAndParameterize(mMemMan, mBoxContext);
dataLitIRI->initDataLiteral("",datatype);
dataLitIRI->setDataLiteralValue(dataLitBase64BinaryValue);
adaptedDataLiteral = dataLitIRI;
}
}
}
return adaptedDataLiteral;
}
CConcept* CDataLiteralNormalizerPreProcess::createConcept() {
CConcept* concept = CObjectAllocator::allocateAndConstruct(mMemMan);
cint64 nextConTag = mTBox->getNextConceptID();
concept->initConcept();
concept->setTag(nextConTag);
mConceptVector->setData(nextConTag,concept);
return concept;
}
CConcept* CDataLiteralNormalizerPreProcess::addConceptOperand(CConcept* concept, CConcept* operand, bool negated) {
CSortedNegLinker* opConLinker = CObjectAllocator< CSortedNegLinker >::allocateAndConstruct(mMemMan);
opConLinker->init(operand,negated);
concept->addOperandLinker(opConLinker);
concept->incOperandCount();
return concept;
}
CDataLiteralValue* CDataLiteralNormalizerPreProcess::parseBooleanValue(const QString& valueString, CPreProcessContext* context) {
CDataLiteralValue* dataLiteralValue = nullptr;
bool parsingSuccessfull = false;
bool booleanValue = false;
if (valueString.toUpper().contains("TRUE")) {
booleanValue = true;
parsingSuccessfull = true;
} else if (valueString.toUpper().contains("FALSE")) {
booleanValue = false;
parsingSuccessfull = true;
}
if (parsingSuccessfull) {
CDataLiteralBooleanValue* dataLitBooleanValue = CObjectAllocator::allocateAndConstruct(mMemMan);
dataLitBooleanValue->initValueFromBoolean(booleanValue);
dataLiteralValue = dataLitBooleanValue;
}
return dataLiteralValue;
}
CDataLiteralValue* CDataLiteralNormalizerPreProcess::parseDoubleValue(const QString& valueString, CPreProcessContext* context) {
CDataLiteralValue* dataLiteralValue = nullptr;
bool parsingSuccessfull = false;
double doubleDataValue = valueString.toDouble(&parsingSuccessfull);
if (parsingSuccessfull) {
CDataLiteralDoubleValue* dataLitDoubleValue = CObjectAllocator::allocateAndConstruct(mMemMan);
dataLitDoubleValue->initValueFromDouble(doubleDataValue);
dataLiteralValue = dataLitDoubleValue;
}
return dataLiteralValue;
}
CDataLiteralValue* CDataLiteralNormalizerPreProcess::parseFloatValue(const QString& valueString, CPreProcessContext* context) {
CDataLiteralValue* dataLiteralValue = nullptr;
bool parsingSuccessfull = false;
float floatDataValue = valueString.toFloat(&parsingSuccessfull);
if (parsingSuccessfull) {
CDataLiteralFloatValue* dataLitFloatValue = CObjectAllocator::allocateAndConstruct(mMemMan);
dataLitFloatValue->initValueFromFloat(floatDataValue);
dataLiteralValue = dataLitFloatValue;
}
return dataLiteralValue;
}
CDataLiteralValue* CDataLiteralNormalizerPreProcess::parseIntegerValue(const QString& valueString, CPreProcessContext* context) {
CDataLiteralValue* dataLiteralValue = nullptr;
bool parsingSuccessfull = false;
QString tmpValueString(valueString);
bool negative = tmpValueString.contains("-");
tmpValueString = tmpValueString.replace("-","");
cuint64 integerDataValue = tmpValueString.toULongLong(&parsingSuccessfull);
if (parsingSuccessfull) {
CDataLiteralRealValue* dataLitRatValue = CObjectAllocator::allocateAndConstruct(mMemMan);
dataLitRatValue->initRationalValueFromInteger(integerDataValue,negative);
dataLiteralValue = dataLitRatValue;
} else {
if (tmpValueString.toUpper().contains("INF")) {
CDataLiteralRealValue* dataLitRatValue = CObjectAllocator::allocateAndConstruct(mMemMan);
dataLitRatValue->initRationalValueFromInfinite(negative);
dataLiteralValue = dataLitRatValue;
}
}
return dataLiteralValue;
}
CDataLiteralValue* CDataLiteralNormalizerPreProcess::parseDecimalValue(const QString& valueString, CPreProcessContext* context) {
CDataLiteralValue* dataLiteralValue = nullptr;
bool parsingSuccessfull = false;
cuint64 integerValue = 0;
cuint64 decimalValue = 0;
QString tmpValueString(valueString);
bool negative = tmpValueString.contains("-");
tmpValueString = tmpValueString.replace("-","");
QStringList dataValueStringList = tmpValueString.split(".");
if (dataValueStringList.size() < 2) {
dataValueStringList = tmpValueString.split(",");
}
int precedingZerors = 0;
if (dataValueStringList.size() >= 2) {
bool integerParsingSuccessfull = false;
bool decimalParsingSuccessfull = false;
QString firstDataValueString = dataValueStringList.takeFirst().trimmed();
QString secondDataValueString = dataValueStringList.takeFirst().trimmed();
if (firstDataValueString.isEmpty()) {
integerValue = 0;
integerParsingSuccessfull = true;
} else {
integerValue = firstDataValueString.toULongLong(&integerParsingSuccessfull);
}
if (secondDataValueString.isEmpty()) {
decimalValue = 0;
decimalParsingSuccessfull = true;
} else {
decimalValue = secondDataValueString.toULongLong(&decimalParsingSuccessfull);
if (secondDataValueString.startsWith("0") && secondDataValueString.size() > 1) {
++precedingZerors;
while (secondDataValueString.size() > precedingZerors && secondDataValueString.at(precedingZerors) == '0') {
++precedingZerors;
}
}
}
parsingSuccessfull = integerParsingSuccessfull & decimalParsingSuccessfull;
}
if (parsingSuccessfull) {
CDataLiteralRealValue* dataLitRatValue = CObjectAllocator::allocateAndConstruct(mMemMan);
dataLitRatValue->initRationalValueFromDecimal(integerValue,decimalValue,negative,precedingZerors);
dataLiteralValue = dataLitRatValue;
}
if (!dataLiteralValue) {
dataLiteralValue = parseIntegerValue(valueString,context);
}
return dataLiteralValue;
}
CDataLiteralValue* CDataLiteralNormalizerPreProcess::parseRationalValue(const QString& valueString, CPreProcessContext* context) {
CDataLiteralValue* dataLiteralValue = nullptr;
bool parsingSuccessfull = false;
cuint64 numeratorValue = 0;
cuint64 denominatorValue = 0;
QString tmpValueString(valueString);
bool negative = tmpValueString.contains("-");
tmpValueString = tmpValueString.replace("-","");
QStringList dataValueStringList = tmpValueString.split("/");
if (dataValueStringList.size() >= 2) {
bool numeratorParsingSuccessfull = false;
bool denominatorParsingSuccessfull = false;
QString firstDataValueString = dataValueStringList.takeFirst().trimmed();
QString secondDataValueString = dataValueStringList.takeFirst().trimmed();
numeratorValue = firstDataValueString.toULongLong(&numeratorParsingSuccessfull);
denominatorValue = secondDataValueString.toULongLong(&denominatorParsingSuccessfull);
parsingSuccessfull = numeratorParsingSuccessfull & denominatorParsingSuccessfull;
}
if (parsingSuccessfull) {
CDataLiteralRealValue* dataLitRatValue = CObjectAllocator::allocateAndConstruct(mMemMan);
dataLitRatValue->initRationalValueFromFraction(numeratorValue,denominatorValue,negative);
dataLiteralValue = dataLitRatValue;
}
if (!dataLiteralValue) {
dataLiteralValue = parseDecimalValue(valueString,context);
}
return dataLiteralValue;
}
CDataLiteralValue* CDataLiteralNormalizerPreProcess::parseRealValue(const QString& valueString, CPreProcessContext* context) {
CDataLiteralValue* dataLiteralValue = nullptr;
if (!dataLiteralValue) {
dataLiteralValue = parseRationalValue(valueString,context);
}
return dataLiteralValue;
}
CDataLiteralValue* CDataLiteralNormalizerPreProcess::parseStringValue(const QString& valueString, bool parseLanguageString, CPreProcessContext* context) {
CDataLiteralValue* dataLiteralValue = nullptr;
if (!dataLiteralValue) {
QString stringValueString = valueString;
QString languageValueString;
if (parseLanguageString) {
cint64 lastLanguageSep = valueString.lastIndexOf("@");
if (lastLanguageSep > 0) {
stringValueString = valueString.mid(0,lastLanguageSep);
if (!stringValueString.trimmed().isEmpty()) {
languageValueString = valueString.mid(lastLanguageSep + 1);
bool validLanguageTag = true;
bool firstBindOccurred = false;
for (cint64 i = 0; i < languageValueString.length() && validLanguageTag; ++i) {
QChar ch = languageValueString.at(i);
if (!firstBindOccurred && i > 3) {
validLanguageTag = false;
}
if (ch == QChar('-')) {
firstBindOccurred = true;
}
if (!ch.isLetterOrNumber() && ch != QChar('-')) {
validLanguageTag = false;
}
}
if (!validLanguageTag) {
stringValueString = valueString;
languageValueString = "";
}
} else {
stringValueString = valueString;
languageValueString = "";
}
}
}
languageValueString = languageValueString.toLower();
CDataLiteralStringValue* dataLitStringValue = CObjectParameterizingAllocator::allocateAndConstructAndParameterize(mMemMan, mBoxContext);
dataLitStringValue->initValueFromString(stringValueString,languageValueString);
dataLiteralValue = dataLitStringValue;
}
return dataLiteralValue;
}
CDataLiteralValue* CDataLiteralNormalizerPreProcess::parseDateTimeValue(const QString& valueString, CPreProcessContext* context) {
CDataLiteralValue* dataLiteralValue = nullptr;
if (!dataLiteralValue) {
QString dateTimeValueString = valueString;
QString timeZoneOffsetValueString;
if (valueString.contains("-") || valueString.contains("+")) {
cint64 lastZoneMinusSep = valueString.lastIndexOf("-");
cint64 lastZonePlusSep = valueString.lastIndexOf("+");
cint64 lastZoneSep = qMax(lastZonePlusSep,lastZoneMinusSep);
if (lastZoneSep >= 12) {
dateTimeValueString = valueString.mid(0,lastZoneSep);
timeZoneOffsetValueString = valueString.mid(lastZoneSep+1);
}
}
QDateTime dateTime = QDateTime::fromString(dateTimeValueString,Qt::ISODate);
if (dateTime.isValid()) {
QDate tmpDate(dateTime.date());
QTime tmpTime(dateTime.time());
QDateTime tmpDateTime(tmpDate,tmpTime,Qt::UTC);
if (dateTime.timeSpec() == Qt::LocalTime) {
dateTime = tmpDateTime;
}
cuint64 timeZoneOffset = 0;
if (dateTime.timeSpec() == Qt::OffsetFromUTC) {
QDateTime utcDateTime = dateTime.toUTC();
timeZoneOffset = utcDateTime.secsTo(tmpDateTime);
dateTime = utcDateTime;
}
CDataLiteralDateTimeValue* dataLitDateTimeValue = CObjectAllocator::allocateAndConstruct(mMemMan);
dataLitDateTimeValue->initValueFromDataTime(dateTime,timeZoneOffset);
dataLiteralValue = dataLitDateTimeValue;
}
}
return dataLiteralValue;
}
CDataLiteralValue* CDataLiteralNormalizerPreProcess::parseIRIValue(const QString& valueString, CPreProcessContext* context) {
CDataLiteralValue* dataLiteralValue = nullptr;
if (!dataLiteralValue) {
CDataLiteralIRIValue* dataLitIRIValue = CObjectAllocator::allocateAndConstruct(mMemMan);
dataLitIRIValue->initValueFromIRIString(valueString.trimmed());
dataLiteralValue = dataLitIRIValue;
}
return dataLiteralValue;
}
CDataLiteralValue* CDataLiteralNormalizerPreProcess::parseXMLValue(const QString& valueString, CPreProcessContext* context) {
CDataLiteralValue* dataLiteralValue = nullptr;
if (!dataLiteralValue) {
QDomDocument domDocument;
if (domDocument.setContent(valueString,true)) {
QString xmlValueString = domDocument.toString();
if (!xmlValueString.isEmpty()) {
CDataLiteralXMLValue* dataLitXMLValue = CObjectAllocator::allocateAndConstruct(mMemMan);
dataLitXMLValue->initValueFromXMLString(valueString.trimmed());
dataLiteralValue = dataLitXMLValue;
}
}
}
return dataLiteralValue;
}
cint64 CDataLiteralNormalizerPreProcess::getBinaryFromHex(QChar character) {
cint64 unicode = character.unicode();
if (unicode > 127) {
return -1;
}
return mHexStringBinaryDataConvArray[unicode];
}
cint64 CDataLiteralNormalizerPreProcess::getBinaryFromBase64(QChar character) {
cint64 unicode = character.unicode();
if (unicode > 127) {
return -1;
}
return mBase64StringBinaryDataConvArray[unicode];
}
CDataLiteralValue* CDataLiteralNormalizerPreProcess::parseBinaryHexValue(const QString& valueString, CPreProcessContext* context) {
CDataLiteralValue* dataLiteralValue = nullptr;
if (!dataLiteralValue) {
QString dataValueString(valueString);
int dataValueStringLength = dataValueString.length();
unsigned char* tmpByteData = new unsigned char[dataValueStringLength/2+1];
cint64 byteDataLength = 0;
cint64 byteParts[2];
cint64 currentBytePart = 0;
for (int i = 0; i < dataValueStringLength; ++i) {
QChar dataChar = dataValueString[i];
cint64 dataBytePart = getBinaryFromHex(dataChar);
if (dataBytePart != -1) {
byteParts[currentBytePart++] = dataBytePart;
if (currentBytePart >= 2) {
currentBytePart = 0;
cint64 nextDataByte = byteParts[0]<<4 + byteParts[1];
tmpByteData[byteDataLength++] = (unsigned char)nextDataByte;
}
}
}
if (currentBytePart == 1) {
cint64 nextDataByte = byteParts[0]<<4;
tmpByteData[byteDataLength++] = (unsigned char)nextDataByte;
}
CDataLiteralBinaryHexDataValue* dataLitHexBinaryValue = CObjectParameterizingAllocator< CDataLiteralBinaryHexDataValue,CContext* >::allocateAndConstructAndParameterize(mMemMan,mBoxContext);
dataLitHexBinaryValue->initValueFromData(tmpByteData,byteDataLength);
delete [] tmpByteData;
dataLiteralValue = dataLitHexBinaryValue;
}
return dataLiteralValue;
}
CDataLiteralValue* CDataLiteralNormalizerPreProcess::parseBinaryBase64Value(const QString& valueString, CPreProcessContext* context) {
CDataLiteralValue* dataLiteralValue = nullptr;
if (!dataLiteralValue) {
QString dataValueString(valueString);
int dataValueStringLength = dataValueString.length();
unsigned char* tmpByteData = new unsigned char[dataValueStringLength*3/4+1];
cint64 byteDataLength = 0;
cint64 byteParts[4];
cint64 currentBytePart = 0;
for (int i = 0; i < dataValueStringLength; ++i) {
QChar dataChar = dataValueString[i];
cint64 dataBytePart = getBinaryFromBase64(dataChar);
if (dataBytePart != -1) {
byteParts[currentBytePart++] = dataBytePart;
if (currentBytePart >= 4) {
currentBytePart = 0;
cint64 nextDataByte1 = byteParts[0]<<2 + byteParts[1]>>4;
tmpByteData[byteDataLength++] = (unsigned char)nextDataByte1;
cint64 nextDataByte2 = byteParts[1]<<4 + byteParts[2]>>2;
tmpByteData[byteDataLength++] = (unsigned char)nextDataByte2;
cint64 nextDataByte3 = byteParts[2]<<6 + byteParts[3];
tmpByteData[byteDataLength++] = (unsigned char)nextDataByte3;
}
}
}
if (currentBytePart == 3) {
cint64 nextDataByte1 = byteParts[0]<<2 + byteParts[1]>>4;
tmpByteData[byteDataLength++] = (unsigned char)nextDataByte1;
cint64 nextDataByte2 = byteParts[1]<<4 + byteParts[2]>>2;
tmpByteData[byteDataLength++] = (unsigned char)nextDataByte2;
cint64 nextDataByte3 = byteParts[2]<<6;
tmpByteData[byteDataLength++] = (unsigned char)nextDataByte3;
}
if (currentBytePart == 2) {
cint64 nextDataByte1 = byteParts[0]<<2 + byteParts[1]>>4;
tmpByteData[byteDataLength++] = (unsigned char)nextDataByte1;
cint64 nextDataByte2 = byteParts[1]<<4;
tmpByteData[byteDataLength++] = (unsigned char)nextDataByte2;
}
if (currentBytePart == 1) {
cint64 nextDataByte1 = byteParts[0]<<2;
tmpByteData[byteDataLength++] = (unsigned char)nextDataByte1;
}
CDataLiteralBinaryBase64DataValue* dataLitBase64BinaryValue = CObjectParameterizingAllocator< CDataLiteralBinaryBase64DataValue,CContext* >::allocateAndConstructAndParameterize(mMemMan,mBoxContext);
dataLitBase64BinaryValue->initValueFromData(tmpByteData,byteDataLength);
delete [] tmpByteData;
dataLiteralValue = dataLitBase64BinaryValue;
}
return dataLiteralValue;
}
CDataLiteralValue* CDataLiteralNormalizerPreProcess::createDataLiteralValue(CDataLiteral* dataLiteral, CPreProcessContext* context) {
CDataLiteralValue* dataLiteralValue = nullptr;
CDatatype* datatype = dataLiteral->getDatatype();
if (datatype) {
QString dataLexicalValueString = dataLiteral->getLexicalDataLiteralValueString();
QString datatypeIRI = datatype->getDatatypeIRI();
if (datatypeIRI == PREFIX_XML_INTEGER_DATATYPE) {
dataLiteralValue = parseIntegerValue(dataLexicalValueString,context);
} else if (datatypeIRI == PREFIX_XML_DECIMAL_DATATYPE) {
dataLiteralValue = parseDecimalValue(dataLexicalValueString,context);
} else if (datatypeIRI == PREFIX_OWL_RATIONAL_DATATYPE) {
dataLiteralValue = parseRationalValue(dataLexicalValueString,context);
} else if (datatypeIRI == PREFIX_OWL_REAL_DATATYPE) {
dataLiteralValue = parseRealValue(dataLexicalValueString,context);
} else if (datatypeIRI == PREFIX_XML_NONNEGATIVEINTEGER_DATATYPE) {
dataLiteralValue = parseIntegerValue(dataLexicalValueString,context);
} else if (datatypeIRI == PREFIX_XML_POSITIVEINTEGER_DATATYPE) {
dataLiteralValue = parseIntegerValue(dataLexicalValueString,context);
} else if (datatypeIRI == PREFIX_XML_NONPOSITIVEINTEGER_DATATYPE) {
dataLiteralValue = parseIntegerValue(dataLexicalValueString,context);
} else if (datatypeIRI == PREFIX_XML_NEGATIVEINTEGER_DATATYPE) {
dataLiteralValue = parseIntegerValue(dataLexicalValueString,context);
} else if (datatypeIRI == PREFIX_XML_LONG_DATATYPE) {
dataLiteralValue = parseIntegerValue(dataLexicalValueString,context);
} else if (datatypeIRI == PREFIX_XML_INT_DATATYPE) {
dataLiteralValue = parseIntegerValue(dataLexicalValueString,context);
} else if (datatypeIRI == PREFIX_XML_SHORT_DATATYPE) {
dataLiteralValue = parseIntegerValue(dataLexicalValueString,context);
} else if (datatypeIRI == PREFIX_XML_BYTE_DATATYPE) {
dataLiteralValue = parseIntegerValue(dataLexicalValueString,context);
} else if (datatypeIRI == PREFIX_XML_UNSIGNEDLONG_DATATYPE) {
dataLiteralValue = parseIntegerValue(dataLexicalValueString,context);
} else if (datatypeIRI == PREFIX_XML_UNSIGNEDINT_DATATYPE) {
dataLiteralValue = parseIntegerValue(dataLexicalValueString,context);
} else if (datatypeIRI == PREFIX_XML_UNSIGNEDSHORT_DATATYPE) {
dataLiteralValue = parseIntegerValue(dataLexicalValueString,context);
} else if (datatypeIRI == PREFIX_XML_UNSIGNEDBYTE_DATATYPE) {
dataLiteralValue = parseIntegerValue(dataLexicalValueString,context);
} else if (datatypeIRI == PREFIX_XML_PLAINLITERAL_DATATYPE) {
dataLiteralValue = parseStringValue(dataLexicalValueString,true,context);
} else if (datatypeIRI == PREFIX_XML_STRING_DATATYPE) {
dataLiteralValue = parseStringValue(dataLexicalValueString,false,context);
} else if (datatypeIRI == PREFIX_XML_NORMALIZEDSTRING_DATATYPE) {
dataLiteralValue = parseStringValue(dataLexicalValueString,false,context);
} else if (datatypeIRI == PREFIX_XML_TOKEN_DATATYPE) {
dataLiteralValue = parseStringValue(dataLexicalValueString,false,context);
} else if (datatypeIRI == PREFIX_XML_NAME_DATATYPE) {
dataLiteralValue = parseStringValue(dataLexicalValueString,false,context);
} else if (datatypeIRI == PREFIX_XML_NCNAME_DATATYPE) {
dataLiteralValue = parseStringValue(dataLexicalValueString,false,context);
} else if (datatypeIRI == PREFIX_XML_NMTOKEN_DATATYPE) {
dataLiteralValue = parseStringValue(dataLexicalValueString,false,context);
} else if (datatypeIRI == PREFIX_XML_LANGUAGE_DATATYPE) {
dataLiteralValue = parseStringValue(dataLexicalValueString,false,context);
} else if (datatypeIRI == PREFIX_XML_BOOLEAN_DATATYPE) {
dataLiteralValue = parseBooleanValue(dataLexicalValueString,context);
} else if (datatypeIRI == PREFIX_XML_DOUBLE_DATATYPE) {
dataLiteralValue = parseDoubleValue(dataLexicalValueString,context);
} else if (datatypeIRI == PREFIX_XML_FLOAT_DATATYPE) {
dataLiteralValue = parseFloatValue(dataLexicalValueString,context);
} else if (datatypeIRI == PREFIX_XML_IRI_DATATYPE) {
dataLiteralValue = parseIRIValue(dataLexicalValueString,context);
} else if (datatypeIRI == PREFIX_XML_XML_DATATYPE) {
dataLiteralValue = parseXMLValue(dataLexicalValueString,context);
} else if (datatypeIRI == PREFIX_XML_BINARYHEX_DATATYPE) {
dataLiteralValue = parseBinaryHexValue(dataLexicalValueString,context);
} else if (datatypeIRI == PREFIX_XML_BINARYBASE64_DATATYPE) {
dataLiteralValue = parseBinaryBase64Value(dataLexicalValueString,context);
} else if (datatypeIRI == PREFIX_XML_DATETIME_DATATYPE) {
dataLiteralValue = parseDateTimeValue(dataLexicalValueString,context);
} else if (datatypeIRI == PREFIX_XML_DATETIMESTAMP_DATATYPE) {
dataLiteralValue = parseDateTimeValue(dataLexicalValueString,context);
} else {
LOG(WARNING,"::Konclude::Reasoner::Preprocess::DataLiteralNormaliser",logTr("Unknown or not supported datatype '%1', cannot parse '%2'.").arg(datatypeIRI).arg(dataLexicalValueString),this);
}
if (!dataLiteralValue) {
LOG(WARNING,"::Konclude::Reasoner::Preprocess::DataLiteralNormaliser",logTr("Failed to parse literal '%1' for datatype '%2'.").arg(dataLexicalValueString).arg(datatypeIRI),this);
}
}
return dataLiteralValue;
}
}; // end namespace Preprocess
}; // end namespace Reasoner
}; // end namespace Konclude