/*
* Copyright (C) 2013-2015, 2019 by the Konclude Developer Team.
*
* This file is part of the reasoning system Konclude.
* For details and support, see .
*
* Konclude is free software: you can redistribute it and/or modify
* it under the terms of version 3 of the GNU Lesser General Public
* License (LGPLv3) as published by the Free Software Foundation.
*
* Konclude is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU (Lesser) General Public License for more details.
*
* You should have received a copy of the GNU (Lesser) General Public
* License along with Konclude. If not, see .
*
*/
#include "CConceptNominalSchemaGroundingHandler.h"
namespace Konclude {
namespace Reasoner {
namespace Kernel {
namespace Algorithm {
CConceptNominalSchemaGroundingHandler::CConceptNominalSchemaGroundingHandler() {
mConfReuseGroundedNominalSchemaConcepts = true;
}
CSortedNegLinker* CConceptNominalSchemaGroundingHandler::getGroundingConceptLinker(CIndividualProcessNode* processNode, CPropagationBindingSet* propBindSet, CConcept* concept, bool negated, CPROCESSINGHASH*& groundedConPropBindDesHash, CPROCESSINGHASH*& additionalPropBindDesHash, CCalculationAlgorithmContext* calcAlgContext) {
CSortedNegLinker* newLinker = nullptr;
mDataBox = calcAlgContext->getUsedProcessingDataBox();
CProcessContext* context = calcAlgContext->getUsedProcessContext();
mMemMan = calcAlgContext->getUsedProcessTaskMemoryAllocationManager();
CMBox* mBox = mDataBox->getOntology()->getDataBoxes()->getMBox();
mTBox = mDataBox->getOntology()->getDataBoxes()->getTBox();
mConceptVec = mDataBox->getExtendedConceptVector(false);
mReplaceHash = mDataBox->getConceptNominalSchemaGroundingHash(false);
CNominalSchemaTemplateVector* nomSchVec = mBox->getNominalSchemaTemplateVector(false);
mLocalizedExtensions = false;
CPROCESSINGHASH nominalSchemaVarBindedNominalHash(calcAlgContext->getUsedTaskProcessorContext());
CPROCESSINGSET* allNominalConceptSet = nullptr;
cint64 nomSchTemplID = concept->getParameter();
if (nomSchVec) {
CNominalSchemaTemplate* nomSchTempl = nomSchVec->getData(nomSchTemplID);
CConcept* templateConcept = nomSchTempl->getTemplateConcept();
CBOXHASH* templateConceptNomSchVarHash = nomSchTempl->getTemplateConceptNominalSchemaConceptHash();
CBOXSET* templateConceptNomSchVarSet = nomSchTempl->getNominalSchemaConceptSet();
CPropagationBindingMap* propBindMap = propBindSet->getPropagationBindingMap();
for (CPropagationBindingMap::iterator it = propBindMap->begin(), itEnd = propBindMap->end(); it != itEnd; ++it) {
CPropagationBindingMapData& propBindData = it.value();
CPropagationBindingDescriptor* propBindDes = propBindData.getPropagationBindingDescriptor();
CPropagationBinding* propBinding = propBindDes->getPropagationBinding();
CVariable* variable = propBinding->getBindedVariable();
CIndividualProcessNode* bindedIndiNode = propBinding->getBindedIndividual();
if (variable->isNominalVariable()) {
CConcept* nomSchVarConcept = variable->getNominalVariableConcept();
if (templateConceptNomSchVarSet->contains(nomSchVarConcept)) {
CConcept* nominalConcept = getNominalConcept(bindedIndiNode,true,calcAlgContext);
if (nominalConcept) {
nominalSchemaVarBindedNominalHash.insertMulti(nomSchVarConcept,TConceptPropagationBindingPair(nominalConcept,propBindDes));
}
}
}
}
for (CBOXSET::iterator it = templateConceptNomSchVarSet->begin(), itEnd = templateConceptNomSchVarSet->end(); it != itEnd; ++it) {
CConcept* nomSchVarConcept = *it;
if (!nominalSchemaVarBindedNominalHash.contains(nomSchVarConcept)) {
collectAllNominalConcepts(allNominalConceptSet,calcAlgContext);
for (CPROCESSINGSET::const_iterator nomIt = allNominalConceptSet->constBegin(), nomItEnd = allNominalConceptSet->constEnd(); nomIt != nomItEnd; ++nomIt) {
CConcept* nominalConcept(*nomIt);
nominalSchemaVarBindedNominalHash.insertMulti(nomSchVarConcept,TConceptPropagationBindingPair(nominalConcept,nullptr));
}
}
}
newLinker = createNominalSchemaGroundingConcepts(processNode,nomSchTempl->getTemplateConcept(),negated,&nominalSchemaVarBindedNominalHash,groundedConPropBindDesHash,nomSchTempl,calcAlgContext);
if (newLinker) {
if (!additionalPropBindDesHash) {
additionalPropBindDesHash = CObjectParameterizingAllocator< CPROCESSINGHASH,CContext* >::allocateAndConstructAndParameterize(calcAlgContext->getUsedTemporaryMemoryAllocationManager(),calcAlgContext->getUsedTaskProcessorContext());;
}
for (CPropagationBindingMap::iterator it = propBindMap->begin(), itEnd = propBindMap->end(); it != itEnd; ++it) {
CPropagationBindingMapData& propBindData = it.value();
CPropagationBindingDescriptor* propBindDes = propBindData.getPropagationBindingDescriptor();
CPropagationBinding* propBinding = propBindDes->getPropagationBinding();
CVariable* variable = propBinding->getBindedVariable();
additionalPropBindDesHash->insert(variable,propBindDes);
}
}
}
return newLinker;
}
void CConceptNominalSchemaGroundingHandler::collectAllNominalConcepts(CPROCESSINGSET*& allNominalConceptSet, CCalculationAlgorithmContext* calcAlgContext) {
if (!allNominalConceptSet) {
allNominalConceptSet = CObjectParameterizingAllocator< CPROCESSINGSET,CContext* >::allocateAndConstructAndParameterize(calcAlgContext->getUsedTemporaryMemoryAllocationManager(),calcAlgContext->getUsedTaskProcessorContext());
CIndividualVector* individualVector = calcAlgContext->getProcessingDataBox()->getOntology()->getABox()->getIndividualVector(false);
cint64 individualCount = 0;
if (individualVector) {
individualCount = individualVector->getItemCount();
// TODO: only active individuals
for (cint64 i = 0; i < individualCount; ++i) {
CIndividual* individual = individualVector->getData(i);
for (CConceptAssertionLinker* assConLinkerIt = individual->getAssertionConceptLinker(); assConLinkerIt; assConLinkerIt = assConLinkerIt->getNext()) {
CConcept* assCon = assConLinkerIt->getData();
bool assConNegation = assConLinkerIt->isNegated();
cint64 assConOpCode = assCon->getOperatorCode();
if (!assConNegation && assConOpCode == CCNOMINAL) {
allNominalConceptSet->insert(assCon);
}
}
}
}
}
}
CConcept* CConceptNominalSchemaGroundingHandler::getNominalConcept(CIndividualProcessNode* processNode, bool forceNotPruned, CCalculationAlgorithmContext* calcAlgContext) {
CIndividualProcessNodeVector* mIndiVector = calcAlgContext->getUsedProcessingDataBox()->getIndividualProcessNodeVector();
CIndividualProcessNode* indiNode = mIndiVector->getData(processNode->getIndividualNodeID());
//while (indiNode->getIndividualID() != indiNode->getMergedIntoIndividualNodeID()) {
// indiNode = mIndiVector->getData(indiNode->getMergedIntoIndividualNodeID());
//}
CConcept* nomConcept = nullptr;
if (!forceNotPruned || !indiNode->hasPartialProcessingRestrictionFlags(CIndividualProcessNode::PRFPURGEDBLOCKED)) {
CIndividual* nomIndi = indiNode->getNominalIndividual();
CConceptAssertionLinker* assLinker = nomIndi->getAssertionConceptLinker();
while (assLinker && !nomConcept) {
CConcept* assConcept = assLinker->getData();
bool assNegation = assLinker->isNegated();
if (!assNegation && assConcept->getOperatorCode() == CCNOMINAL) {
nomConcept = assConcept;
}
assLinker = assLinker->getNext();
}
}
return nomConcept;
}
void CConceptNominalSchemaGroundingHandler::addConceptOperand(CConcept* concept, CConcept* opConcept, bool negated) {
CSortedNegLinker* opConLinker = CObjectAllocator< CSortedNegLinker >::allocateAndConstruct(mMemMan);
opConLinker->init(opConcept,negated);
concept->addOperandLinker(opConLinker);
concept->incOperandCount();
}
CConcept* CConceptNominalSchemaGroundingHandler::createNominalSchemaConceptCopy(CConcept* concept) {
CConcept* conceptCopy = CObjectAllocator< CConcept >::allocateAndConstruct(mMemMan);
conceptCopy->initConceptCopy(concept);
conceptCopy->setOperandCount(0);
conceptCopy->setConceptTag(mConceptVec->getItemCount());
mConceptVec->setData(conceptCopy->getConceptTag(),conceptCopy);
return conceptCopy;
}
CConcept* CConceptNominalSchemaGroundingHandler::createGroundedNominalSchemaConcept(CConcept* concept, CBOXHASH* templConNomSchConHash, QHash::const_iterator >* nomSchConIndividualItHash, CCalculationAlgorithmContext* calcAlgContext) {
if (templConNomSchConHash->contains(concept)) {
cint64 opCode = concept->getOperatorCode();
if (opCode == CCNOMVAR) {
CPROCESSINGHASH::const_iterator nomVarIt = nomSchConIndividualItHash->value(concept);
CConcept* nominalConcept = nomVarIt.value().first;
return nominalConcept;
}
if (mConfReuseGroundedNominalSchemaConcepts && mReplaceHash) {
CConceptNominalSchemaGroundingData mHashedTestData(calcAlgContext->getUsedTaskProcessorContext());
mHashedTestData.setGroundingConcept(concept);
CBOXHASH::const_iterator it = templConNomSchConHash->constFind(concept), itEnd = templConNomSchConHash->constEnd();
while (it != itEnd && it.key() == concept) {
CConcept* nomSchemConcept = *it;
CPROCESSINGHASH::const_iterator nomVarIt = nomSchConIndividualItHash->value(nomSchemConcept);
CConcept* indiConcept = nomVarIt.value().first;
mHashedTestData.addBindedNominalSchemaConcept(indiConcept);
++it;
}
CConceptNominalSchemaGroundingData* replaceConData = mReplaceHash->value(CConceptNominalSchemaGroundingHasher(&mHashedTestData),nullptr);
if (replaceConData) {
return replaceConData->getGroundedConcept();
}
}
forceExtensionLocalisation(calcAlgContext);
CConcept* copiedConcept = createNominalSchemaConceptCopy(concept);
for (CSortedNegLinker* opConLinkerIt = concept->getOperandList(); opConLinkerIt; opConLinkerIt = opConLinkerIt->getNext()) {
CConcept* opConcept = opConLinkerIt->getData();
bool opConNegation = opConLinkerIt->isNegated();
CConcept* newOpConcept = createGroundedNominalSchemaConcept(opConcept,templConNomSchConHash,nomSchConIndividualItHash,calcAlgContext);
addConceptOperand(copiedConcept,newOpConcept,opConNegation);
}
if (mConfReuseGroundedNominalSchemaConcepts) {
CConceptNominalSchemaGroundingData* mHashedTestData = CObjectParameterizingAllocator< CConceptNominalSchemaGroundingData,CProcessContext* >::allocateAndConstructAndParameterize(mMemMan,calcAlgContext->getUsedProcessContext());
mHashedTestData->setGroundingConcept(concept);
CBOXHASH::const_iterator it = templConNomSchConHash->constFind(concept), itEnd = templConNomSchConHash->constEnd();
while (it != itEnd && it.key() == concept) {
CConcept* nomSchemConcept = *it;
CPROCESSINGHASH::const_iterator nomVarIt = nomSchConIndividualItHash->value(nomSchemConcept);
CConcept* indiConcept = nomVarIt.value().first;
mHashedTestData->addBindedNominalSchemaConcept(indiConcept);
++it;
}
mHashedTestData->setGroundedConcept(copiedConcept);
mReplaceHash->insert(CConceptNominalSchemaGroundingHasher(mHashedTestData),mHashedTestData);
}
return copiedConcept;
} else {
return concept;
}
}
bool CConceptNominalSchemaGroundingHandler::forceExtensionLocalisation(CCalculationAlgorithmContext* calcAlgContext) {
if (!mLocalizedExtensions) {
mLocalizedExtensions = true;
mConceptVec = mDataBox->getExtendedConceptVector(true);
mReplaceHash = mDataBox->getConceptNominalSchemaGroundingHash(true);
return true;
}
return false;
}
CSortedNegLinker* CConceptNominalSchemaGroundingHandler::createNominalSchemaGroundingConcepts(CIndividualProcessNode* indiProcessNode, CConcept* concept, bool negated, CPROCESSINGHASH* nominalSchemaVarBindedNominalHash, CPROCESSINGHASH*& groundedConPropBindDesHash, CNominalSchemaTemplate* nsTemplate, CCalculationAlgorithmContext* calcAlgContext) {
CSortedNegLinker* newGroundedConLinker = nullptr;
CReapplyConceptLabelSet* conLabelSet = indiProcessNode->getReapplyConceptLabelSet(false);
CBOXHASH* templConNomSchConHash = nsTemplate->getTemplateConceptNominalSchemaConceptHash();
CBOXSET* nomSchConSet = nsTemplate->getNominalSchemaConceptSet();
QHash::const_iterator > nomSchConIndividualItHash;
CPROCESSINGHASH::const_iterator indiItEnd = nominalSchemaVarBindedNominalHash->constEnd();
for (CBOXSET::const_iterator it = nomSchConSet->constBegin(), itEnd = nomSchConSet->constEnd(); it != itEnd; ++it) {
CConcept* nomSchCon(*it);
CPROCESSINGHASH::const_iterator indiIt = nominalSchemaVarBindedNominalHash->constFind(nomSchCon);
nomSchConIndividualItHash.insert(nomSchCon,indiIt);
}
bool conVarItFinished = false;
while (!conVarItFinished) {
CConcept* templateConcept = nsTemplate->getTemplateConcept();
CSortedNegLinker* opConLinker = createGroundedNominalSchemaConcept(templateConcept,negated,conLabelSet,templConNomSchConHash,&nomSchConIndividualItHash,calcAlgContext);
if (opConLinker) {
if (!groundedConPropBindDesHash) {
groundedConPropBindDesHash = CObjectParameterizingAllocator< CPROCESSINGHASH,CContext* >::allocateAndConstructAndParameterize(calcAlgContext->getUsedTemporaryMemoryAllocationManager(),calcAlgContext->getUsedTaskProcessorContext());
}
QHash::const_iterator >::const_iterator variableIt = nomSchConIndividualItHash.constBegin(), variableItEnd = nomSchConIndividualItHash.constEnd();
while (variableIt != variableItEnd) {
CPROCESSINGHASH::const_iterator nomBindIt = variableIt.value();
CPropagationBindingDescriptor* bindedDes = nomBindIt.value().second;
if (bindedDes) {
for (CSortedNegLinker* opConLinkerIt = opConLinker; opConLinkerIt; opConLinkerIt = opConLinkerIt->getNext()) {
CConcept* groundedConcept = opConLinkerIt->getData();
groundedConPropBindDesHash->insertMulti(groundedConcept,bindedDes);
}
}
++variableIt;
}
newGroundedConLinker = opConLinker->append(newGroundedConLinker);
}
QHash::const_iterator >::const_iterator variableIt = nomSchConIndividualItHash.constBegin();
QHash::const_iterator >::const_iterator variableItEnd = nomSchConIndividualItHash.constEnd();
CPROCESSINGHASH::const_iterator varIndiIt = variableIt.value();
CConcept* varConcept = variableIt.key();
++varIndiIt;
bool conVarIteration = true;
while ((varIndiIt == indiItEnd || varIndiIt.key() != varConcept) && conVarIteration) {
conVarIteration = false;
CPROCESSINGHASH::const_iterator indiIt = nominalSchemaVarBindedNominalHash->constFind(varConcept);
nomSchConIndividualItHash.insert(varConcept,indiIt);
++variableIt;
if (variableIt == variableItEnd) {
conVarItFinished = true;
} else {
varIndiIt = variableIt.value();
varConcept = variableIt.key();
++varIndiIt;
if (varIndiIt == indiItEnd) {
conVarIteration = true;
}
}
}
if (!conVarItFinished) {
nomSchConIndividualItHash.insert(varConcept,varIndiIt);
}
}
return newGroundedConLinker;
}
CSortedNegLinker* CConceptNominalSchemaGroundingHandler::getGroundingConceptLinker(CIndividualProcessNode* processNode, CVariableBindingPathSet* varBindPathSet, CConcept* concept, bool negated, CPROCESSINGHASH*& groundedConVarBindPathDesHash, CCalculationAlgorithmContext* calcAlgContext) {
CSortedNegLinker* newLinker = nullptr;
mDataBox = calcAlgContext->getUsedProcessingDataBox();
CProcessContext* context = calcAlgContext->getUsedProcessContext();
mMemMan = calcAlgContext->getUsedProcessTaskMemoryAllocationManager();
CMBox* mBox = mDataBox->getOntology()->getDataBoxes()->getMBox();
mTBox = mDataBox->getOntology()->getDataBoxes()->getTBox();
mConceptVec = mDataBox->getExtendedConceptVector(false);
mReplaceHash = mDataBox->getConceptNominalSchemaGroundingHash(false);
CNominalSchemaTemplateVector* nomSchVec = mBox->getNominalSchemaTemplateVector(false);
mLocalizedExtensions = false;
cint64 nomSchTemplID = concept->getParameter();
if (nomSchVec) {
CNominalSchemaTemplate* nomSchTempl = nomSchVec->getData(nomSchTemplID);
CConcept* templateConcept = nomSchTempl->getTemplateConcept();
CBOXHASH* templateConceptNomSchVarHash = nomSchTempl->getTemplateConceptNominalSchemaConceptHash();
CBOXSET* templateConceptNomSchVarSet = nomSchTempl->getNominalSchemaConceptSet();
CVariableBindingPathMap* varBindPathMap = varBindPathSet->getVariableBindingPathMap();
for (CVariableBindingPathMap::iterator it = varBindPathMap->begin(), itEnd = varBindPathMap->end(); it != itEnd; ++it) {
CVariableBindingPathMapData& varBindPathData = it.value();
CVariableBindingPathDescriptor* varBindPathDes = varBindPathData.getVariableBindingPathDescriptor();
CVariableBindingPath* varBindPath = varBindPathDes->getVariableBindingPath();
CPROCESSINGHASH nominalSchemaVarBindedNominalHash(calcAlgContext->getUsedTaskProcessorContext());
CPROCESSINGSET* allNominalConceptSet = nullptr;
for (CVariableBindingDescriptor* varBindDesIt = varBindPath->getVariableBindingDescriptorLinker(); varBindDesIt; varBindDesIt = varBindDesIt->getNext()) {
CVariableBinding* varBind = varBindDesIt->getVariableBinding();
CVariable* variable = varBind->getBindedVariable();
CIndividualProcessNode* bindedIndiNode = varBind->getBindedIndividual();
if (variable->isNominalVariable()) {
CConcept* nomSchVarConcept = variable->getNominalVariableConcept();
if (templateConceptNomSchVarSet->contains(nomSchVarConcept)) {
CConcept* nominalConcept = getNominalConcept(bindedIndiNode,false,calcAlgContext);
if (nominalConcept) {
nominalSchemaVarBindedNominalHash.insertMulti(nomSchVarConcept,TConceptPropagationBindingPair(nominalConcept,nullptr));
}
}
}
}
for (CBOXSET::iterator it = templateConceptNomSchVarSet->begin(), itEnd = templateConceptNomSchVarSet->end(); it != itEnd; ++it) {
CConcept* nomSchVarConcept = *it;
if (!nominalSchemaVarBindedNominalHash.contains(nomSchVarConcept)) {
collectAllNominalConcepts(allNominalConceptSet,calcAlgContext);
for (CPROCESSINGSET::const_iterator nomIt = allNominalConceptSet->constBegin(), nomItEnd = allNominalConceptSet->constEnd(); nomIt != nomItEnd; ++nomIt) {
CConcept* nominalConcept(*nomIt);
nominalSchemaVarBindedNominalHash.insertMulti(nomSchVarConcept,TConceptPropagationBindingPair(nominalConcept,nullptr));
}
}
}
CSortedNegLinker* tmpNewLinker = createNominalSchemaGroundingConcepts(processNode,nomSchTempl->getTemplateConcept(),negated,&nominalSchemaVarBindedNominalHash,nomSchTempl,calcAlgContext);
if (tmpNewLinker) {
for (CSortedNegLinker* tmpNewLinkerIt = tmpNewLinker; tmpNewLinkerIt; tmpNewLinkerIt = tmpNewLinkerIt->getNext()) {
CConcept* concept = tmpNewLinkerIt->getData();
if (!groundedConVarBindPathDesHash) {
groundedConVarBindPathDesHash = CObjectParameterizingAllocator< CPROCESSINGHASH,CContext* >::allocateAndConstructAndParameterize(calcAlgContext->getUsedTemporaryMemoryAllocationManager(),calcAlgContext->getUsedTaskProcessorContext());
}
groundedConVarBindPathDesHash->insert(concept,varBindPathDes);
}
newLinker = tmpNewLinker->append(newLinker);
}
}
}
return newLinker;
}
CSortedNegLinker* CConceptNominalSchemaGroundingHandler::getGroundingConceptLinker(CIndividualProcessNode* processNode, CRepresentativeVariableBindingPathMap* repVarBindPathSetMap, CConcept* concept, bool negated, CPROCESSINGHASH*& groundedConVarBindPathHash, CCalculationAlgorithmContext* calcAlgContext) {
CSortedNegLinker* newLinker = nullptr;
mDataBox = calcAlgContext->getUsedProcessingDataBox();
CProcessContext* context = calcAlgContext->getUsedProcessContext();
mMemMan = calcAlgContext->getUsedProcessTaskMemoryAllocationManager();
CMBox* mBox = mDataBox->getOntology()->getDataBoxes()->getMBox();
CTBox* tBox = mDataBox->getOntology()->getDataBoxes()->getTBox();
mConceptVec = mDataBox->getExtendedConceptVector(false);
mReplaceHash = mDataBox->getConceptNominalSchemaGroundingHash(false);
CNominalSchemaTemplateVector* nomSchVec = mBox->getNominalSchemaTemplateVector(false);
mLocalizedExtensions = false;
cint64 nomSchTemplID = concept->getParameter();
if (nomSchVec) {
CNominalSchemaTemplate* nomSchTempl = nomSchVec->getData(nomSchTemplID);
CConcept* templateConcept = nomSchTempl->getTemplateConcept();
CBOXHASH* templateConceptNomSchVarHash = nomSchTempl->getTemplateConceptNominalSchemaConceptHash();
CBOXSET* templateConceptNomSchVarSet = nomSchTempl->getNominalSchemaConceptSet();
for (CRepresentativeVariableBindingPathMap::const_iterator it = repVarBindPathSetMap->constBegin(), itEnd = repVarBindPathSetMap->constEnd(); it != itEnd; ++it) {
const CRepresentativeVariableBindingPathMapData& varBindPathData = it.value();
CVariableBindingPath* varBindPath = varBindPathData.getVariableBindingPath();
CPROCESSINGHASH nominalSchemaVarBindedNominalHash(calcAlgContext->getUsedTaskProcessorContext());
CPROCESSINGSET* allNominalConceptSet = nullptr;
for (CVariableBindingDescriptor* varBindDesIt = varBindPath->getVariableBindingDescriptorLinker(); varBindDesIt; varBindDesIt = varBindDesIt->getNext()) {
CVariableBinding* varBind = varBindDesIt->getVariableBinding();
CVariable* variable = varBind->getBindedVariable();
CIndividualProcessNode* bindedIndiNode = varBind->getBindedIndividual();
if (variable->isNominalVariable()) {
CConcept* nomSchVarConcept = variable->getNominalVariableConcept();
if (templateConceptNomSchVarSet->contains(nomSchVarConcept)) {
CConcept* nominalConcept = getNominalConcept(bindedIndiNode,false,calcAlgContext);
if (nominalConcept) {
nominalSchemaVarBindedNominalHash.insertMulti(nomSchVarConcept,TConceptPropagationBindingPair(nominalConcept,nullptr));
}
}
}
}
for (CBOXSET::iterator it = templateConceptNomSchVarSet->begin(), itEnd = templateConceptNomSchVarSet->end(); it != itEnd; ++it) {
CConcept* nomSchVarConcept = *it;
if (!nominalSchemaVarBindedNominalHash.contains(nomSchVarConcept)) {
collectAllNominalConcepts(allNominalConceptSet,calcAlgContext);
for (CPROCESSINGSET::const_iterator nomIt = allNominalConceptSet->constBegin(), nomItEnd = allNominalConceptSet->constEnd(); nomIt != nomItEnd; ++nomIt) {
CConcept* nominalConcept(*nomIt);
nominalSchemaVarBindedNominalHash.insertMulti(nomSchVarConcept,TConceptPropagationBindingPair(nominalConcept,nullptr));
}
}
}
CSortedNegLinker* tmpNewLinker = createNominalSchemaGroundingConcepts(processNode,nomSchTempl->getTemplateConcept(),negated,&nominalSchemaVarBindedNominalHash,nomSchTempl,calcAlgContext);
if (tmpNewLinker) {
for (CSortedNegLinker* tmpNewLinkerIt = tmpNewLinker; tmpNewLinkerIt; tmpNewLinkerIt = tmpNewLinkerIt->getNext()) {
CConcept* concept = tmpNewLinkerIt->getData();
if (!groundedConVarBindPathHash) {
groundedConVarBindPathHash = CObjectParameterizingAllocator< CPROCESSINGHASH,CContext* >::allocateAndConstructAndParameterize(calcAlgContext->getUsedTemporaryMemoryAllocationManager(),calcAlgContext->getUsedTaskProcessorContext());
}
groundedConVarBindPathHash->insert(concept,varBindPath);
}
newLinker = tmpNewLinker->append(newLinker);
}
}
}
return newLinker;
}
CSortedNegLinker* CConceptNominalSchemaGroundingHandler::createGroundedNominalSchemaConcept(CConcept* concept, bool negated, CReapplyConceptLabelSet* conLabelSet, CBOXHASH* templConNomSchConHash, QHash::const_iterator >* nomSchConIndividualItHash, CCalculationAlgorithmContext* calcAlgContext) {
CSortedNegLinker* conLinker = nullptr;
cint64 opCode = concept->getOperatorCode();
if (!negated && (opCode == CCAND) || negated && (opCode == CCOR)) {
for (CSortedNegLinker* opConLinkerIt = concept->getOperandList(); opConLinkerIt; opConLinkerIt = opConLinkerIt->getNext()) {
CConcept* opConcept = opConLinkerIt->getData();
bool opConNegation = opConLinkerIt->isNegated()^negated;
CSortedNegLinker* tmpConLinker = createGroundedNominalSchemaConcept(opConcept,opConNegation,conLabelSet,templConNomSchConHash,nomSchConIndividualItHash,calcAlgContext);
if (tmpConLinker) {
conLinker = tmpConLinker->append(conLinker);
}
}
} else {
CConcept* groundedConcept = createGroundedNominalSchemaConcept(concept,templConNomSchConHash,nomSchConIndividualItHash,calcAlgContext);
bool alreadyContained = false;
if (conLabelSet) {
alreadyContained = conLabelSet->containsConcept(groundedConcept);
}
if (!alreadyContained) {
CSortedNegLinker* opConLinker = CObjectAllocator< CSortedNegLinker >::allocateAndConstruct(mMemMan);
opConLinker->init(groundedConcept,negated);
conLinker = opConLinker->append(conLinker);
}
}
return conLinker;
}
CSortedNegLinker* CConceptNominalSchemaGroundingHandler::createNominalSchemaGroundingConcepts(CIndividualProcessNode* indiProcessNode, CConcept* concept, bool negated, CPROCESSINGHASH* nominalSchemaVarBindedNominalHash, CNominalSchemaTemplate* nsTemplate, CCalculationAlgorithmContext* calcAlgContext) {
CSortedNegLinker* newGroundedConLinker = nullptr;
CReapplyConceptLabelSet* conLabelSet = indiProcessNode->getReapplyConceptLabelSet(false);
CBOXHASH* templConNomSchConHash = nsTemplate->getTemplateConceptNominalSchemaConceptHash();
CBOXSET* nomSchConSet = nsTemplate->getNominalSchemaConceptSet();
QHash::const_iterator > nomSchConIndividualItHash;
CPROCESSINGHASH::const_iterator indiItEnd = nominalSchemaVarBindedNominalHash->constEnd();
for (CBOXSET::const_iterator it = nomSchConSet->constBegin(), itEnd = nomSchConSet->constEnd(); it != itEnd; ++it) {
CConcept* nomSchCon(*it);
CPROCESSINGHASH::const_iterator indiIt = nominalSchemaVarBindedNominalHash->constFind(nomSchCon);
nomSchConIndividualItHash.insert(nomSchCon,indiIt);
}
bool conVarItFinished = false;
while (!conVarItFinished) {
CConcept* templateConcept = nsTemplate->getTemplateConcept();
CSortedNegLinker* opConLinker = createGroundedNominalSchemaConcept(templateConcept,negated,conLabelSet,templConNomSchConHash,&nomSchConIndividualItHash,calcAlgContext);
if (opConLinker) {
newGroundedConLinker = opConLinker->append(newGroundedConLinker);
}
QHash::const_iterator >::const_iterator variableIt = nomSchConIndividualItHash.constBegin();
QHash::const_iterator >::const_iterator variableItEnd = nomSchConIndividualItHash.constEnd();
if (variableIt == variableItEnd) {
conVarItFinished = true;
} else {
CPROCESSINGHASH::const_iterator varIndiIt = variableIt.value();
CConcept* varConcept = variableIt.key();
++varIndiIt;
bool conVarIteration = true;
while ((varIndiIt == indiItEnd || varIndiIt.key() != varConcept) && conVarIteration) {
conVarIteration = false;
CPROCESSINGHASH::const_iterator indiIt = nominalSchemaVarBindedNominalHash->constFind(varConcept);
nomSchConIndividualItHash.insert(varConcept,indiIt);
++variableIt;
if (variableIt == variableItEnd) {
conVarItFinished = true;
} else {
varIndiIt = variableIt.value();
varConcept = variableIt.key();
++varIndiIt;
if (varIndiIt == indiItEnd) {
conVarIteration = true;
}
}
}
if (!conVarItFinished) {
nomSchConIndividualItHash.insert(varConcept,varIndiIt);
}
}
}
return newGroundedConLinker;
}
}; // end namespace Algorithm
}; // end namespace Kernel
}; // end namespace Reasoner
}; // end namespace Konclude