/*
* 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 .
*
*/
#ifdef KONCLUDE_REDLAND_INTEGRATION
#include "CConcreteOntologyRedlandTriplesDataExpressionMapper.h"
namespace Konclude {
namespace Reasoner {
namespace Generator {
int CConcreteOntologyRedlandTriplesDataExpressionMapper::CRedlandNodeProcessingData::nextId = 0;
CConcreteOntologyRedlandTriplesDataExpressionMapper::CConcreteOntologyRedlandTriplesDataExpressionMapper(COntologyBuilder* ontologyBuilder) : CConcreteOntologyTriplesExpressionMapper(ontologyBuilder) {
mConfSuccessorRetrieval = true;
}
CConcreteOntologyRedlandTriplesDataExpressionMapper::~CConcreteOntologyRedlandTriplesDataExpressionMapper() {
}
bool CConcreteOntologyRedlandTriplesDataExpressionMapper::mapTriples(CConcreteOntology* updateConcreteOntology, COntologyTriplesData* ontologyTripleData) {
bool newTriplesMapped = false;
CTriplesData* tripleData = ontologyTripleData->getLatestTriplesData(true);
if (tripleData) {
CRedlandStoredTriplesData* redlandTriplesData = dynamic_cast(tripleData);
librdf_model* model = redlandTriplesData->getRedlandIndexedModel();
librdf_statement *partial_statement = librdf_new_statement(redlandTriplesData->getRedlandWorld());
librdf_stream* stream = librdf_model_find_statements(model, partial_statement);
if (!stream) {
return false;
} else {
newTriplesMapped = true;
//unsigned char* modelString = librdf_model_to_string(redlandTriplesData->getRedlandIndexedModel(), nullptr, "turtle", nullptr, nullptr);
//QFile file("temp.ttl");
//file.open(QIODevice::WriteOnly);
//file.write((const char*)modelString);
initTripleDataProcessing(redlandTriplesData);
cint64 count = 0;
getOWLClassInstanceNodesStream()->forEach([&](librdf_node* node) {
count++;
});
loadExistingEntities(updateConcreteOntology->getBuildData(), redlandTriplesData);
buildDeclarations();
buildObjectPropertyExpressions();
buildDataRangeExpressions();
buildClassExpressions();
buildClassBasedAxioms();
buildObjectPropertyBasedAxioms();
buildDataPropertyBasedAxioms();
buildDatatypeBasedAxioms();
buildSeparateNodeBasedAxioms();
buildComplexABoxAxioms();
if (mConfExtractSimpleABoxAssertions) {
buildSimpleABoxAxioms();
}
// do clean up
//clearTripleDataProcessing();
}
}
return newTriplesMapped;
}
CConcreteOntologyRedlandTriplesDataExpressionMapper* CConcreteOntologyRedlandTriplesDataExpressionMapper::handleParsedOntologyAxiomExpression(CAxiomExpression* axiomExpression) {
mOntologyBuilder->tellOntologyAxiom(axiomExpression);
return this;
}
CConcreteOntologyRedlandTriplesDataExpressionMapper* CConcreteOntologyRedlandTriplesDataExpressionMapper::buildSimpleABoxAxioms() {
QList axiomExpressionList;
for (CRedlandNodeProcessingData* nextProcessingData : mClassNodeHandlingList) {
if (nextProcessingData->mExpression) {
if (librdf_node_is_resource(nextProcessingData->mRedlandNode)) {
QList* processingDataList = getNodeProcessingDataListFromNodeStreamWithNewHandling(createRedlandNodeStreamWrapper()->init(getPartialStatementFilteredTripleStream(getAdaptedPartialFilteringStatement(nullptr, nullptr, nextProcessingData->mRedlandNode, mPartialFilteringStatementForOWLAllRDFTypePredecessors)), 0), mNamedIndividualNodeIdentifierDataHash, [&](librdf_node* node)->CRedlandNodeProcessingData* {
return createNamedIndividualProcessingData(node);
});
if (processingDataList && !processingDataList->isEmpty()) {
for (CRedlandNodeProcessingData* processingData : *processingDataList) {
CAxiomExpression* axiomExpression = mOntologyBuilder->getClassAssertion(processingData->mExpression, nextProcessingData->mExpression);
if (axiomExpression) {
axiomExpressionList.append(axiomExpression);
}
}
}
if (processingDataList) {
delete processingDataList;
}
}
}
}
for (CRedlandNodeProcessingData* nextProcessingData : mObjectPropertyNodeHandlingList) {
if (nextProcessingData->mExpression) {
collectBetweenIndividualsBasedAxiomExpression(nextProcessingData, [&](const QList& expressionList)->CAxiomExpression* { return mOntologyBuilder->getObjectPropertyAssertion(expressionList); }, mPartialFilteringStatementForOWLPropertyAssertions, axiomExpressionList);
}
}
collectBetweenIndividualsBasedAxiomExpression([&](const QList& expressionList)->CAxiomExpression* { return mOntologyBuilder->getDifferentIndividuals(expressionList); }, mPartialFilteringStatementForOWLDifferentIndividuals, axiomExpressionList);
collectBetweenIndividualsBasedAxiomExpression([&](const QList& expressionList)->CAxiomExpression* { return mOntologyBuilder->getSameIndividual(expressionList); }, mPartialFilteringStatementForOWLSameIndividuals, axiomExpressionList);
for (CRedlandNodeProcessingData* nextProcessingData : mDataPropertyNodeHandlingList) {
if (nextProcessingData->mExpression) {
releaseRedlandTripleStreamWrapper(getPartialStatementFilteredTripleStream(getAdaptedPartialFilteringStatement(nullptr, nextProcessingData->mRedlandNode, nullptr, mPartialFilteringStatementForOWLPropertyAssertions))->forEach([&](librdf_statement* statement) {
librdf_node* subject = librdf_statement_get_subject(statement);
librdf_node* object = librdf_statement_get_object(statement);
if (librdf_node_is_literal(object)) {
QList* processingDataList = nullptr;
// TODO: individuals may be anonymous individuals
processingDataList = getNodeProcessingDataListFromNodeWithNewHandling(subject, mNamedIndividualNodeIdentifierDataHash, [&](librdf_node* node)->CRedlandNodeProcessingData* { return createNamedIndividualProcessingData(node); }, processingDataList);
processingDataList = getNodeProcessingDataListFromNodeWithNewHandling(object, mDataLiteralNodeIdentifierDataHash, [&](librdf_node* node)->CRedlandNodeProcessingData* { return createLiteralValueProcessingData(node); }, processingDataList);
if (processingDataList) {
processingDataList->append(nextProcessingData);
QList expressionList;
collectBuildExpressionsFromProcessingDataList(*processingDataList, expressionList);
CAxiomExpression* axiomExpression = mOntologyBuilder->getDataPropertyAssertion(expressionList);
if (axiomExpression) {
axiomExpressionList.append(axiomExpression);
}
delete processingDataList;
}
}
}));
}
}
for (CAxiomExpression* axiomExpression : axiomExpressionList) {
handleParsedOntologyAxiomExpression(axiomExpression);
}
return this;
}
CConcreteOntologyRedlandTriplesDataExpressionMapper* CConcreteOntologyRedlandTriplesDataExpressionMapper::collectBetweenIndividualsBasedAxiomExpression(CRedlandNodeProcessingData* nextProcessingData, function&)> buildFunc, librdf_statement* filteringStatement, QList& axiomList) {
releaseRedlandTripleStreamWrapper(getPartialStatementFilteredTripleStream(getAdaptedPartialFilteringStatement(nullptr, nextProcessingData->mRedlandNode, nullptr, filteringStatement))->forEach([&](librdf_statement* statement) {
librdf_node* subject = librdf_statement_get_subject(statement);
librdf_node* object = librdf_statement_get_object(statement);
QList* processingDataList = nullptr;
// TODO: individuals may be anonymous individuals
processingDataList = getNodeProcessingDataListFromNodeWithNewHandling(subject, mNamedIndividualNodeIdentifierDataHash, [&](librdf_node* node)->CRedlandNodeProcessingData* { return createNamedIndividualProcessingData(node); }, processingDataList);
processingDataList = getNodeProcessingDataListFromNodeWithNewHandling(object, mNamedIndividualNodeIdentifierDataHash, [&](librdf_node* node)->CRedlandNodeProcessingData* { return createNamedIndividualProcessingData(node); }, processingDataList);
if (processingDataList) {
processingDataList->append(nextProcessingData);
QList expressionList;
collectBuildExpressionsFromProcessingDataList(*processingDataList, expressionList);
CAxiomExpression* axiomExpression = buildFunc(expressionList);
if (axiomExpression) {
axiomList.append(axiomExpression);
}
delete processingDataList;
}
}));
return this;
}
CConcreteOntologyRedlandTriplesDataExpressionMapper* CConcreteOntologyRedlandTriplesDataExpressionMapper::collectBetweenIndividualsBasedAxiomExpression(function&)> buildFunc, librdf_statement* filteringStatement, QList& axiomList) {
releaseRedlandTripleStreamWrapper(getPartialStatementFilteredTripleStream(getAdaptedPartialFilteringStatement(nullptr, nullptr, nullptr, filteringStatement))->forEach([&](librdf_statement* statement) {
librdf_node* subject = librdf_statement_get_subject(statement);
librdf_node* object = librdf_statement_get_object(statement);
QList* processingDataList = nullptr;
// TODO: individuals may be anonymous individuals
processingDataList = getNodeProcessingDataListFromNodeWithNewHandling(subject, mNamedIndividualNodeIdentifierDataHash, [&](librdf_node* node)->CRedlandNodeProcessingData* { return createNamedIndividualProcessingData(node); }, processingDataList);
processingDataList = getNodeProcessingDataListFromNodeWithNewHandling(object, mNamedIndividualNodeIdentifierDataHash, [&](librdf_node* node)->CRedlandNodeProcessingData* { return createNamedIndividualProcessingData(node); }, processingDataList);
if (processingDataList) {
QList expressionList;
collectBuildExpressionsFromProcessingDataList(*processingDataList, expressionList);
CAxiomExpression* axiomExpression = buildFunc(expressionList);
if (axiomExpression) {
axiomList.append(axiomExpression);
}
delete processingDataList;
}
}));
return this;
}
CConcreteOntologyRedlandTriplesDataExpressionMapper* CConcreteOntologyRedlandTriplesDataExpressionMapper::buildComplexABoxAxioms() {
QList axiomExpressionList;
for (CRedlandNodeProcessingData* nextProcessingData : mClassNodeHandlingList) {
if (nextProcessingData->mExpression) {
if (librdf_node_is_blank(nextProcessingData->mRedlandNode)) {
QList* processingDataList = getNodeProcessingDataListFromNodeStreamWithNewHandling(createRedlandNodeStreamWrapper()->init(getPartialStatementFilteredTripleStream(getAdaptedPartialFilteringStatement(nullptr, nullptr, nextProcessingData->mRedlandNode, mPartialFilteringStatementForOWLAllRDFTypePredecessors)), 0), mNamedIndividualNodeIdentifierDataHash, [&](librdf_node* node)->CRedlandNodeProcessingData* {
return createNamedIndividualProcessingData(node);
});
if (processingDataList && !processingDataList->isEmpty()) {
for (CRedlandNodeProcessingData* processingData : *processingDataList) {
QList expressionList;
expressionList.append(nextProcessingData->mExpression);
expressionList.append(processingData->mExpression);
CAxiomExpression* axiomExpression = mOntologyBuilder->getClassAssertion(expressionList);
if (axiomExpression) {
axiomExpressionList.append(axiomExpression);
}
delete processingDataList;
}
}
}
}
}
// complex data range assertions
for (CRedlandNodeProcessingData* nextProcessingData : mDataPropertyNodeHandlingList) {
if (nextProcessingData->mExpression) {
releaseRedlandTripleStreamWrapper(getPartialStatementFilteredTripleStream(getAdaptedPartialFilteringStatement(nullptr, nextProcessingData->mRedlandNode, nullptr, mPartialFilteringStatementForOWLPropertyAssertions))->forEach([&](librdf_statement* statement) {
librdf_node* subject = librdf_statement_get_subject(statement);
librdf_node* object = librdf_statement_get_object(statement);
if (!librdf_node_is_literal(object)) {
QList* processingDataList = nullptr;
// TODO: individuals may be anonymous individuals
processingDataList = getNodeProcessingDataListFromNodeWithNewHandling(subject, mNamedIndividualNodeIdentifierDataHash, [&](librdf_node* node)->CRedlandNodeProcessingData* { return createNamedIndividualProcessingData(node); }, processingDataList);
processingDataList = getNodeProcessingDataListFromNode(object, mDatatypeNodeIdentifierDataHash, processingDataList);
if (processingDataList) {
processingDataList->append(nextProcessingData);
QList expressionList;
collectBuildExpressionsFromProcessingDataList(*processingDataList, expressionList);
CAxiomExpression* axiomExpression = mOntologyBuilder->getDataPropertyAssertion(expressionList);
if (axiomExpression) {
axiomExpressionList.append(axiomExpression);
}
delete processingDataList;
}
}
}));
}
}
for (CAxiomExpression* axiomExpression : axiomExpressionList) {
handleParsedOntologyAxiomExpression(axiomExpression);
}
return this;
}
CConcreteOntologyRedlandTriplesDataExpressionMapper* CConcreteOntologyRedlandTriplesDataExpressionMapper::loadExistingEntities(COntologyBuildData* buildData, CRedlandStoredTriplesData* redlandTriplesData) {
CBUILDHASH* classExpHash = buildData->getClassEntityBuildHash();
for (CBUILDHASH::const_iterator it = classExpHash->constBegin(), itEnd = classExpHash->constEnd(); it != itEnd; ++it) {
CClassExpression* classExp = it.value();
loadExistingEntity(classExp, classExp->getName(), redlandTriplesData->getRedlandWorld(), mClassNodeIdentifierDataHash, mClassNodeHandlingList);
}
CBUILDHASH* objPropExpHash = buildData->getObjectPropertyEntityBuildHash();
for (CBUILDHASH::const_iterator it = objPropExpHash->constBegin(), itEnd = objPropExpHash->constEnd(); it != itEnd; ++it) {
CObjectPropertyExpression* objPropExp = it.value();
loadExistingEntity(objPropExp, objPropExp->getName(), redlandTriplesData->getRedlandWorld(), mObjectPropertyNodeIdentifierDataHash, mObjectPropertyNodeHandlingList);
}
CBUILDHASH* dataPropExpHash = buildData->getDataPropertyEntityBuildHash();
for (CBUILDHASH::const_iterator it = dataPropExpHash->constBegin(), itEnd = dataPropExpHash->constEnd(); it != itEnd; ++it) {
CDataPropertyExpression* dataPropExp = it.value();
loadExistingEntity(dataPropExp, dataPropExp->getName(), redlandTriplesData->getRedlandWorld(), mDataPropertyNodeIdentifierDataHash, mDataPropertyNodeHandlingList);
}
return this;
}
CConcreteOntologyRedlandTriplesDataExpressionMapper* CConcreteOntologyRedlandTriplesDataExpressionMapper::loadExistingEntity(CBuildExpression* expression, const QString& entityUri, librdf_world* world, QHash& nodeIdentifierDataHash, QList& nodeHandlingList) {
QByteArray uriData = entityUri.toUtf8();
librdf_uri* uri = librdf_new_uri(world, (const unsigned char*)uriData.constData());
librdf_node* classNode = librdf_new_node_from_uri(world, uri);
CRedlandNodeProcessingData*& processingData = nodeIdentifierDataHash[CRedlandNodeHasher(classNode)];
if (!processingData) {
processingData = new CRedlandNodeProcessingData(classNode, expression);
nodeHandlingList.append(processingData);
processingData->mExpression = expression;
}
return this;
}
CConcreteOntologyRedlandTriplesDataExpressionMapper* CConcreteOntologyRedlandTriplesDataExpressionMapper::buildDeclarations() {
releaseRedlandNodeStreamWrapper(getOWLClassInstanceNodesStream()->forEach([&](librdf_node* node) {
handleDeclaration(node, [&](const QString &uri)->CBuildExpression* {
return mOntologyBuilder->getClass(uri);
}, mClassNodeIdentifierDataHash, mClassNodeHandlingList);
}));
releaseRedlandNodeStreamWrapper(getOWLRestrictionInstanceNodesStream()->forEach([&](librdf_node* node) {
handleClassExpressionRestriction(node);
}));
releaseRedlandNodeStreamWrapper(getOWLObjectPropertyInstanceNodesStream()->forEach([&](librdf_node* node) {
handleDeclaration(node, [&](const QString &uri)->CBuildExpression* { return mOntologyBuilder->getObjectProberty(uri); }, mObjectPropertyNodeIdentifierDataHash, mObjectPropertyNodeHandlingList);
}));
releaseRedlandNodeStreamWrapper(getOWLDatatypePropertyInstanceNodesStream()->forEach([&](librdf_node* node) {
handleDeclaration(node, [&](const QString &uri)->CBuildExpression* { return mOntologyBuilder->getDataProberty(uri); }, mDataPropertyNodeIdentifierDataHash, mDataPropertyNodeHandlingList);
}));
releaseRedlandNodeStreamWrapper(getRDFSDatatypeInstanceNodesStream()->forEach([&](librdf_node* node) {
handleDeclaration(node, [&](const QString &uri)->CBuildExpression* { return mOntologyBuilder->getDatatype(uri); }, mDatatypeNodeIdentifierDataHash, mDatatypeNodeHandlingList);
}));
if (mConfExtractSimpleABoxAssertions) {
releaseRedlandNodeStreamWrapper(getOWLNamedIndividualInstanceNodesStream()->forEach([&](librdf_node* node) {
handleDeclaration(node, [&](const QString &uri)->CBuildExpression* { return mOntologyBuilder->getNamedIndividual(uri); }, mNamedIndividualNodeIdentifierDataHash, mNamedIndividualNodeHandlingList);
}));
}
return this;
}
CConcreteOntologyRedlandTriplesDataExpressionMapper* CConcreteOntologyRedlandTriplesDataExpressionMapper::buildSeparateNodeBasedAxioms() {
QList axiomExpressionList;
releaseRedlandNodeStreamWrapper(getOWLAllDisjointClassesInstanceNodesStream()->forEach([&](librdf_node* node) {
bool processed = false;
if (!processed) {
buildAxiomExpressionForMemberRDFNodeList(node, mPartialFilteringStatementForOWLMembers, mClassNodeIdentifierDataHash, [&](const QList& expressions)->CAxiomExpression* {
CAxiomExpression* axiomExp = mOntologyBuilder->getDisjointClasses(expressions);
processed |= axiomExp != nullptr;
return axiomExp;
}, axiomExpressionList);
}
}));
releaseRedlandNodeStreamWrapper(getOWLAllDisjointPropertiesInstanceNodesStream()->forEach([&](librdf_node* node) {
bool processed = false;
if (!processed) {
buildAxiomExpressionForObjectORDataPropertyMemberRDFNodeList(node, mPartialFilteringStatementForOWLMembers, [&](const QList& expressions, bool hasDataProperties, bool hasObjectProperties)->CAxiomExpression* {
CAxiomExpression* axiomExp = nullptr;
if (!hasDataProperties && hasObjectProperties) {
axiomExp = mOntologyBuilder->getDisjointObjectProperties(expressions);
} else if (hasDataProperties && !hasObjectProperties) {
axiomExp = mOntologyBuilder->getDisjointDataProperties(expressions);
}
processed |= axiomExp != nullptr;
return axiomExp;
}, axiomExpressionList);
}
}));
releaseRedlandNodeStreamWrapper(getOWLAllDifferentInstanceNodesStream()->forEach([&](librdf_node* node) {
bool processed = false;
if (!processed) {
buildAxiomExpressionForMemberRDFNodeListWithNewHandling(node, mPartialFilteringStatementForOWLMembers, mNamedIndividualNodeIdentifierDataHash, [&](librdf_node* node)->CRedlandNodeProcessingData* { return createNamedIndividualProcessingData(node); }, [&](const QList& expressions)->CAxiomExpression* {
if (expressions.size() > 0) {
CAxiomExpression* axiomExp = mOntologyBuilder->getDifferentIndividuals(expressions);
processed |= axiomExp != nullptr;
return axiomExp;
}
return nullptr;
}, axiomExpressionList);
}
if (!processed) {
buildAxiomExpressionForMemberRDFNodeListWithNewHandling(node, mPartialFilteringStatementForOWLDistinctMembers, mNamedIndividualNodeIdentifierDataHash, [&](librdf_node* node)->CRedlandNodeProcessingData* { return createNamedIndividualProcessingData(node); }, [&](const QList& expressions)->CAxiomExpression* {
if (expressions.size() > 0) {
CAxiomExpression* axiomExp = mOntologyBuilder->getDifferentIndividuals(expressions);
processed |= axiomExp != nullptr;
return axiomExp;
}
return nullptr;
}, axiomExpressionList);
}
}));
releaseRedlandNodeStreamWrapper(getOWLAllNegativePropertyAssertionInstanceNodesStream()->forEach([&](librdf_node* node) {
bool processed = false;
if (!processed) {
QList* sourcendividualProcessingDataList = getNodeProcessingDataListFromNodeStreamWithNewHandling(createRedlandNodeStreamWrapper()->init(getPartialStatementFilteredTripleStream(getAdaptedPartialFilteringStatement(node, nullptr, nullptr, mPartialFilteringStatementForOWLSourceIndividualSuccessors)), 2), mNamedIndividualNodeIdentifierDataHash, [&](librdf_node* node)->CRedlandNodeProcessingData* { return createNamedIndividualProcessingData(node); });
if (sourcendividualProcessingDataList) {
if (!processed) {
QList* targetValueLiteralProcessingDataList = getNodeProcessingDataListFromNodeStreamWithNewHandling(createRedlandNodeStreamWrapper()->init(getPartialStatementFilteredTripleStream(getAdaptedPartialFilteringStatement(node, nullptr, nullptr, mPartialFilteringStatementForOWLTargetValueSuccessors)), 2), mDataLiteralNodeIdentifierDataHash, [&](librdf_node* node)->CRedlandNodeProcessingData* { return createLiteralValueProcessingData(node); });
if (targetValueLiteralProcessingDataList) {
QList* propertyProcessingDataList = getNodeProcessingDataListFromNodeStream(createRedlandNodeStreamWrapper()->init(getPartialStatementFilteredTripleStream(getAdaptedPartialFilteringStatement(node, nullptr, nullptr, mPartialFilteringStatementForOWLAssertionPropertySuccessors)), 2), mObjectPropertyNodeIdentifierDataHash);
if (propertyProcessingDataList) {
QList expressionList;
collectBuildExpressionsFromProcessingDataList(*sourcendividualProcessingDataList, expressionList);
collectBuildExpressionsFromProcessingDataList(*targetValueLiteralProcessingDataList, expressionList);
collectBuildExpressionsFromProcessingDataList(*propertyProcessingDataList, expressionList);
CAxiomExpression* axiomExpression = mOntologyBuilder->getNegativeObjectPropertyAssertion(expressionList);
if (axiomExpression) {
processed = true;
axiomExpressionList.append(axiomExpression);
}
delete propertyProcessingDataList;
}
delete targetValueLiteralProcessingDataList;
}
}
if (!processed) {
QList* targetIndividualProcessingDataList = getNodeProcessingDataListFromNodeStreamWithNewHandling(createRedlandNodeStreamWrapper()->init(getPartialStatementFilteredTripleStream(getAdaptedPartialFilteringStatement(node, nullptr, nullptr, mPartialFilteringStatementForOWLTargetIndividualSuccessors)), 2), mNamedIndividualNodeIdentifierDataHash, [&](librdf_node* node)->CRedlandNodeProcessingData* { return createNamedIndividualProcessingData(node); });
if (targetIndividualProcessingDataList) {
QList* propertyProcessingDataList = getNodeProcessingDataListFromNodeStream(createRedlandNodeStreamWrapper()->init(getPartialStatementFilteredTripleStream(getAdaptedPartialFilteringStatement(node, nullptr, nullptr, mPartialFilteringStatementForOWLAssertionPropertySuccessors)), 2), mDataPropertyNodeIdentifierDataHash);
if (propertyProcessingDataList) {
QList expressionList;
collectBuildExpressionsFromProcessingDataList(*sourcendividualProcessingDataList, expressionList);
collectBuildExpressionsFromProcessingDataList(*targetIndividualProcessingDataList, expressionList);
collectBuildExpressionsFromProcessingDataList(*propertyProcessingDataList, expressionList);
CAxiomExpression* axiomExpression = mOntologyBuilder->getNegativeDataPropertyAssertion(expressionList);
if (axiomExpression) {
processed = true;
axiomExpressionList.append(axiomExpression);
}
delete propertyProcessingDataList;
}
delete targetIndividualProcessingDataList;
}
}
delete sourcendividualProcessingDataList;
}
}
}));
for (CAxiomExpression* axiomExpression : axiomExpressionList) {
handleParsedOntologyAxiomExpression(axiomExpression);
}
return this;
}
CConcreteOntologyRedlandTriplesDataExpressionMapper* CConcreteOntologyRedlandTriplesDataExpressionMapper::collectBuildExpressionsFromProcessingDataList(QList& processingDataList, QList& expressionList) {
for (CRedlandNodeProcessingData* processingData : processingDataList) {
if (processingData->mExpression) {
expressionList.append(processingData->mExpression);
}
}
return this;
}
CConcreteOntologyRedlandTriplesDataExpressionMapper* CConcreteOntologyRedlandTriplesDataExpressionMapper::buildAxiomExpressionForMemberRDFNodeList(librdf_node* node, librdf_statement* partialFilteringStatementForOWLMembers, QHash& nodeIdentifierDataHash, function&)> buildFunction, QList& axiomExpressions) {
releaseRedlandTripleStreamWrapper(getPartialStatementFilteredTripleStream(getAdaptedPartialFilteringStatement(node, nullptr, nullptr, partialFilteringStatementForOWLMembers))->forEach([&](librdf_statement* statement) {
librdf_node* object = librdf_statement_get_object(statement);
QList expressionList;
buildAxiomExpressionFromRDFNodeList(object, nodeIdentifierDataHash, expressionList, buildFunction, axiomExpressions);
}));
return this;
}
CConcreteOntologyRedlandTriplesDataExpressionMapper* CConcreteOntologyRedlandTriplesDataExpressionMapper::buildAxiomExpressionForMemberRDFNodeListWithNewHandling(librdf_node* node, librdf_statement* partialFilteringStatementForOWLMembers, QHash& nodeIdentifierDataHash, function newHandlingFunc, function&)> buildFunction, QList& axiomExpressions) {
releaseRedlandTripleStreamWrapper(getPartialStatementFilteredTripleStream(getAdaptedPartialFilteringStatement(node, nullptr, nullptr, partialFilteringStatementForOWLMembers))->forEach([&](librdf_statement* statement) {
librdf_node* object = librdf_statement_get_object(statement);
QList expressionList;
buildAxiomExpressionFromRDFNodeListWithNewHandling(object, nodeIdentifierDataHash, newHandlingFunc, expressionList, buildFunction, axiomExpressions);
}));
return this;
}
CConcreteOntologyRedlandTriplesDataExpressionMapper* CConcreteOntologyRedlandTriplesDataExpressionMapper::buildAxiomExpressionForObjectORDataPropertyMemberRDFNodeList(librdf_node* node, librdf_statement* partialFilteringStatementForOWLMembers, function&, bool hasDataProperties, bool hasObjectProperties)> buildFunction, QList& axiomExpressions) {
releaseRedlandTripleStreamWrapper(getPartialStatementFilteredTripleStream(getAdaptedPartialFilteringStatement(node, nullptr, nullptr, partialFilteringStatementForOWLMembers))->forEach([&](librdf_statement* statement) {
librdf_node* object = librdf_statement_get_object(statement);
bool dataPropertyNodeUsed = false;
bool objectPropertyNodeUsed = false;
QList expressionList;
QList* nodeList = nullptr;
nodeList = getOWLListElementNodesList(object, nodeList);
if (nodeList) {
for (librdf_node* listElementNode : *nodeList) {
CRedlandNodeHasher hasher(listElementNode);
CRedlandNodeProcessingData* processingData = mObjectPropertyNodeIdentifierDataHash.value(hasher);
if (!processingData) {
processingData = mDataPropertyNodeIdentifierDataHash.value(hasher);
if (processingData) {
dataPropertyNodeUsed = true;
}
} else {
objectPropertyNodeUsed = true;
}
if (processingData && processingData->mExpression) {
expressionList.append(processingData->mExpression);
}
}
CAxiomExpression* axiomExp = buildFunction(expressionList, dataPropertyNodeUsed, objectPropertyNodeUsed);
if (axiomExp) {
axiomExpressions.append(axiomExp);
}
delete nodeList;
}
}));
return this;
}
CConcreteOntologyRedlandTriplesDataExpressionMapper* CConcreteOntologyRedlandTriplesDataExpressionMapper::buildDatatypeBasedAxioms() {
if (mConfSuccessorRetrieval) {
buildAxioms(&mDatatypeNodeHandlingList, [&](CRedlandNodeProcessingData* processingData, QList& axiomExpressions) { collectDatatypeBasedAxiomExpressionsBySuccessorRetrieval(processingData, axiomExpressions); });
} else {
buildAxioms(&mDatatypeNodeHandlingList, [&](CRedlandNodeProcessingData* processingData, QList& axiomExpressions) { collectDatatypeBasedAxiomExpressions(processingData, axiomExpressions); });
}
return this;
}
CConcreteOntologyRedlandTriplesDataExpressionMapper* CConcreteOntologyRedlandTriplesDataExpressionMapper::buildClassBasedAxioms() {
if (mConfSuccessorRetrieval) {
buildAxioms(&mClassNodeHandlingList, [&](CRedlandNodeProcessingData* processingData, QList& axiomExpressions) { collectClassBasedAxiomExpressionsBySuccessorRetrieval(processingData, axiomExpressions); });
} else {
buildAxioms(&mClassNodeHandlingList, [&](CRedlandNodeProcessingData* processingData, QList& axiomExpressions) { collectClassBasedAxiomExpressions(processingData, axiomExpressions); });
}
return this;
}
CConcreteOntologyRedlandTriplesDataExpressionMapper* CConcreteOntologyRedlandTriplesDataExpressionMapper::buildObjectPropertyBasedAxioms() {
if (mConfSuccessorRetrieval) {
buildAxioms(&mObjectPropertyNodeHandlingList, [&](CRedlandNodeProcessingData* processingData, QList& axiomExpressions) { collectObjectPropertyBasedAxiomExpressionsBySuccessorRetrieval(processingData, axiomExpressions); });
QList axiomExpressions;
collectObjectPropertyTypesAxiomExpressionsBySuccessorRetrieval(axiomExpressions);
for (CAxiomExpression* axiomExpression : axiomExpressions) {
handleParsedOntologyAxiomExpression(axiomExpression);
}
} else {
buildAxioms(&mObjectPropertyNodeHandlingList, [&](CRedlandNodeProcessingData* processingData, QList& axiomExpressions) { collectObjectPropertyBasedAxiomExpressions(processingData, axiomExpressions); });
}
return this;
}
CConcreteOntologyRedlandTriplesDataExpressionMapper* CConcreteOntologyRedlandTriplesDataExpressionMapper::buildDataPropertyBasedAxioms() {
if (mConfSuccessorRetrieval) {
buildAxioms(&mDataPropertyNodeHandlingList, [&](CRedlandNodeProcessingData* processingData, QList& axiomExpressions) { collectDataPropertyBasedAxiomExpressionsBySuccessorRetrieval(processingData, axiomExpressions); });
QList axiomExpressions;
collectDataPropertyTypesAxiomExpressionsBySuccessorRetrieval(axiomExpressions);
for (CAxiomExpression* axiomExpression : axiomExpressions) {
handleParsedOntologyAxiomExpression(axiomExpression);
}
} else {
buildAxioms(&mDataPropertyNodeHandlingList, [&](CRedlandNodeProcessingData* processingData, QList& axiomExpressions) { collectDataPropertyBasedAxiomExpressions(processingData, axiomExpressions); });
}
return this;
}
CConcreteOntologyRedlandTriplesDataExpressionMapper* CConcreteOntologyRedlandTriplesDataExpressionMapper::buildAxioms(QList* nodeHandlingList, function&)> dependenciesCollectionFunction) {
QList axiomExpressionList;
for (CRedlandNodeProcessingData* nextProcessingData : *nodeHandlingList) {
if (nextProcessingData->mExpression) {
dependenciesCollectionFunction(nextProcessingData, axiomExpressionList);
}
}
for (CAxiomExpression* axiomExpression : axiomExpressionList) {
handleParsedOntologyAxiomExpression(axiomExpression);
}
return this;
}
CConcreteOntologyRedlandTriplesDataExpressionMapper* CConcreteOntologyRedlandTriplesDataExpressionMapper::collectClassBasedAxiomExpressions(CRedlandNodeProcessingData* processingData, QList& axiomExpressions) {
if (processingData->mExpression) {
// TODO: if there are too many successor triples, then use the other method, which directly filters by the corresponding predicates
// create/use forEachAsLong/forEachLimited
releaseRedlandTripleStreamWrapper(getPartialStatementFilteredTripleStream(getAdaptedPartialFilteringStatement(processingData->mRedlandNode, nullptr, nullptr, mPartialFilteringStatementForOWLAxioms))->forEach([&](librdf_statement* statement) {
librdf_node* predicate = librdf_statement_get_predicate(statement);
librdf_node* object = librdf_statement_get_object(statement);
cint64 index = mClassBasedAxiomPredicateIndexHash.value(CRedlandNodeHasher(predicate), -1);
if (index >= 0) {
QList expressionList;
expressionList.append(processingData->mExpression);
switch (index) {
case mOWLClassAxiomSubClassOfPredicateIndex:
buildAxiomExpressionFromNode(object, mClassNodeIdentifierDataHash, expressionList, [&](const QList& expressions)->CAxiomExpression* { return mOntologyBuilder->getSubClassOf(expressions); }, axiomExpressions);
break;
case mOWLClassAxiomEquvialentClassPredicateIndex:
buildAxiomExpressionFromNode(object, mClassNodeIdentifierDataHash, expressionList, [&](const QList& expressions)->CAxiomExpression* { return mOntologyBuilder->getEquivalentClasses(expressions); }, axiomExpressions);
break;
case mOWLClassAxiomDisjointWithPredicateIndex:
buildAxiomExpressionFromNode(object, mClassNodeIdentifierDataHash, expressionList, [&](const QList& expressions)->CAxiomExpression* { return mOntologyBuilder->getDisjointClasses(expressions); }, axiomExpressions);
break;
case mOWLClassAxiomDisjointUnionOfPredicateIndex:
buildAxiomExpressionFromRDFNodeList(object, mClassNodeIdentifierDataHash, expressionList, [&](const QList& expressions)->CAxiomExpression* { return mOntologyBuilder->getDisjointUnion(expressions); }, axiomExpressions);
break;
default:
break;
}
}
}));
}
return this;
}
CConcreteOntologyRedlandTriplesDataExpressionMapper* CConcreteOntologyRedlandTriplesDataExpressionMapper::collectClassBasedAxiomExpressionsBySuccessorRetrieval(CRedlandNodeProcessingData* processingData, QList& axiomExpressions) {
releaseRedlandTripleStreamWrapper(getPartialStatementFilteredTripleStream(getAdaptedPartialFilteringStatement(processingData->mRedlandNode, nullptr, nullptr, mPartialFilteringStatementForRDFSSubClassOfSuccessors))->forEach([&](librdf_statement* statement) {
librdf_node* object = librdf_statement_get_object(statement);
buildAxiomExpressionFromNode(object, mClassNodeIdentifierDataHash, QList() << processingData->mExpression, [&](const QList& expressions)->CAxiomExpression* { return mOntologyBuilder->getSubClassOf(expressions); }, axiomExpressions);
}));
releaseRedlandTripleStreamWrapper(getPartialStatementFilteredTripleStream(getAdaptedPartialFilteringStatement(processingData->mRedlandNode, nullptr, nullptr, mPartialFilteringStatementForOWLEquivalentClassesSuccessors))->forEach([&](librdf_statement* statement) {
librdf_node* object = librdf_statement_get_object(statement);
buildAxiomExpressionFromNode(object, mClassNodeIdentifierDataHash, QList() << processingData->mExpression, [&](const QList& expressions)->CAxiomExpression* { return mOntologyBuilder->getEquivalentClasses(expressions); }, axiomExpressions);
}));
releaseRedlandTripleStreamWrapper(getPartialStatementFilteredTripleStream(getAdaptedPartialFilteringStatement(processingData->mRedlandNode, nullptr, nullptr, mPartialFilteringStatementForOWLDisjointClassesSuccessors))->forEach([&](librdf_statement* statement) {
librdf_node* object = librdf_statement_get_object(statement);
buildAxiomExpressionFromNode(object, mClassNodeIdentifierDataHash, QList() << processingData->mExpression, [&](const QList& expressions)->CAxiomExpression* { return mOntologyBuilder->getDisjointClasses(expressions); }, axiomExpressions);
}));
releaseRedlandTripleStreamWrapper(getPartialStatementFilteredTripleStream(getAdaptedPartialFilteringStatement(processingData->mRedlandNode, nullptr, nullptr, mPartialFilteringStatementForOWLDisjointUnionSuccessors))->forEach([&](librdf_statement* statement) {
librdf_node* object = librdf_statement_get_object(statement);
buildAxiomExpressionFromRDFNodeList(object, mClassNodeIdentifierDataHash, QList() << processingData->mExpression, [&](const QList& expressions)->CAxiomExpression* { return mOntologyBuilder->getDisjointUnion(expressions); }, axiomExpressions);
}));
return this;
}
CConcreteOntologyRedlandTriplesDataExpressionMapper* CConcreteOntologyRedlandTriplesDataExpressionMapper::collectDatatypeBasedAxiomExpressions(CRedlandNodeProcessingData* processingData, QList& axiomExpressions) {
if (processingData->mExpression) {
// TODO: if there are too many successor triples, then use the other method, which directly filters by the corresponding predicates
// create/use forEachAsLong/forEachLimited
releaseRedlandTripleStreamWrapper(getPartialStatementFilteredTripleStream(getAdaptedPartialFilteringStatement(processingData->mRedlandNode, nullptr, nullptr, mPartialFilteringStatementForOWLAxioms))->forEach([&](librdf_statement* statement) {
librdf_node* predicate = librdf_statement_get_predicate(statement);
librdf_node* object = librdf_statement_get_object(statement);
cint64 index = mDatatypeBasedAxiomPredicateIndexHash.value(CRedlandNodeHasher(predicate), -1);
if (index >= 0) {
QList expressionList;
expressionList.append(processingData->mExpression);
switch (index) {
case mOWLClassAxiomEquvialentClassPredicateIndex:
// TODO: build datatype definition axiom (may not yet available)
break;
default:
break;
}
}
}));
}
return this;
}
CConcreteOntologyRedlandTriplesDataExpressionMapper* CConcreteOntologyRedlandTriplesDataExpressionMapper::collectDatatypeBasedAxiomExpressionsBySuccessorRetrieval(CRedlandNodeProcessingData* processingData, QList& axiomExpressions) {
// TODO: build datatype definition axiom (may not yet available)
return this;
}
CConcreteOntologyRedlandTriplesDataExpressionMapper* CConcreteOntologyRedlandTriplesDataExpressionMapper::collectObjectPropertyBasedAxiomExpressions(CRedlandNodeProcessingData* processingData, QList& axiomExpressions) {
if (processingData->mExpression) {
// TODO: if there are too many successor triples, then use the other method, which directly filters by the corresponding predicates
// create/use forEachAsLong/forEachLimited
releaseRedlandTripleStreamWrapper(getPartialStatementFilteredTripleStream(getAdaptedPartialFilteringStatement(processingData->mRedlandNode, nullptr, nullptr, mPartialFilteringStatementForOWLAxioms))->forEach([&](librdf_statement* statement) {
librdf_node* predicate = librdf_statement_get_predicate(statement);
librdf_node* object = librdf_statement_get_object(statement);
cint64 predicateIndex = mPropertyBasedAxiomPredicateIndexHash.value(CRedlandNodeHasher(predicate), -1);
if (predicateIndex >= 0) {
QList expressionList;
expressionList.append(processingData->mExpression);
switch (predicateIndex) {
case mOWLPredicateBasedAxiomSubPropertyOfPredicateIndex:
buildAxiomExpressionFromNode(object, mObjectPropertyNodeIdentifierDataHash, expressionList, [&](const QList& expressions)->CAxiomExpression* { return mOntologyBuilder->getSubObjectPropertyOf(expressions); }, axiomExpressions);
break;
case mOWLPredicateBasedAxiomPropertyChainAxiomPredicateIndex:
buildAxiomExpressionFromRDFNodeList(object, mObjectPropertyNodeIdentifierDataHash, expressionList, [&](const QList& expressions)->CAxiomExpression* {
QList resortedExpressionList(expressions);
if (resortedExpressionList.size() > 0) {
CBuildExpression* superProperty = resortedExpressionList.takeFirst();
resortedExpressionList.append(superProperty);
}
return mOntologyBuilder->getSubObjectPropertyOf(resortedExpressionList);
}, axiomExpressions);
break;
case mOWLPredicateBasedAxiomEquivalentPropertyPredicateIndex:
buildAxiomExpressionFromNode(object, mObjectPropertyNodeIdentifierDataHash, expressionList, [&](const QList& expressions)->CAxiomExpression* { return mOntologyBuilder->getEquivalentObjectProperties(expressions); }, axiomExpressions);
break;
case mOWLPredicateBasedAxiomPropertyDisjointWithPredicateIndex:
buildAxiomExpressionFromNode(object, mObjectPropertyNodeIdentifierDataHash, expressionList, [&](const QList& expressions)->CAxiomExpression* { return mOntologyBuilder->getDisjointObjectProperties(expressions); }, axiomExpressions);
break;
case mOWLPredicateBasedAxiomDomainPredicateIndex:
buildAxiomExpressionFromNode(object, mClassNodeIdentifierDataHash, expressionList, [&](const QList& expressions)->CAxiomExpression* { return mOntologyBuilder->getObjectPropertyDomainExpression(expressions); }, axiomExpressions);
break;
case mOWLPredicateBasedAxiomRangePredicateIndex:
buildAxiomExpressionFromNode(object, mClassNodeIdentifierDataHash, expressionList, [&](const QList& expressions)->CAxiomExpression* { return mOntologyBuilder->getObjectPropertyRangeExpression(expressions); }, axiomExpressions);
break;
case mOWLPredicateBasedAxiomInverseOfPredicateIndex:
buildAxiomExpressionFromNode(object, mObjectPropertyNodeIdentifierDataHash, expressionList, [&](const QList& expressions)->CAxiomExpression* { return mOntologyBuilder->getInverseObjectProperties(expressions); }, axiomExpressions);
break;
case mRDFPredicateBasedAxiomTypeOfPredicateIndex:
cint64 objectIndex = mPropertyBasedAxiomObjectIndexHash.value(CRedlandNodeHasher(object), -1);
if (objectIndex >= 0) {
switch (objectIndex) {
case mOWLPredicateBasedAxiomTypeFunctionalPropertyObjectIndex:
axiomExpressions.append(mOntologyBuilder->getFunctionalObjectProperty(processingData->mExpression));
break;
case mOWLPredicateBasedAxiomTypeInverseFunctionalPropertyObjectIndex:
axiomExpressions.append(mOntologyBuilder->getInverseFunctionalObjectProperty(processingData->mExpression));
break;
case mOWLPredicateBasedAxiomTypeReflexivePropertyObjectIndex:
axiomExpressions.append(mOntologyBuilder->getReflexiveObjectProperty(processingData->mExpression));
break;
case mOWLPredicateBasedAxiomTypeIrreflexivePropertyObjectIndex:
axiomExpressions.append(mOntologyBuilder->getIrreflexiveObjectProperty(processingData->mExpression));
break;
case mOWLPredicateBasedAxiomTypeSymmetricPropertyObjectIndex:
axiomExpressions.append(mOntologyBuilder->getSymmetricObjectProperty(processingData->mExpression));
break;
case mOWLPredicateBasedAxiomTypeAsymmetricPropertyObjectIndex:
axiomExpressions.append(mOntologyBuilder->getAsymmetricObjectProperty(processingData->mExpression));
break;
case mOWLPredicateBasedAxiomTypeTransitivePropertyObjectIndex:
axiomExpressions.append(mOntologyBuilder->getTransetiveObjectProperty(processingData->mExpression));
break;
default:
break;
}
}
break;
}
}
}));
}
return this;
}
CConcreteOntologyRedlandTriplesDataExpressionMapper* CConcreteOntologyRedlandTriplesDataExpressionMapper::collectDataPropertyTypesAxiomExpressionsBySuccessorRetrieval(QList& axiomExpressions) {
releaseRedlandNodeStreamWrapper(getOWLFunctionalPropertyInstanceNodesStream()->forEach([&](librdf_node* node) {
QList* dataProcessingDataList = getNodeProcessingDataListFromNode(node, mDataPropertyNodeIdentifierDataHash);
if (dataProcessingDataList) {
for (CRedlandNodeProcessingData* processingData : *dataProcessingDataList) {
axiomExpressions.append(mOntologyBuilder->getFunctionalDataProperty(QList() << processingData->mExpression));
}
delete dataProcessingDataList;
}
}));
return this;
}
CConcreteOntologyRedlandTriplesDataExpressionMapper* CConcreteOntologyRedlandTriplesDataExpressionMapper::collectObjectPropertyTypesAxiomExpressionsBySuccessorRetrieval(QList& axiomExpressions) {
collectObjectPropertyTypesAxiomExpressionsBySuccessorRetrieval([&]()->CRedlandNodeStream* { return getOWLFunctionalPropertyInstanceNodesStream(); }, [&](const QList& expressions)->CAxiomExpression* { return mOntologyBuilder->getFunctionalObjectProperty(expressions); }, axiomExpressions);
collectObjectPropertyTypesAxiomExpressionsBySuccessorRetrieval([&]()->CRedlandNodeStream* { return getOWLInverseFunctionalPropertyInstanceNodesStream(); }, [&](const QList& expressions)->CAxiomExpression* { return mOntologyBuilder->getInverseFunctionalObjectProperty(expressions); }, axiomExpressions);
collectObjectPropertyTypesAxiomExpressionsBySuccessorRetrieval([&]()->CRedlandNodeStream* { return getOWLReflexivePropertyInstanceNodesStream(); }, [&](const QList& expressions)->CAxiomExpression* { return mOntologyBuilder->getReflexiveObjectProperty(expressions); }, axiomExpressions);
collectObjectPropertyTypesAxiomExpressionsBySuccessorRetrieval([&]()->CRedlandNodeStream* { return getOWLIrreflexivePropertyInstanceNodesStream(); }, [&](const QList& expressions)->CAxiomExpression* { return mOntologyBuilder->getIrreflexiveObjectProperty(expressions); }, axiomExpressions);
collectObjectPropertyTypesAxiomExpressionsBySuccessorRetrieval([&]()->CRedlandNodeStream* { return getOWLSymmetricPropertyInstanceNodesStream(); }, [&](const QList& expressions)->CAxiomExpression* { return mOntologyBuilder->getSymmetricObjectProperty(expressions); }, axiomExpressions);
collectObjectPropertyTypesAxiomExpressionsBySuccessorRetrieval([&]()->CRedlandNodeStream* { return getOWLAsymmetricPropertyInstanceNodesStream(); }, [&](const QList& expressions)->CAxiomExpression* { return mOntologyBuilder->getAsymmetricObjectProperty(expressions); }, axiomExpressions);
collectObjectPropertyTypesAxiomExpressionsBySuccessorRetrieval([&]()->CRedlandNodeStream* { return getOWLTransetivePropertyInstanceNodesStream(); }, [&](const QList& expressions)->CAxiomExpression* { return mOntologyBuilder->getTransetiveObjectProperty(expressions); }, axiomExpressions);
return this;
}
CConcreteOntologyRedlandTriplesDataExpressionMapper* CConcreteOntologyRedlandTriplesDataExpressionMapper::collectObjectPropertyTypesAxiomExpressionsBySuccessorRetrieval(function nodeStreamFunc, function& expressions)> buildFunc, QList& axiomExpressions) {
releaseRedlandNodeStreamWrapper(nodeStreamFunc()->forEach([&](librdf_node* node) {
QList* objectProcessingDataList = getNodeProcessingDataListFromNode(node, mObjectPropertyNodeIdentifierDataHash);
if (objectProcessingDataList) {
for (CRedlandNodeProcessingData* processingData : *objectProcessingDataList) {
axiomExpressions.append(buildFunc(QList() << processingData->mExpression));
}
delete objectProcessingDataList;
}
}));
return this;
}
CConcreteOntologyRedlandTriplesDataExpressionMapper* CConcreteOntologyRedlandTriplesDataExpressionMapper::collectObjectPropertyBasedAxiomExpressionsBySuccessorRetrieval(CRedlandNodeProcessingData* processingData, QList& axiomExpressions) {
if (processingData->mExpression) {
releaseRedlandTripleStreamWrapper(getPartialStatementFilteredTripleStream(getAdaptedPartialFilteringStatement(processingData->mRedlandNode, nullptr, nullptr, mPartialFilteringStatementForRDFSSubPropertySuccessors))->forEach([&](librdf_statement* statement) {
librdf_node* object = librdf_statement_get_object(statement);
buildAxiomExpressionFromNode(object, mObjectPropertyNodeIdentifierDataHash, QList() << processingData->mExpression, [&](const QList& expressions)->CAxiomExpression* { return mOntologyBuilder->getSubObjectPropertyOf(expressions); }, axiomExpressions);
}));
releaseRedlandTripleStreamWrapper(getPartialStatementFilteredTripleStream(getAdaptedPartialFilteringStatement(processingData->mRedlandNode, nullptr, nullptr, mPartialFilteringStatementForOWLPropertyChainAxiomSuccessors))->forEach([&](librdf_statement* statement) {
librdf_node* object = librdf_statement_get_object(statement);
buildAxiomExpressionFromRDFNodeList(object, mObjectPropertyNodeIdentifierDataHash, QList() << processingData->mExpression, [&](const QList& expressions)->CAxiomExpression* {
QList resortedExpressionList(expressions);
if (!resortedExpressionList.isEmpty()) {
CBuildExpression* superProperty = resortedExpressionList.takeFirst();
resortedExpressionList.append(superProperty);
}
return mOntologyBuilder->getSubObjectPropertyOf(resortedExpressionList);
}, axiomExpressions);
}));
releaseRedlandTripleStreamWrapper(getPartialStatementFilteredTripleStream(getAdaptedPartialFilteringStatement(processingData->mRedlandNode, nullptr, nullptr, mPartialFilteringStatementForOWLEquivalentPropertySuccessors))->forEach([&](librdf_statement* statement) {
librdf_node* object = librdf_statement_get_object(statement);
buildAxiomExpressionFromNode(object, mObjectPropertyNodeIdentifierDataHash, QList() << processingData->mExpression, [&](const QList& expressions)->CAxiomExpression* { return mOntologyBuilder->getEquivalentObjectProperties(expressions); }, axiomExpressions);
}));
releaseRedlandTripleStreamWrapper(getPartialStatementFilteredTripleStream(getAdaptedPartialFilteringStatement(processingData->mRedlandNode, nullptr, nullptr, mPartialFilteringStatementForOWLPropertyDisjointWithSuccessors))->forEach([&](librdf_statement* statement) {
librdf_node* object = librdf_statement_get_object(statement);
buildAxiomExpressionFromNode(object, mObjectPropertyNodeIdentifierDataHash, QList() << processingData->mExpression, [&](const QList& expressions)->CAxiomExpression* { return mOntologyBuilder->getDisjointObjectProperties(expressions); }, axiomExpressions);
}));
releaseRedlandTripleStreamWrapper(getPartialStatementFilteredTripleStream(getAdaptedPartialFilteringStatement(processingData->mRedlandNode, nullptr, nullptr, mPartialFilteringStatementForRDFSDomainSuccessors))->forEach([&](librdf_statement* statement) {
librdf_node* object = librdf_statement_get_object(statement);
buildAxiomExpressionFromNode(object, mClassNodeIdentifierDataHash, QList() << processingData->mExpression, [&](const QList& expressions)->CAxiomExpression* { return mOntologyBuilder->getObjectPropertyDomainExpression(expressions); }, axiomExpressions);
}));
releaseRedlandTripleStreamWrapper(getPartialStatementFilteredTripleStream(getAdaptedPartialFilteringStatement(processingData->mRedlandNode, nullptr, nullptr, mPartialFilteringStatementForRDFSRangeSuccessors))->forEach([&](librdf_statement* statement) {
librdf_node* object = librdf_statement_get_object(statement);
buildAxiomExpressionFromNode(object, mClassNodeIdentifierDataHash, QList() << processingData->mExpression, [&](const QList& expressions)->CAxiomExpression* { return mOntologyBuilder->getObjectPropertyRangeExpression(expressions); }, axiomExpressions);
}));
releaseRedlandTripleStreamWrapper(getPartialStatementFilteredTripleStream(getAdaptedPartialFilteringStatement(processingData->mRedlandNode, nullptr, nullptr, mPartialFilteringStatementForOWLInverseOfSuccessors))->forEach([&](librdf_statement* statement) {
librdf_node* object = librdf_statement_get_object(statement);
buildAxiomExpressionFromNode(object, mObjectPropertyNodeIdentifierDataHash, QList() << processingData->mExpression, [&](const QList& expressions)->CAxiomExpression* { return mOntologyBuilder->getInverseObjectProperties(expressions); }, axiomExpressions);
}));
}
return this;
}
CConcreteOntologyRedlandTriplesDataExpressionMapper* CConcreteOntologyRedlandTriplesDataExpressionMapper::collectDataPropertyBasedAxiomExpressions(CRedlandNodeProcessingData* processingData, QList& axiomExpressions) {
if (processingData->mExpression) {
// TODO: if there are too many successor triples, then use the other method, which directly filters by the corresponding predicates
// create/use forEachAsLong/forEachLimited
releaseRedlandTripleStreamWrapper(getPartialStatementFilteredTripleStream(getAdaptedPartialFilteringStatement(processingData->mRedlandNode, nullptr, nullptr, mPartialFilteringStatementForOWLAxioms))->forEach([&](librdf_statement* statement) {
librdf_node* predicate = librdf_statement_get_predicate(statement);
librdf_node* object = librdf_statement_get_object(statement);
cint64 predicateIndex = mPropertyBasedAxiomPredicateIndexHash.value(CRedlandNodeHasher(predicate), -1);
if (predicateIndex >= 0) {
QList expressionList;
expressionList.append(processingData->mExpression);
switch (predicateIndex) {
case mOWLPredicateBasedAxiomSubPropertyOfPredicateIndex:
buildAxiomExpressionFromNode(object, mDataPropertyNodeIdentifierDataHash, expressionList, [&](const QList& expressions)->CAxiomExpression* { return mOntologyBuilder->getSubDataPropertyOf(expressions); }, axiomExpressions);
break;
case mOWLPredicateBasedAxiomEquivalentPropertyPredicateIndex:
buildAxiomExpressionFromNode(object, mDataPropertyNodeIdentifierDataHash, expressionList, [&](const QList& expressions)->CAxiomExpression* { return mOntologyBuilder->getEquivalentDataProperties(expressions); }, axiomExpressions);
break;
case mOWLPredicateBasedAxiomPropertyDisjointWithPredicateIndex:
buildAxiomExpressionFromNode(object, mDataPropertyNodeIdentifierDataHash, expressionList, [&](const QList& expressions)->CAxiomExpression* { return mOntologyBuilder->getDisjointDataProperties(expressions); }, axiomExpressions);
break;
case mOWLPredicateBasedAxiomDomainPredicateIndex:
buildAxiomExpressionFromNode(object, mClassNodeIdentifierDataHash, expressionList, [&](const QList& expressions)->CAxiomExpression* { return mOntologyBuilder->getDataPropertyDomainExpression(expressions); }, axiomExpressions);
break;
case mOWLPredicateBasedAxiomRangePredicateIndex:
buildAxiomExpressionFromNode(object, mDatatypeNodeIdentifierDataHash, expressionList, [&](const QList& expressions)->CAxiomExpression* { return mOntologyBuilder->getDataPropertyRangeExpression(expressions); }, axiomExpressions);
break;
case mRDFPredicateBasedAxiomTypeOfPredicateIndex:
cint64 objectIndex = mPropertyBasedAxiomObjectIndexHash.value(CRedlandNodeHasher(object), -1);
if (objectIndex >= 0) {
switch (objectIndex) {
case mOWLPredicateBasedAxiomTypeFunctionalPropertyObjectIndex:
axiomExpressions.append(mOntologyBuilder->getFunctionalDataProperty(processingData->mExpression));
break;
}
}
break;
}
}
}));
}
return this;
}
CConcreteOntologyRedlandTriplesDataExpressionMapper* CConcreteOntologyRedlandTriplesDataExpressionMapper::collectDataPropertyBasedAxiomExpressionsBySuccessorRetrieval(CRedlandNodeProcessingData* processingData, QList& axiomExpressions) {
if (processingData->mExpression) {
releaseRedlandTripleStreamWrapper(getPartialStatementFilteredTripleStream(getAdaptedPartialFilteringStatement(processingData->mRedlandNode, nullptr, nullptr, mPartialFilteringStatementForRDFSSubPropertySuccessors))->forEach([&](librdf_statement* statement) {
librdf_node* object = librdf_statement_get_object(statement);
buildAxiomExpressionFromNode(object, mDataPropertyNodeIdentifierDataHash, QList() << processingData->mExpression, [&](const QList& expressions)->CAxiomExpression* { return mOntologyBuilder->getSubDataPropertyOf(expressions); }, axiomExpressions);
}));
releaseRedlandTripleStreamWrapper(getPartialStatementFilteredTripleStream(getAdaptedPartialFilteringStatement(processingData->mRedlandNode, nullptr, nullptr, mPartialFilteringStatementForOWLEquivalentPropertySuccessors))->forEach([&](librdf_statement* statement) {
librdf_node* object = librdf_statement_get_object(statement);
buildAxiomExpressionFromNode(object, mDataPropertyNodeIdentifierDataHash, QList() << processingData->mExpression, [&](const QList& expressions)->CAxiomExpression* { return mOntologyBuilder->getEquivalentDataProperties(expressions); }, axiomExpressions);
}));
releaseRedlandTripleStreamWrapper(getPartialStatementFilteredTripleStream(getAdaptedPartialFilteringStatement(processingData->mRedlandNode, nullptr, nullptr, mPartialFilteringStatementForOWLPropertyDisjointWithSuccessors))->forEach([&](librdf_statement* statement) {
librdf_node* object = librdf_statement_get_object(statement);
buildAxiomExpressionFromNode(object, mDataPropertyNodeIdentifierDataHash, QList() << processingData->mExpression, [&](const QList& expressions)->CAxiomExpression* { return mOntologyBuilder->getDisjointDataProperties(expressions); }, axiomExpressions);
}));
releaseRedlandTripleStreamWrapper(getPartialStatementFilteredTripleStream(getAdaptedPartialFilteringStatement(processingData->mRedlandNode, nullptr, nullptr, mPartialFilteringStatementForRDFSDomainSuccessors))->forEach([&](librdf_statement* statement) {
librdf_node* object = librdf_statement_get_object(statement);
buildAxiomExpressionFromNode(object, mClassNodeIdentifierDataHash, QList() << processingData->mExpression, [&](const QList& expressions)->CAxiomExpression* { return mOntologyBuilder->getDataPropertyDomainExpression(expressions); }, axiomExpressions);
}));
releaseRedlandTripleStreamWrapper(getPartialStatementFilteredTripleStream(getAdaptedPartialFilteringStatement(processingData->mRedlandNode, nullptr, nullptr, mPartialFilteringStatementForRDFSRangeSuccessors))->forEach([&](librdf_statement* statement) {
librdf_node* object = librdf_statement_get_object(statement);
buildAxiomExpressionFromNode(object, mDatatypeNodeIdentifierDataHash, QList() << processingData->mExpression, [&](const QList& expressions)->CAxiomExpression* {
return mOntologyBuilder->getDataPropertyRangeExpression(expressions);
}, axiomExpressions);
}));
}
return this;
}
CConcreteOntologyRedlandTriplesDataExpressionMapper* CConcreteOntologyRedlandTriplesDataExpressionMapper::buildAxiomExpressionFromNode(librdf_node* node, QHash& nodeIdentifierDataHash, QList& expressionList, function&)> buildFunction, QList& axiomExpressions) {
cint64 prevSize = expressionList.size();
collectBuildExpressionsFromNode(node, nodeIdentifierDataHash, expressionList);
CAxiomExpression* axiomExpression = buildFunction(expressionList);
if (axiomExpression) {
axiomExpressions.append(axiomExpression);
}
while (expressionList.size() > prevSize) {
expressionList.removeLast();
}
return this;
}
CConcreteOntologyRedlandTriplesDataExpressionMapper* CConcreteOntologyRedlandTriplesDataExpressionMapper::buildAxiomExpressionFromRDFNodeList(librdf_node* listNode, QHash& nodeIdentifierDataHash, QList& expressionList, function&)> buildFunction, QList& axiomExpressions) {
cint64 prevSize = expressionList.size();
collectBuildExpressionsFromRDFNodeList(listNode, nodeIdentifierDataHash, expressionList);
CAxiomExpression* axiomExpression = buildFunction(expressionList);
if (axiomExpression) {
axiomExpressions.append(axiomExpression);
}
while (expressionList.size() > prevSize) {
expressionList.removeLast();
}
return this;
}
CConcreteOntologyRedlandTriplesDataExpressionMapper* CConcreteOntologyRedlandTriplesDataExpressionMapper::buildAxiomExpressionFromRDFNodeListWithNewHandling(librdf_node* listNode, QHash& nodeIdentifierDataHash, function newHandlingFunc, QList& expressionList, function&)> buildFunction, QList& axiomExpressions) {
cint64 prevSize = expressionList.size();
collectBuildExpressionsFromRDFNodeListWithNewHandling(listNode, nodeIdentifierDataHash, newHandlingFunc, expressionList);
CAxiomExpression* axiomExpression = buildFunction(expressionList);
if (axiomExpression) {
axiomExpressions.append(axiomExpression);
}
while (expressionList.size() > prevSize) {
expressionList.removeLast();
}
return this;
}
CConcreteOntologyRedlandTriplesDataExpressionMapper* CConcreteOntologyRedlandTriplesDataExpressionMapper::buildObjectPropertyExpressions() {
for (CRedlandNodeProcessingData* nextProcessingData : mObjectPropertyNodeHandlingList) {
nextProcessingData->mDependendRedlandNodeProcessingDataList = getNodeProcessingDataListFromNodeStreamWithNewHandling(getOWLObjectInverseOfPredecessorNodesStream(nextProcessingData->mRedlandNode), mObjectPropertyNodeIdentifierDataHash, [&](librdf_node* node)->CRedlandNodeProcessingData* {
CRedlandNodeProcessingData* processingData = nullptr;
CBuildExpression* expression = nullptr;
if (librdf_node_is_blank(node)) {
expression = mOntologyBuilder->getInverseObjectPropertyOf(nextProcessingData->mExpression);
processingData = new CRedlandNodeProcessingData(node, expression);
}
return processingData;
});
if (nextProcessingData->mDependendRedlandNodeProcessingDataList) {
delete nextProcessingData->mDependendRedlandNodeProcessingDataList;
nextProcessingData->mDependendRedlandNodeProcessingDataList = nullptr;
}
}
return this;
}
CConcreteOntologyRedlandTriplesDataExpressionMapper* CConcreteOntologyRedlandTriplesDataExpressionMapper::buildDataRangeExpressions() {
if (mConfSuccessorRetrieval) {
buildExpressions(&mDatatypeNodeHandlingList, [&](CRedlandNodeProcessingData* processingData) { collectDataRangeExpressionDependenciesBySuccessorRetrieval(processingData); });
} else {
buildExpressions(&mDatatypeNodeHandlingList, [&](CRedlandNodeProcessingData* processingData) { collectDataRangeExpressionDependencies(processingData); });
}
return this;
}
CConcreteOntologyRedlandTriplesDataExpressionMapper* CConcreteOntologyRedlandTriplesDataExpressionMapper::buildClassExpressions() {
if (mConfSuccessorRetrieval) {
buildExpressions(&mClassNodeHandlingList, [&](CRedlandNodeProcessingData* processingData) { collectClassExpressionDependenciesBySuccessorRetrieval(processingData); });
} else {
buildExpressions(&mClassNodeHandlingList, [&](CRedlandNodeProcessingData* processingData) { collectClassExpressionDependencies(processingData); });
}
return this;
}
CConcreteOntologyRedlandTriplesDataExpressionMapper* CConcreteOntologyRedlandTriplesDataExpressionMapper::buildExpressions(QList* nodeHandlingList, function dependenciesCollectionFunction) {
QStack processingStack;
QList dependentBuildExpressionList;
for (CRedlandNodeProcessingData* nextProcessingData : *nodeHandlingList) {
if (!nextProcessingData->mStacked && !nextProcessingData->mExpression) {
nextProcessingData->mStacked = true;
processingStack.push(nextProcessingData);
while (!processingStack.isEmpty()) {
CRedlandNodeProcessingData* processingData = processingStack.top();
bool buildingPossible = false;
if (!processingData->mExpression && !processingData->mProcessed) {
dependenciesCollectionFunction(processingData);
bool stackedProcessing = false;
if (processingData->mDependendRedlandNodeProcessingDataList) {
for (CRedlandNodeProcessingData* dependentProcessingData : *processingData->mDependendRedlandNodeProcessingDataList) {
if (!dependentProcessingData->mExpression && !dependentProcessingData->mStacked) {
processingStack.push(dependentProcessingData);
dependentProcessingData->mStacked = true;
stackedProcessing = true;
}
}
if (!stackedProcessing) {
buildingPossible = true;
}
} else {
// probably an error, not clear how to build expression
//TODO: print warning/error message
buildingPossible = true;
}
processingData->mProcessed = true;
} else {
buildingPossible = true;
}
if (buildingPossible) {
processingStack.pop();
if (processingData->mExpressionBuildFunc) {
dependentBuildExpressionList.clear();
if (processingData->mDependendRedlandNodeProcessingDataList) {
for (CRedlandNodeProcessingData* dependentProcessingData : *processingData->mDependendRedlandNodeProcessingDataList) {
if (dependentProcessingData->mExpression) {
dependentBuildExpressionList.append(dependentProcessingData->mExpression);
}
}
//delete processingData->mDependendRedlandNodeProcessingDataList;
}
//processingData->mDependendRedlandNodeProcessingDataList = nullptr;
processingData->mExpression = processingData->mExpressionBuildFunc(dependentBuildExpressionList);
processingData->mBuilt = true;
processingData->mDependendRedlandNodeProcessingDataList = nullptr;
}
}
}
}
}
return this;
}
CConcreteOntologyRedlandTriplesDataExpressionMapper* CConcreteOntologyRedlandTriplesDataExpressionMapper::collectDataRangeExpressionDependencies(CRedlandNodeProcessingData* processingData) {
if (!processingData->mExpression) {
librdf_node* dataRangePredicateObjectArray[mOWLDataRangePredicateMaxIndex];
for (cint64 i = 0; i < mOWLDataRangePredicateMaxIndex; ++i) {
dataRangePredicateObjectArray[i] = nullptr;
}
// TODO: if there are too many successor triples, then use the other method, which directly filters by the corresponding predicates
// create/use forEachAsLong/forEachLimited
releaseRedlandTripleStreamWrapper(getPartialStatementFilteredTripleStream(getAdaptedPartialFilteringStatement(processingData->mRedlandNode, nullptr, nullptr, mPartialFilteringStatementForOWLDataRanges))->forEach([&](librdf_statement* statement) {
librdf_node* predicate = librdf_statement_get_predicate(statement);
librdf_node* object = librdf_statement_get_object(statement);
cint64 index = mDataRangePredicateIndexHash.value(CRedlandNodeHasher(predicate), -1);
if (index >= 0 && !dataRangePredicateObjectArray[index]) {
dataRangePredicateObjectArray[index] = librdf_new_node_from_node(object);
}
}));
// data intersection of
if (!processingData->mExpressionBuildFunc && !processingData->mDependendRedlandNodeProcessingDataList && dataRangePredicateObjectArray[mOWLIntersectionOfPredicateIndex]) {
librdf_node* listNode = dataRangePredicateObjectArray[mOWLIntersectionOfPredicateIndex];
processingData->mDependendRedlandNodeProcessingDataList = getRDFListElementNodesAsProcessingDataList(listNode, mDatatypeNodeIdentifierDataHash, processingData->mDependendRedlandNodeProcessingDataList);
processingData->mExpressionBuildFunc = [&](const QList& expressions)->CBuildExpression* { return mOntologyBuilder->getDataIntersectionOf(expressions); };
}
// data union of
if (!processingData->mExpressionBuildFunc && !processingData->mDependendRedlandNodeProcessingDataList && dataRangePredicateObjectArray[mOWLUnionOfPredicateIndex]) {
librdf_node* listNode = dataRangePredicateObjectArray[mOWLUnionOfPredicateIndex];
processingData->mDependendRedlandNodeProcessingDataList = getRDFListElementNodesAsProcessingDataList(listNode, mDatatypeNodeIdentifierDataHash, processingData->mDependendRedlandNodeProcessingDataList);
processingData->mExpressionBuildFunc = [&](const QList& expressions)->CBuildExpression* { return mOntologyBuilder->getDataUnionOf(expressions); };
}
// data complement of
if (!processingData->mExpressionBuildFunc && !processingData->mDependendRedlandNodeProcessingDataList && dataRangePredicateObjectArray[mOWLDatatypeComplementOfPredicateIndex]) {
processingData->mDependendRedlandNodeProcessingDataList = getNodeProcessingDataListFromNode(dataRangePredicateObjectArray[mOWLDatatypeComplementOfPredicateIndex], mDatatypeNodeIdentifierDataHash);
if (processingData->mDependendRedlandNodeProcessingDataList) {
processingData->mExpressionBuildFunc = [&](const QList& expressions)->CBuildExpression* { return mOntologyBuilder->getDataComplementOf(expressions); };
}
}
// data one of
if (!processingData->mExpressionBuildFunc && !processingData->mDependendRedlandNodeProcessingDataList && dataRangePredicateObjectArray[mOWLOneOfPredicateIndex]) {
librdf_node* listNode = dataRangePredicateObjectArray[mOWLOneOfPredicateIndex];
processingData->mDependendRedlandNodeProcessingDataList = getRDFListElementNodesAsProcessingDataListWithNewHandling(listNode, mDataLiteralNodeIdentifierDataHash, [&](librdf_node* node)->CRedlandNodeProcessingData* { return createLiteralValueProcessingData(node); });
processingData->mExpressionBuildFunc = [&](const QList& expressions)->CBuildExpression* { return mOntologyBuilder->getDataOneOf(expressions); };
}
// datatype restriction
if (!processingData->mExpressionBuildFunc && !processingData->mDependendRedlandNodeProcessingDataList && dataRangePredicateObjectArray[mOWLOnDatatypePredicateIndex] && dataRangePredicateObjectArray[mOWLWithRestrictionPredicateIndex]) {
processingData->mDependendRedlandNodeProcessingDataList = getNodeProcessingDataListFromNode(dataRangePredicateObjectArray[mOWLOnDatatypePredicateIndex], mDatatypeNodeIdentifierDataHash);
if (processingData->mDependendRedlandNodeProcessingDataList) {
QList* facetNodeList = getOWLListElementNodesList(dataRangePredicateObjectArray[mOWLWithRestrictionPredicateIndex]);
if (facetNodeList) {
for (librdf_node* facetNode : *facetNodeList) {
releaseRedlandTripleStreamWrapper(getPartialStatementFilteredTripleStream(getAdaptedPartialFilteringStatement(facetNode, nullptr, nullptr, mPartialFilteringStatementForOWLFacets))->forEach([&](librdf_statement* statement) {
librdf_node* objectNode = librdf_statement_get_object(statement);
librdf_node* predicateNode = librdf_statement_get_predicate(statement);
if (librdf_node_is_literal(objectNode) && librdf_node_is_resource(predicateNode)) {
CDataLiteralExpression* datLitExp = (CDataLiteralExpression*)createLiteralValueProcessingData(objectNode)->mExpression;
const char* facetUri = (const char*)librdf_uri_as_string(librdf_node_get_uri(predicateNode));
CDataFacetExpression* dataFacetExp = mOntologyBuilder->getDataFacet(QString::fromUtf8(facetUri));
CDataFacetRestrictionExpression* dataFacetRestExp = mOntologyBuilder->getDataFacetRestriction(datLitExp, dataFacetExp);
CRedlandNodeProcessingData* tmpProcessignData = new CRedlandNodeProcessingData(facetNode, dataFacetRestExp);
processingData->mDependendRedlandNodeProcessingDataList->append(tmpProcessignData);
mDataFacetRestrictionHandlingContainerList.append(tmpProcessignData);
}
}));
}
delete facetNodeList;
}
processingData->mExpressionBuildFunc = [&](const QList& expressions)->CBuildExpression* { return mOntologyBuilder->getDatatypeRestriction(expressions); };
}
}
for (cint64 i = 0; i < mOWLDataRangePredicateMaxIndex; ++i) {
if (dataRangePredicateObjectArray[i]) {
librdf_free_node(dataRangePredicateObjectArray[i]);
}
}
}
return this;
}
CConcreteOntologyRedlandTriplesDataExpressionMapper* CConcreteOntologyRedlandTriplesDataExpressionMapper::collectDataRangeExpressionDependenciesBySuccessorRetrieval(CRedlandNodeProcessingData* processingData) {
if (!processingData->mExpression) {
// data intersection of
if (!processingData->mExpressionBuildFunc && !processingData->mDependendRedlandNodeProcessingDataList) {
releaseRedlandNodeStreamWrapper(getOWLIntersectionOfSuccessorNodesStream(processingData->mRedlandNode)->forEach([&](librdf_node* listNode) {
processingData->mDependendRedlandNodeProcessingDataList = getRDFListElementNodesAsProcessingDataList(listNode, mDatatypeNodeIdentifierDataHash, processingData->mDependendRedlandNodeProcessingDataList);
processingData->mExpressionBuildFunc = [&](const QList& expressions)->CBuildExpression* { return mOntologyBuilder->getDataIntersectionOf(expressions); };
}));
}
// data union of
if (!processingData->mExpressionBuildFunc && !processingData->mDependendRedlandNodeProcessingDataList) {
releaseRedlandNodeStreamWrapper(getOWLUnionOfSuccessorNodesStream(processingData->mRedlandNode)->forEach([&](librdf_node* listNode) {
processingData->mDependendRedlandNodeProcessingDataList = getRDFListElementNodesAsProcessingDataList(listNode, mDatatypeNodeIdentifierDataHash, processingData->mDependendRedlandNodeProcessingDataList);
processingData->mExpressionBuildFunc = [&](const QList& expressions)->CBuildExpression* { return mOntologyBuilder->getDataUnionOf(expressions); };
}));
}
// data complement of
if (!processingData->mExpressionBuildFunc && !processingData->mDependendRedlandNodeProcessingDataList) {
processingData->mDependendRedlandNodeProcessingDataList = getNodeProcessingDataListFromNodeStream(getOWLDatatypeComplementOfSuccessorNodesStream(processingData->mRedlandNode), mDatatypeNodeIdentifierDataHash);
if (processingData->mDependendRedlandNodeProcessingDataList) {
processingData->mExpressionBuildFunc = [&](const QList& expressions)->CBuildExpression* { return mOntologyBuilder->getDataComplementOf(expressions); };
}
}
// data one of
if (!processingData->mExpressionBuildFunc && !processingData->mDependendRedlandNodeProcessingDataList) {
releaseRedlandNodeStreamWrapper(getOWLOneOfSuccessorNodesStream(processingData->mRedlandNode)->forEach([&](librdf_node* listNode) {
processingData->mDependendRedlandNodeProcessingDataList = getRDFListElementNodesAsProcessingDataListWithNewHandling(listNode, mDataLiteralNodeIdentifierDataHash, [&](librdf_node* node)->CRedlandNodeProcessingData* { return createLiteralValueProcessingData(node); });
processingData->mExpressionBuildFunc = [&](const QList& expressions)->CBuildExpression* { return mOntologyBuilder->getDataOneOf(expressions); };
}));
}
// datatype restriction
if (!processingData->mExpressionBuildFunc && !processingData->mDependendRedlandNodeProcessingDataList) {
processingData->mDependendRedlandNodeProcessingDataList = getNodeProcessingDataListFromNodeStream(getOWLOnDatatypeSuccessorNodesStream(processingData->mRedlandNode), mDatatypeNodeIdentifierDataHash);
if (processingData->mDependendRedlandNodeProcessingDataList) {
QList* facetNodeList = nullptr;
releaseRedlandNodeStreamWrapper(getOWLWithRestrictionSuccessorNodesStream(processingData->mRedlandNode)->forEach([&](librdf_node* node) {
facetNodeList = getOWLListElementNodesList(node, facetNodeList);
}));
if (facetNodeList) {
for (librdf_node* facetNode : *facetNodeList) {
for (QHash::const_iterator it = mFacetUriNodeHash.constBegin(), itEnd = mFacetUriNodeHash.constEnd(); it != itEnd; ++it) {
const char* facetUri = it.key();
librdf_node* facetUriNode = it.value();
collectDataFacetExpressionBySuccessorRetrieval(processingData, facetNode, facetUriNode, facetUri);
}
}
delete facetNodeList;
}
processingData->mExpressionBuildFunc = [&](const QList& expressions)->CBuildExpression* { return mOntologyBuilder->getDatatypeRestriction(expressions); };
}
}
}
return this;
}
CConcreteOntologyRedlandTriplesDataExpressionMapper* CConcreteOntologyRedlandTriplesDataExpressionMapper::collectDataFacetExpressionBySuccessorRetrieval(CRedlandNodeProcessingData* processingData, librdf_node* node, librdf_node* facetNode, const char* facetUri) {
releaseRedlandTripleStreamWrapper(getPartialStatementFilteredTripleStream(getAdaptedPartialFilteringStatement(node, facetNode, nullptr, mPartialFilteringStatementForOWLFacetSuccessors))->forEach([&](librdf_statement* statement) {
librdf_node* objectNode = librdf_statement_get_object(statement);
if (librdf_node_is_literal(objectNode)) {
CDataLiteralExpression* datLitExp = (CDataLiteralExpression*)createLiteralValueProcessingData(objectNode)->mExpression;
CDataFacetExpression* dataFacetExp = mOntologyBuilder->getDataFacet(QString::fromUtf8(facetUri));
CDataFacetRestrictionExpression* dataFacetRestExp = mOntologyBuilder->getDataFacetRestriction(datLitExp, dataFacetExp);
CRedlandNodeProcessingData* tmpProcessignData = new CRedlandNodeProcessingData(node, dataFacetRestExp);
processingData->mDependendRedlandNodeProcessingDataList->append(tmpProcessignData);
mDataFacetRestrictionHandlingContainerList.append(tmpProcessignData);
}
}));
return this;
}
CConcreteOntologyRedlandTriplesDataExpressionMapper* CConcreteOntologyRedlandTriplesDataExpressionMapper::collectClassExpressionDependencies(CRedlandNodeProcessingData* processingData) {
if (!processingData->mExpression) {
librdf_node* classPredicateObjectArray[mOWLPredicateMaxIndex];
for (cint64 i = 0; i < mOWLPredicateMaxIndex; ++i) {
classPredicateObjectArray[i] = nullptr;
}
// TODO: if there are too many successor triples that do not match, then use the other method, which directly filters by the corresponding predicates
// create/use forEachAsLong/forEachLimited
releaseRedlandTripleStreamWrapper(getPartialStatementFilteredTripleStream(getAdaptedPartialFilteringStatement(processingData->mRedlandNode, nullptr, nullptr, mPartialFilteringStatementForOWLClasses))->forEach([&](librdf_statement* statement) {
librdf_node* predicate = librdf_statement_get_predicate(statement);
librdf_node* object = librdf_statement_get_object(statement);
cint64 index = mClassPredicateIndexHash.value(CRedlandNodeHasher(predicate), -1);
if (index >= 0 && !classPredicateObjectArray[index]) {
classPredicateObjectArray[index] = librdf_new_node_from_node(object);
}
}));
// object intersection of
if (!processingData->mExpressionBuildFunc && !processingData->mDependendRedlandNodeProcessingDataList && classPredicateObjectArray[mOWLIntersectionOfPredicateIndex]) {
librdf_node* listNode = classPredicateObjectArray[mOWLIntersectionOfPredicateIndex];
processingData->mDependendRedlandNodeProcessingDataList = getRDFListElementNodesAsProcessingDataList(listNode, mClassNodeIdentifierDataHash, processingData->mDependendRedlandNodeProcessingDataList);
processingData->mExpressionBuildFunc = [&](const QList& expressions)->CBuildExpression* { return mOntologyBuilder->getObjectIntersectionOf(expressions); };
}
// object union of
if (!processingData->mExpressionBuildFunc && !processingData->mDependendRedlandNodeProcessingDataList && classPredicateObjectArray[mOWLUnionOfPredicateIndex]) {
librdf_node* listNode = classPredicateObjectArray[mOWLUnionOfPredicateIndex];
processingData->mDependendRedlandNodeProcessingDataList = getRDFListElementNodesAsProcessingDataList(listNode, mClassNodeIdentifierDataHash, processingData->mDependendRedlandNodeProcessingDataList);
processingData->mExpressionBuildFunc = [&](const QList& expressions)->CBuildExpression* { return mOntologyBuilder->getObjectUnionOf(expressions); };
}
// object complement of
if (!processingData->mExpressionBuildFunc && !processingData->mDependendRedlandNodeProcessingDataList && classPredicateObjectArray[mOWLComplementOfPredicateIndex]) {
processingData->mDependendRedlandNodeProcessingDataList = getNodeProcessingDataListFromNode(classPredicateObjectArray[mOWLComplementOfPredicateIndex], mClassNodeIdentifierDataHash);
if (processingData->mDependendRedlandNodeProcessingDataList) {
processingData->mExpressionBuildFunc = [&](const QList& expressions)->CBuildExpression* { return mOntologyBuilder->getObjectComplementOf(expressions); };
}
}
// object one of
if (!processingData->mExpressionBuildFunc && !processingData->mDependendRedlandNodeProcessingDataList && classPredicateObjectArray[mOWLOneOfPredicateIndex]) {
librdf_node* listNode = classPredicateObjectArray[mOWLOneOfPredicateIndex];
processingData->mDependendRedlandNodeProcessingDataList = getRDFListElementNodesAsProcessingDataListWithNewHandling(listNode, mNamedIndividualNodeIdentifierDataHash, [&](librdf_node* node)->CRedlandNodeProcessingData* { return createNamedIndividualProcessingData(node); });
processingData->mExpressionBuildFunc = [&](const QList& expressions)->CBuildExpression* { return mOntologyBuilder->getObjectOneOf(expressions); };
}
// restrictions
if (!processingData->mExpressionBuildFunc && !processingData->mDependendRedlandNodeProcessingDataList && classPredicateObjectArray[mOWLOnPropertyPredicateIndex]) {
QHash* nodeDataHash = nullptr;
bool dataPropertyNodeUsed = false;
processingData->mDependendRedlandNodeProcessingDataList = getNodeProcessingDataListFromObjectORDataPropertyNode(classPredicateObjectArray[mOWLOnPropertyPredicateIndex], &dataPropertyNodeUsed, &nodeDataHash, processingData->mDependendRedlandNodeProcessingDataList);
if (processingData->mDependendRedlandNodeProcessingDataList) {
// object/data some value from
if (!processingData->mExpressionBuildFunc && classPredicateObjectArray[mOWLSomeValuesFromPredicateIndex]) {
processingData->mDependendRedlandNodeProcessingDataList = getNodeProcessingDataListFromNode(classPredicateObjectArray[mOWLSomeValuesFromPredicateIndex], *nodeDataHash, processingData->mDependendRedlandNodeProcessingDataList);
if (dataPropertyNodeUsed) {
processingData->mExpressionBuildFunc = [&](const QList& expressions)->CBuildExpression* { return mOntologyBuilder->getDataSomeValuesFrom(expressions); };
} else {
processingData->mExpressionBuildFunc = [&](const QList& expressions)->CBuildExpression* { return mOntologyBuilder->getObjectSomeValuesFrom(expressions); };
}
}
// object/data some value from
if (!processingData->mExpressionBuildFunc && classPredicateObjectArray[mOWLAllValuesFromPredicateIndex]) {
processingData->mDependendRedlandNodeProcessingDataList = getNodeProcessingDataListFromNode(classPredicateObjectArray[mOWLAllValuesFromPredicateIndex], *nodeDataHash, processingData->mDependendRedlandNodeProcessingDataList);
if (dataPropertyNodeUsed) {
processingData->mExpressionBuildFunc = [&](const QList& expressions)->CBuildExpression* { return mOntologyBuilder->getDataAllValuesFrom(expressions); };
} else {
processingData->mExpressionBuildFunc = [&](const QList& expressions)->CBuildExpression* { return mOntologyBuilder->getObjectAllValuesFrom(expressions); };
}
}
// object/data has value
if (!processingData->mExpressionBuildFunc && classPredicateObjectArray[mOWLHasValuePredicateIndex]) {
if (!dataPropertyNodeUsed) {
processingData->mDependendRedlandNodeProcessingDataList = getNodeProcessingDataListFromNodeWithNewHandling(classPredicateObjectArray[mOWLHasValuePredicateIndex], mNamedIndividualNodeIdentifierDataHash, [&](librdf_node* node)->CRedlandNodeProcessingData* { return createNamedIndividualProcessingData(node); }, processingData->mDependendRedlandNodeProcessingDataList);
processingData->mExpressionBuildFunc = [&](const QList& expressions)->CBuildExpression* { return mOntologyBuilder->getObjectHasValue(expressions); };
} else {
processingData->mDependendRedlandNodeProcessingDataList = getNodeProcessingDataListFromNodeWithNewHandling(classPredicateObjectArray[mOWLHasValuePredicateIndex], mDataLiteralNodeIdentifierDataHash, [&](librdf_node* node)->CRedlandNodeProcessingData* { return createLiteralValueProcessingData(node); }, processingData->mDependendRedlandNodeProcessingDataList);
processingData->mExpressionBuildFunc = [&](const QList& expressions)->CBuildExpression* { return mOntologyBuilder->getDataHasValue(expressions); };
}
}
// object has self
if (!processingData->mExpressionBuildFunc && classPredicateObjectArray[mOWLHasSelfPredicateIndex]) {
if (!dataPropertyNodeUsed) {
if (checkHasBooleanTrueLiteralValue(classPredicateObjectArray[mOWLHasSelfPredicateIndex])) {
processingData->mExpressionBuildFunc = [&](const QList& expressions)->CBuildExpression* { return mOntologyBuilder->getObjectHasSelf(expressions); };
}
}
}
// qualified cardinality restrictions
if (!processingData->mExpressionBuildFunc && (classPredicateObjectArray[mOWLOnClassPredicateIndex] || classPredicateObjectArray[mOWLOnDataRangePredicateIndex])) {
cint64 prevDepSize = processingData->mDependendRedlandNodeProcessingDataList->size();
if (!dataPropertyNodeUsed) {
processingData->mDependendRedlandNodeProcessingDataList = getNodeProcessingDataListFromNode(classPredicateObjectArray[mOWLOnClassPredicateIndex], mClassNodeIdentifierDataHash, processingData->mDependendRedlandNodeProcessingDataList);
} else {
processingData->mDependendRedlandNodeProcessingDataList = getNodeProcessingDataListFromNode(classPredicateObjectArray[mOWLOnDataRangePredicateIndex], mDatatypeNodeIdentifierDataHash, processingData->mDependendRedlandNodeProcessingDataList);
}
if (processingData->mDependendRedlandNodeProcessingDataList->size() > prevDepSize) {
if (!processingData->mExpressionBuildFunc && classPredicateObjectArray[mOWLMinQualifiedCardinalityPredicateIndex]) {
cint64 minCardinality = getNonNegativeNumberFromLiteralValue(classPredicateObjectArray[mOWLMinQualifiedCardinalityPredicateIndex]);
if (minCardinality >= 0) {
if (!dataPropertyNodeUsed) {
processingData->mExpressionBuildFunc = [minCardinality, this](const QList& expressions)->CBuildExpression* { return mOntologyBuilder->getObjectMinCardinality(expressions, minCardinality); };
} else {
processingData->mExpressionBuildFunc = [minCardinality, this](const QList& expressions)->CBuildExpression* { return mOntologyBuilder->getDataMinCardinality(expressions, minCardinality); };
}
}
}
if (!processingData->mExpressionBuildFunc && classPredicateObjectArray[mOWLMaxQualifiedCardinalityPredicateIndex]) {
cint64 maxCardinality = getNonNegativeNumberFromLiteralValue(classPredicateObjectArray[mOWLMaxQualifiedCardinalityPredicateIndex]);
if (maxCardinality >= 0) {
if (!dataPropertyNodeUsed) {
processingData->mExpressionBuildFunc = [maxCardinality, this](const QList& expressions)->CBuildExpression* { return mOntologyBuilder->getObjectMaxCardinality(expressions, maxCardinality); };
} else {
processingData->mExpressionBuildFunc = [maxCardinality, this](const QList& expressions)->CBuildExpression* { return mOntologyBuilder->getDataMaxCardinality(expressions, maxCardinality); };
}
}
}
if (!processingData->mExpressionBuildFunc && classPredicateObjectArray[mOWLQualifiedCardinalityPredicateIndex]) {
cint64 cardinality = getNonNegativeNumberFromLiteralValue(classPredicateObjectArray[mOWLQualifiedCardinalityPredicateIndex]);
if (cardinality >= 0) {
if (!dataPropertyNodeUsed) {
processingData->mExpressionBuildFunc = [cardinality, this](const QList& expressions)->CBuildExpression* { return mOntologyBuilder->getObjectExactlyCardinality(expressions, cardinality); };
} else {
processingData->mExpressionBuildFunc = [cardinality, this](const QList& expressions)->CBuildExpression* { return mOntologyBuilder->getDataExactCardinality(expressions, cardinality); };
}
}
}
}
if (!processingData->mExpressionBuildFunc) {
while (processingData->mDependendRedlandNodeProcessingDataList->size() > prevDepSize) {
processingData->mDependendRedlandNodeProcessingDataList->removeLast();
}
}
}
// unqualified cardinality restrictions
if (!processingData->mExpressionBuildFunc && !dataPropertyNodeUsed) {
if (!processingData->mExpressionBuildFunc && classPredicateObjectArray[mOWLMinCardinalityPredicateIndex]) {
cint64 minCardinality = getNonNegativeNumberFromLiteralValue(classPredicateObjectArray[mOWLMinCardinalityPredicateIndex]);
if (minCardinality >= 0) {
if (!dataPropertyNodeUsed) {
processingData->mExpressionBuildFunc = [minCardinality, this](const QList& expressions)->CBuildExpression* { return mOntologyBuilder->getObjectMinCardinality(expressions, minCardinality); };
} else {
processingData->mExpressionBuildFunc = [minCardinality, this](const QList& expressions)->CBuildExpression* { return mOntologyBuilder->getDataMinCardinality(expressions, minCardinality); };
}
}
}
if (!processingData->mExpressionBuildFunc && classPredicateObjectArray[mOWLMaxCardinalityPredicateIndex]) {
cint64 maxCardinality = getNonNegativeNumberFromLiteralValue(classPredicateObjectArray[mOWLMaxCardinalityPredicateIndex]);
if (maxCardinality >= 0) {
if (!dataPropertyNodeUsed) {
processingData->mExpressionBuildFunc = [maxCardinality, this](const QList& expressions)->CBuildExpression* { return mOntologyBuilder->getObjectMaxCardinality(expressions, maxCardinality); };
} else {
processingData->mExpressionBuildFunc = [maxCardinality, this](const QList& expressions)->CBuildExpression* { return mOntologyBuilder->getDataMaxCardinality(expressions, maxCardinality); };
}
}
}
if (!processingData->mExpressionBuildFunc && classPredicateObjectArray[mOWLCardinalityPredicateIndex]) {
cint64 cardinality = getNonNegativeNumberFromLiteralValue(classPredicateObjectArray[mOWLCardinalityPredicateIndex]);
if (cardinality >= 0) {
if (!dataPropertyNodeUsed) {
processingData->mExpressionBuildFunc = [cardinality, this](const QList& expressions)->CBuildExpression* { return mOntologyBuilder->getObjectExactlyCardinality(expressions, cardinality); };
} else {
processingData->mExpressionBuildFunc = [cardinality, this](const QList& expressions)->CBuildExpression* { return mOntologyBuilder->getDataExactCardinality(expressions, cardinality); };
}
}
}
}
}
if (!processingData->mExpressionBuildFunc) {
delete processingData->mDependendRedlandNodeProcessingDataList;
processingData->mDependendRedlandNodeProcessingDataList = nullptr;
}
}
}
return this;
}
CConcreteOntologyRedlandTriplesDataExpressionMapper* CConcreteOntologyRedlandTriplesDataExpressionMapper::collectClassExpressionDependenciesBySuccessorRetrieval(CRedlandNodeProcessingData* processingData) {
if (!processingData->mExpression) {
// object intersection of
if (!processingData->mExpressionBuildFunc && !processingData->mDependendRedlandNodeProcessingDataList) {
releaseRedlandNodeStreamWrapper(getOWLIntersectionOfSuccessorNodesStream(processingData->mRedlandNode)->forEach([&](librdf_node* listNode) {
processingData->mDependendRedlandNodeProcessingDataList = getRDFListElementNodesAsProcessingDataList(listNode, mClassNodeIdentifierDataHash);
if (processingData->mDependendRedlandNodeProcessingDataList->isEmpty()) {
processingData->mDependendRedlandNodeProcessingDataList = getRDFListElementNodesAsProcessingDataList(listNode, mClassNodeIdentifierDataHash);
processingData->mDependendRedlandNodeProcessingDataList = getRDFListElementNodesAsProcessingDataList(listNode, mClassNodeIdentifierDataHash);
processingData->mDependendRedlandNodeProcessingDataList = getRDFListElementNodesAsProcessingDataList(listNode, mClassNodeIdentifierDataHash);
}
processingData->mExpressionBuildFunc = [&](const QList& expressions)->CBuildExpression* { return mOntologyBuilder->getObjectIntersectionOf(expressions); };
}));
}
// object union of
if (!processingData->mExpressionBuildFunc && !processingData->mDependendRedlandNodeProcessingDataList) {
releaseRedlandNodeStreamWrapper(getOWLUnionOfSuccessorNodesStream(processingData->mRedlandNode)->forEach([&](librdf_node* listNode) {
processingData->mDependendRedlandNodeProcessingDataList = getRDFListElementNodesAsProcessingDataList(listNode, mClassNodeIdentifierDataHash);
processingData->mExpressionBuildFunc = [&](const QList& expressions)->CBuildExpression* { return mOntologyBuilder->getObjectUnionOf(expressions); };
}));
}
// object complement of
if (!processingData->mExpressionBuildFunc && !processingData->mDependendRedlandNodeProcessingDataList) {
processingData->mDependendRedlandNodeProcessingDataList = getNodeProcessingDataListFromNodeStream(getOWLComplementOfSuccessorNodesStream(processingData->mRedlandNode), mClassNodeIdentifierDataHash);
if (processingData->mDependendRedlandNodeProcessingDataList) {
processingData->mExpressionBuildFunc = [&](const QList& expressions)->CBuildExpression* { return mOntologyBuilder->getObjectComplementOf(expressions); };
}
}
// object one of
if (!processingData->mExpressionBuildFunc && !processingData->mDependendRedlandNodeProcessingDataList) {
releaseRedlandNodeStreamWrapper(getOWLOneOfSuccessorNodesStream(processingData->mRedlandNode)->forEach([&](librdf_node* listNode) {
processingData->mDependendRedlandNodeProcessingDataList = getRDFListElementNodesAsProcessingDataListWithNewHandling(listNode, mNamedIndividualNodeIdentifierDataHash, [&](librdf_node* node)->CRedlandNodeProcessingData* { return createNamedIndividualProcessingData(node); });
processingData->mExpressionBuildFunc = [&](const QList& expressions)->CBuildExpression* { return mOntologyBuilder->getObjectOneOf(expressions); };
}));
}
// restriction
if (!processingData->mExpressionBuildFunc && !processingData->mDependendRedlandNodeProcessingDataList) {
QHash* nodeDataHash = nullptr;
bool dataPropertyNodeUsed = false;
bool onPropertyPresent = collectClassExpressionOnPropertyDependenciesReturnPresence(processingData, &dataPropertyNodeUsed, &nodeDataHash);
if (onPropertyPresent && processingData->mDependendRedlandNodeProcessingDataList) {
cint64 onPropertyDepDataCount = processingData->mDependendRedlandNodeProcessingDataList->size();
// object/data some value from
if (!processingData->mExpressionBuildFunc) {
processingData->mDependendRedlandNodeProcessingDataList = getNodeProcessingDataListFromNodeStream(getOWLSomeValuesFromSuccessorNodesStream(processingData->mRedlandNode), *nodeDataHash, processingData->mDependendRedlandNodeProcessingDataList);
if (processingData->mDependendRedlandNodeProcessingDataList->size() > onPropertyDepDataCount) {
if (dataPropertyNodeUsed) {
processingData->mExpressionBuildFunc = [&](const QList& expressions)->CBuildExpression* { return mOntologyBuilder->getDataSomeValuesFrom(expressions); };
} else {
processingData->mExpressionBuildFunc = [&](const QList& expressions)->CBuildExpression* { return mOntologyBuilder->getObjectSomeValuesFrom(expressions); };
}
}
}
// object/data add value from
if (!processingData->mExpressionBuildFunc) {
processingData->mDependendRedlandNodeProcessingDataList = getNodeProcessingDataListFromNodeStream(getOWLAllValuesFromSuccessorNodesStream(processingData->mRedlandNode), *nodeDataHash, processingData->mDependendRedlandNodeProcessingDataList);
if (processingData->mDependendRedlandNodeProcessingDataList->size() > onPropertyDepDataCount) {
if (dataPropertyNodeUsed) {
processingData->mExpressionBuildFunc = [&](const QList& expressions)->CBuildExpression* { return mOntologyBuilder->getDataAllValuesFrom(expressions); };
} else {
processingData->mExpressionBuildFunc = [&](const QList& expressions)->CBuildExpression* { return mOntologyBuilder->getObjectAllValuesFrom(expressions); };
}
}
}
// object/data has value
if (!processingData->mExpressionBuildFunc) {
if (dataPropertyNodeUsed) {
processingData->mDependendRedlandNodeProcessingDataList = getNodeProcessingDataListFromNodeStreamWithNewHandling(getOWLHasValueSuccessorNodesStream(processingData->mRedlandNode), mDataLiteralNodeIdentifierDataHash, [&](librdf_node* node)->CRedlandNodeProcessingData* { return createLiteralValueProcessingData(node); }, processingData->mDependendRedlandNodeProcessingDataList);
} else {
processingData->mDependendRedlandNodeProcessingDataList = getNodeProcessingDataListFromNodeStreamWithNewHandling(getOWLHasValueSuccessorNodesStream(processingData->mRedlandNode), mNamedIndividualNodeIdentifierDataHash, [&](librdf_node* node)->CRedlandNodeProcessingData* { return createNamedIndividualProcessingData(node); }, processingData->mDependendRedlandNodeProcessingDataList);
}
if (processingData->mDependendRedlandNodeProcessingDataList->size() > onPropertyDepDataCount) {
if (dataPropertyNodeUsed) {
processingData->mExpressionBuildFunc = [&](const QList& expressions)->CBuildExpression* { return mOntologyBuilder->getDataHasValue(expressions); };
} else {
processingData->mExpressionBuildFunc = [&](const QList& expressions)->CBuildExpression* { return mOntologyBuilder->getObjectHasValue(expressions); };
}
}
}
// object has self
if (!processingData->mExpressionBuildFunc && !dataPropertyNodeUsed) {
releaseRedlandNodeStreamWrapper(getOWLHasSelfSuccessorNodesStream(processingData->mRedlandNode)->forEach([&](librdf_node* node) {
if (!processingData->mExpressionBuildFunc && checkHasBooleanTrueLiteralValue(node)) {
processingData->mExpressionBuildFunc = [&](const QList& expressions)->CBuildExpression* { return mOntologyBuilder->getObjectHasSelf(expressions); };
}
}));
}
// cardinalities
if (!processingData->mExpressionBuildFunc) {
if (!dataPropertyNodeUsed) {
processingData->mDependendRedlandNodeProcessingDataList = getNodeProcessingDataListFromNodeStream(getOWLOnClassSuccessorNodesStream(processingData->mRedlandNode), *nodeDataHash, processingData->mDependendRedlandNodeProcessingDataList);
} else {
processingData->mDependendRedlandNodeProcessingDataList = getNodeProcessingDataListFromNodeStream(getOWLOnDataRangeSuccessorNodesStream(processingData->mRedlandNode), *nodeDataHash, processingData->mDependendRedlandNodeProcessingDataList);
}
cint64 onClassOrDataRangeDepDataCount = processingData->mDependendRedlandNodeProcessingDataList->size();
if (!processingData->mExpressionBuildFunc && onClassOrDataRangeDepDataCount > onPropertyDepDataCount) {
// qualified cardinality restrictions
if (!processingData->mExpressionBuildFunc) {
cint64 minCardinality = -1;
releaseRedlandNodeStreamWrapper(getOWLMinQualifiedCardinalitySuccessorNodesStream(processingData->mRedlandNode)->forEach([&](librdf_node* node) {
minCardinality = getNonNegativeNumberFromLiteralValue(node);
}));
if (minCardinality >= 0) {
if (!dataPropertyNodeUsed) {
processingData->mExpressionBuildFunc = [minCardinality, this](const QList& expressions)->CBuildExpression* { return mOntologyBuilder->getObjectMinCardinality(expressions, minCardinality); };
} else {
processingData->mExpressionBuildFunc = [minCardinality, this](const QList& expressions)->CBuildExpression* { return mOntologyBuilder->getDataMinCardinality(expressions, minCardinality); };
}
}
}
if (!processingData->mExpressionBuildFunc) {
cint64 maxCardinality = -1;
releaseRedlandNodeStreamWrapper(getOWLMaxQualifiedCardinalitySuccessorNodesStream(processingData->mRedlandNode)->forEach([&](librdf_node* node) {
maxCardinality = getNonNegativeNumberFromLiteralValue(node);
}));
if (maxCardinality >= 0) {
if (!dataPropertyNodeUsed) {
processingData->mExpressionBuildFunc = [maxCardinality, this](const QList& expressions)->CBuildExpression* { return mOntologyBuilder->getObjectMaxCardinality(expressions, maxCardinality); };
} else {
processingData->mExpressionBuildFunc = [maxCardinality, this](const QList& expressions)->CBuildExpression* { return mOntologyBuilder->getDataMaxCardinality(expressions, maxCardinality); };
}
}
}
if (!processingData->mExpressionBuildFunc) {
cint64 cardinality = -1;
releaseRedlandNodeStreamWrapper(getOWLQualifiedCardinalitySuccessorNodesStream(processingData->mRedlandNode)->forEach([&](librdf_node* node) {
cardinality = getNonNegativeNumberFromLiteralValue(node);
}));
if (!dataPropertyNodeUsed) {
processingData->mExpressionBuildFunc = [cardinality, this](const QList& expressions)->CBuildExpression* { return mOntologyBuilder->getObjectExactlyCardinality(expressions, cardinality); };
} else {
processingData->mExpressionBuildFunc = [cardinality, this](const QList& expressions)->CBuildExpression* { return mOntologyBuilder->getDataExactCardinality(expressions, cardinality); };
}
}
if (!processingData->mExpressionBuildFunc) {
while (processingData->mDependendRedlandNodeProcessingDataList->size() > onPropertyDepDataCount) {
processingData->mDependendRedlandNodeProcessingDataList->removeLast();
}
}
}
if (!processingData->mExpressionBuildFunc) {
// unqualified cardinality restriction
if (!processingData->mExpressionBuildFunc) {
cint64 minCardinality = -1;
releaseRedlandNodeStreamWrapper(getOWLMinCardinalitySuccessorNodesStream(processingData->mRedlandNode)->forEach([&](librdf_node* node) {
minCardinality = getNonNegativeNumberFromLiteralValue(node);
}));
if (minCardinality >= 0) {
if (!dataPropertyNodeUsed) {
processingData->mExpressionBuildFunc = [minCardinality, this](const QList& expressions)->CBuildExpression* { return mOntologyBuilder->getObjectMinCardinality(expressions, minCardinality); };
} else {
processingData->mExpressionBuildFunc = [minCardinality, this](const QList& expressions)->CBuildExpression* { return mOntologyBuilder->getDataMinCardinality(expressions, minCardinality); };
}
}
}
if (!processingData->mExpressionBuildFunc) {
cint64 maxCardinality = -1;
releaseRedlandNodeStreamWrapper(getOWLMaxCardinalitySuccessorNodesStream(processingData->mRedlandNode)->forEach([&](librdf_node* node) {
maxCardinality = getNonNegativeNumberFromLiteralValue(node);
}));
if (maxCardinality >= 0) {
if (!dataPropertyNodeUsed) {
processingData->mExpressionBuildFunc = [maxCardinality, this](const QList& expressions)->CBuildExpression* { return mOntologyBuilder->getObjectMaxCardinality(expressions, maxCardinality); };
} else {
processingData->mExpressionBuildFunc = [maxCardinality, this](const QList& expressions)->CBuildExpression* { return mOntologyBuilder->getDataMaxCardinality(expressions, maxCardinality); };
}
}
}
if (!processingData->mExpressionBuildFunc) {
cint64 cardinality = -1;
releaseRedlandNodeStreamWrapper(getOWLCardinalitySuccessorNodesStream(processingData->mRedlandNode)->forEach([&](librdf_node* node) {
cardinality = getNonNegativeNumberFromLiteralValue(node);
}));
if (cardinality >= 0) {
if (!dataPropertyNodeUsed) {
processingData->mExpressionBuildFunc = [cardinality, this](const QList& expressions)->CBuildExpression* { return mOntologyBuilder->getObjectExactlyCardinality(expressions, cardinality); };
} else {
processingData->mExpressionBuildFunc = [cardinality, this](const QList& expressions)->CBuildExpression* { return mOntologyBuilder->getDataExactCardinality(expressions, cardinality); };
}
}
}
}
} // end cardinality
if (!processingData->mExpressionBuildFunc) {
delete processingData->mDependendRedlandNodeProcessingDataList;
processingData->mDependendRedlandNodeProcessingDataList = nullptr;
}
}
} // end restriction
}
return this;
}
bool CConcreteOntologyRedlandTriplesDataExpressionMapper::checkHasBooleanTrueLiteralValue(librdf_node* node) {
if (librdf_node_is_literal(node)) {
const char* lexicalDataValueString = (const char*)librdf_node_get_literal_value(node);
QString literalValueString = QString::fromUtf8(lexicalDataValueString);
literalValueString = literalValueString.toUpper();
if (literalValueString.compare("TRUE") != 0) {
return false;
}
const char* lexicalDataValueLanguageString = librdf_node_get_literal_value_language(node);
if (lexicalDataValueLanguageString) {
return false;
}
librdf_uri* datatypeUri = librdf_node_get_literal_value_datatype_uri(node);
if (datatypeUri) {
if (librdf_uri_equals(mBooleanDatatypeUri, datatypeUri) == 0) {
return false;
}
} else {
return false;
}
return true;
}
return false;
}
cint64 CConcreteOntologyRedlandTriplesDataExpressionMapper::getNonNegativeNumberFromLiteralValue(librdf_node* node) {
cint64 nonNegativeNumber = -1;
if (librdf_node_is_literal(node)) {
const char* lexicalDataValueString = (const char*)librdf_node_get_literal_value(node);
QString literalValueString = QString::fromUtf8(lexicalDataValueString);
bool parsingSuccess = false;
nonNegativeNumber = literalValueString.toLongLong(&parsingSuccess);
if (!parsingSuccess) {
nonNegativeNumber = -1;
}
}
return nonNegativeNumber;
}
QList* CConcreteOntologyRedlandTriplesDataExpressionMapper::getNodeProcessingDataListFromObjectORDataPropertyNode(librdf_node* node, bool* dataPropertyFlag, QHash** nodeDataHash, QList* extendingList) {
QList* nodesProcessingData = extendingList;
bool dataPropertyNodeUsed = false;
CRedlandNodeHasher hasher(node);
CRedlandNodeProcessingData* processingData = mObjectPropertyNodeIdentifierDataHash.value(hasher);
if (!processingData) {
processingData = mDataPropertyNodeIdentifierDataHash.value(hasher);
if (processingData) {
dataPropertyNodeUsed = true;
}
}
if (processingData) {
if (!nodesProcessingData) {
nodesProcessingData = new QList();
}
nodesProcessingData->append(processingData);
}
if (dataPropertyFlag) {
*dataPropertyFlag = false;
if (dataPropertyNodeUsed) {
*dataPropertyFlag = true;
}
}
if (nodeDataHash) {
*nodeDataHash = &mClassNodeIdentifierDataHash;
if (dataPropertyNodeUsed) {
*nodeDataHash = &mDatatypeNodeIdentifierDataHash;
}
}
return nodesProcessingData;
}
bool CConcreteOntologyRedlandTriplesDataExpressionMapper::collectClassExpressionOnPropertyDependenciesReturnPresence(CRedlandNodeProcessingData* processingData, bool* dataPropertyFlag, QHash** nodeDataHash) {
bool onPropertyPresent = false;
bool dataPropertyNodeUsed = false;
processingData->mDependendRedlandNodeProcessingDataList = getNodeProcessingDataListFromNodeStream(getOWLOnPropertySuccessorNodesStream(processingData->mRedlandNode), [&](librdf_node* node)->CRedlandNodeProcessingData* {
CRedlandNodeHasher hasher(node);
CRedlandNodeProcessingData* processingData = mObjectPropertyNodeIdentifierDataHash.value(hasher);
if (!processingData) {
processingData = mDataPropertyNodeIdentifierDataHash.value(hasher);
if (processingData) {
dataPropertyNodeUsed = true;
}
}
if (processingData) {
onPropertyPresent = true;
}
return processingData;
}, processingData->mDependendRedlandNodeProcessingDataList);
if (dataPropertyFlag) {
*dataPropertyFlag = dataPropertyNodeUsed;
}
if (nodeDataHash) {
*nodeDataHash = &mClassNodeIdentifierDataHash;
if (dataPropertyNodeUsed) {
*nodeDataHash = &mDatatypeNodeIdentifierDataHash;
}
}
return onPropertyPresent;
}
CConcreteOntologyRedlandTriplesDataExpressionMapper::CRedlandNodeProcessingData* CConcreteOntologyRedlandTriplesDataExpressionMapper::createNamedIndividualProcessingData(librdf_node* node) {
CRedlandNodeProcessingData* processingData = nullptr;
CBuildExpression* expression = nullptr;
if (!librdf_node_is_blank(node)) {
librdf_uri* uri = librdf_node_get_uri(node);
const char* uriString = (const char*)librdf_uri_as_string(uri);
expression = mOntologyBuilder->getNamedIndividual(QString::fromUtf8(uriString));
processingData = new CRedlandNodeProcessingData(node, expression);
}
return processingData;
}
CConcreteOntologyRedlandTriplesDataExpressionMapper::CRedlandNodeProcessingData* CConcreteOntologyRedlandTriplesDataExpressionMapper::createLiteralValueProcessingData(librdf_node* node) {
CRedlandNodeProcessingData* processingData = nullptr;
if (librdf_node_is_literal(node)) {
const char* lexicalDataValueString = (const char*)librdf_node_get_literal_value(node);
QString literalValueString = QString::fromUtf8(lexicalDataValueString);
const char* lexicalDataValueLanguageString = librdf_node_get_literal_value_language(node);
if (lexicalDataValueLanguageString) {
literalValueString += QString("@%1").arg(QString::fromUtf8(lexicalDataValueLanguageString));
}
librdf_uri* datatypeUri = librdf_node_get_literal_value_datatype_uri(node);
const char* datatypeUriString = nullptr;
if (datatypeUri) {
datatypeUriString = (const char*)librdf_uri_as_string(datatypeUri);
}
if (!datatypeUriString) {
datatypeUriString = PREFIX_XML_PLAINLITERAL_DATATYPE;
}
CDataLexicalValueExpression* dataLexValueExp = mOntologyBuilder->getDataLexicalValue(literalValueString);
CDatatypeExpression* datatypeExp = mOntologyBuilder->getDatatype(QString::fromUtf8(datatypeUriString));
CDataLiteralExpression* dataLitExp = mOntologyBuilder->getDataLiteral(dataLexValueExp, datatypeExp);
processingData = new CRedlandNodeProcessingData(node, dataLitExp);
}
return processingData;
}
CConcreteOntologyRedlandTriplesDataExpressionMapper* CConcreteOntologyRedlandTriplesDataExpressionMapper::collectBuildExpressionsFromNode(librdf_node* node, QHash& nodeIdentifierDataHash, QList& existingList) {
CRedlandNodeProcessingData* processingData = nodeIdentifierDataHash.value(CRedlandNodeHasher(node));
if (processingData && processingData->mExpression) {
existingList.append(processingData->mExpression);
}
return this;
}
CConcreteOntologyRedlandTriplesDataExpressionMapper* CConcreteOntologyRedlandTriplesDataExpressionMapper::collectBuildExpressionsFromNodeStream(CRedlandNodeStream* nodeStream, QHash& nodeIdentifierDataHash, QList& existingList) {
nodeStream->forEach([&](librdf_node* node) {
collectBuildExpressionsFromNode(node, nodeIdentifierDataHash, existingList);
});
releaseRedlandNodeStreamWrapper(nodeStream);
return this;
}
CConcreteOntologyRedlandTriplesDataExpressionMapper* CConcreteOntologyRedlandTriplesDataExpressionMapper::collectBuildExpressionsFromRDFNodeList(librdf_node* listNode, QHash& nodeIdentifierDataHash, QList& existingList) {
QList listNodes;
listNodes.append(librdf_new_node_from_node(listNode));
while (!listNodes.isEmpty()) {
librdf_node* nextListNode = listNodes.takeFirst();
if (!librdf_node_equals(nextListNode, mRDFNilNode)) {
collectBuildExpressionsFromNodeStream(createRedlandNodeStreamWrapper()->init(getPartialStatementFilteredTripleStream(getAdaptedPartialFilteringStatement(nextListNode, nullptr, nullptr, mPartialFilteringStatementForRDFFirstSuccessors)), 2), nodeIdentifierDataHash, existingList);
releaseRedlandNodeStreamWrapper(createRedlandNodeStreamWrapper()->init(getPartialStatementFilteredTripleStream(getAdaptedPartialFilteringStatement(nextListNode, nullptr, nullptr, mPartialFilteringStatementForRDFRestSuccessors)), 2)->forEach([&](librdf_node* node) {
listNodes.append(librdf_new_node_from_node(node));
}));
}
librdf_free_node(nextListNode);
}
return this;
}
CConcreteOntologyRedlandTriplesDataExpressionMapper* CConcreteOntologyRedlandTriplesDataExpressionMapper::collectBuildExpressionsFromNodeWithNewHandling(librdf_node* node, QHash& nodeIdentifierDataHash, function newHandlingFunc, QList& existingList) {
CRedlandNodeProcessingData* processingData = nodeIdentifierDataHash.value(CRedlandNodeHasher(node));
if (!processingData) {
librdf_node* nodeCopy = librdf_new_node_from_node(node);
processingData = newHandlingFunc(nodeCopy);
if (processingData) {
nodeIdentifierDataHash[CRedlandNodeHasher(nodeCopy)] = processingData;
} else {
librdf_free_node(nodeCopy);
}
}
if (processingData && processingData->mExpression) {
existingList.append(processingData->mExpression);
}
return this;
}
CConcreteOntologyRedlandTriplesDataExpressionMapper* CConcreteOntologyRedlandTriplesDataExpressionMapper::collectBuildExpressionsFromNodeStreamWithNewHandling(CRedlandNodeStream* nodeStream, QHash& nodeIdentifierDataHash, function newHandlingFunc, QList& existingList) {
nodeStream->forEach([&](librdf_node* node) {
collectBuildExpressionsFromNodeWithNewHandling(node, nodeIdentifierDataHash, newHandlingFunc, existingList);
});
releaseRedlandNodeStreamWrapper(nodeStream);
return this;
}
CConcreteOntologyRedlandTriplesDataExpressionMapper* CConcreteOntologyRedlandTriplesDataExpressionMapper::collectBuildExpressionsFromRDFNodeListWithNewHandling(librdf_node* listNode, QHash& nodeIdentifierDataHash, function newHandlingFunc, QList& existingList) {
QList listNodes;
listNodes.append(librdf_new_node_from_node(listNode));
while (!listNodes.isEmpty()) {
librdf_node* nextListNode = listNodes.takeFirst();
if (!librdf_node_equals(nextListNode, mRDFNilNode)) {
collectBuildExpressionsFromNodeStreamWithNewHandling(createRedlandNodeStreamWrapper()->init(getPartialStatementFilteredTripleStream(getAdaptedPartialFilteringStatement(nextListNode, nullptr, nullptr, mPartialFilteringStatementForRDFFirstSuccessors)), 2), nodeIdentifierDataHash, newHandlingFunc, existingList);
releaseRedlandNodeStreamWrapper(createRedlandNodeStreamWrapper()->init(getPartialStatementFilteredTripleStream(getAdaptedPartialFilteringStatement(nextListNode, nullptr, nullptr, mPartialFilteringStatementForRDFRestSuccessors)), 2)->forEach([&](librdf_node* node) {
listNodes.append(librdf_new_node_from_node(node));
}));
}
librdf_free_node(nextListNode);
}
return this;
}
QList* CConcreteOntologyRedlandTriplesDataExpressionMapper::getNodeProcessingDataListFromNode(librdf_node* node, QHash& nodeIdentifierDataHash, QList* existingList) {
QList* nodesProcessingData = existingList;
CRedlandNodeProcessingData* processingData = nodeIdentifierDataHash.value(CRedlandNodeHasher(node));
if (processingData) {
if (!nodesProcessingData) {
nodesProcessingData = new QList();
}
nodesProcessingData->append(processingData);
}
return nodesProcessingData;
}
QList* CConcreteOntologyRedlandTriplesDataExpressionMapper::getNodeProcessingDataListFromNodeStream(CRedlandNodeStream* nodeStream, QHash