(clashDes);
if (clashedDataVSExDes) {
newTrackingClash = CObjectAllocator< CTrackedClashedDescriptor >::allocateAndConstruct(tmpMemMan);
newTrackingClash->initTrackedClashedDescriptor(clashedDataVSExDes->getAppropriatedIndividual(),nullptr,nullptr,clashedDataVSExDes->getDependencyTrackPoint());
} else {
CIndividualProcessNode* indiNode = getCoresspondingIndividualNodeFromDependency(clashDes->getDependencyTrackPoint(),calcAlgContext);
newTrackingClash = CObjectAllocator< CTrackedClashedDescriptor >::allocateAndConstruct(tmpMemMan);
newTrackingClash->initTrackedClashedDescriptor(indiNode,nullptr,nullptr,clashDes->getDependencyTrackPoint());
}
}
}
return newTrackingClash;
}
CIndividualProcessNode* CCalculationTableauCompletionTaskHandleAlgorithm::getCoresspondingIndividualNodeFromDependency(CDependencyTrackPoint* depTrackPoint, CCalculationAlgorithmContextBase* calcAlgContext) {
CDependencyNode* depNode = depTrackPoint->getDependencyNode();
return getCoresspondingIndividualNodeFromDependency(depNode,calcAlgContext);
}
CIndividualProcessNode* CCalculationTableauCompletionTaskHandleAlgorithm::getCoresspondingIndividualNodeFromDependency(CDependencyNode* depNode, CCalculationAlgorithmContextBase* calcAlgContext) {
CIndividualProcessNode* indi = nullptr;
indi = depNode->getAppropriateIndividualNode();
//KONCLUDE_ASSERT_X(indi,"getCoresspondingIndividualNodeFromDependency","individual node not available");
if (indi) {
CIndividualProcessNode* updIndi = getUpToDateIndividual(indi,calcAlgContext);
if (updIndi) {
if (updIndi->hasMergedIntoIndividualNodeID()) {
updIndi = getCorrectedNominalIndividualNode(updIndi->getMergedIntoIndividualNodeID(),calcAlgContext);
}
indi = updIndi;
}
}
return indi;
}
QString CCalculationTableauCompletionTaskHandleAlgorithm::generateDebugDependentNominalsString(CIndividualProcessNode* indi, CCalculationAlgorithmContextBase* calcAlgContext) {
QStringList nominalDependentStringList;
CSuccessorConnectedNominalSet* connNomSet = indi->getSuccessorNominalConnectionSet(false);
if (connNomSet) {
for (CSuccessorConnectedNominalSet::const_iterator it = connNomSet->constBegin(), itEnd = connNomSet->constEnd(); it != itEnd; ++it) {
cint64 nominalID = *it;
QString nominalString = QString("%1").arg(nominalID);
nominalDependentStringList.append(nominalString);
}
}
return nominalDependentStringList.join(", ");
}
QString CCalculationTableauCompletionTaskHandleAlgorithm::generateDebugIncrementalExpansionString(CIndividualProcessNode* indi, CCalculationAlgorithmContextBase* calcAlgContext) {
QString incExpString;
CIndividualNodeIncrementalExpansionData* incExpData = indi->getIncrementalExpansionData(false);
if (incExpData) {
QStringList statusStringList;
if (incExpData->isPreviousCompletionGraphCompatible()) {
statusStringList += QString("compatible");
}
if (incExpData->hasDirectlyChangedNeighbourConnection()) {
statusStringList += QString("directly-changed-connection");
}
if (incExpData->isDirectlyChanged()) {
statusStringList += QString("directly-changed-node");
}
QString dirChangedNeighConnNodeID = "-";
if (incExpData->getDirectlyChangedNeighbourConnectionNode()) {
dirChangedNeighConnNodeID = QString("%1").arg(incExpData->getDirectlyChangedNeighbourConnectionNode()->getIndividualNodeID());
}
double expansionPriority = incExpData->getExpansionPriority();
incExpString += QString("Incremental-Expansion-Status: %1\r\n Directly-Changed-Connection-Neighbour: %2\r\n Expansion-Priority: %3").arg(statusStringList.join(", ")).arg(dirChangedNeighConnNodeID).arg(expansionPriority);
}
return incExpString;
}
QString CCalculationTableauCompletionTaskHandleAlgorithm::generateDebugIndiStatusString(CIndividualProcessNode* indi, CCalculationAlgorithmContextBase* calcAlgContext) {
QStringList statusStringList;
if (indi->hasPartialProcessingRestrictionFlags(CIndividualProcessNode::PRFINVALIDATEBLOCKERFLAGSCOMPINATION)) {
statusStringList.append("invalid-blocker");
}
if (indi->hasPartialProcessingRestrictionFlags(CIndividualProcessNode::PRFPURGEDBLOCKED)) {
statusStringList.append("pruned");
}
if (indi->hasPartialProcessingRestrictionFlags(CIndividualProcessNode::PRFPROCESSINGBLOCKED)) {
statusStringList.append("processing blocked");
}
if (indi->hasPartialProcessingRestrictionFlags(CIndividualProcessNode::PRFSATISFIABLECACHED)) {
statusStringList.append("satisfiable-cached");
}
if (indi->hasPartialProcessingRestrictionFlags(CIndividualProcessNode::PRFANCESTORSATISFIABLECACHED)) {
statusStringList.append("ancestor-satisfiable-cached");
}
if (indi->hasPartialProcessingRestrictionFlags(CIndividualProcessNode::PRFDIRECTBLOCKED)) {
cint64 blockerIndiID = indi->getBlockerIndividualNode()->getIndividualNodeID();
cint64 lastConTag = indi->mDebugBlockerLastConceptDes->getConceptTag();
statusStringList.append(QString("direct-blocked by %1 (%2)").arg(blockerIndiID).arg(lastConTag));
}
if (indi->hasPartialProcessingRestrictionFlags(CIndividualProcessNode::PRFINDIRECTBLOCKED)) {
statusStringList.append("indirect-blocked");
}
if (indi->hasPartialProcessingRestrictionFlags(CIndividualProcessNode::PRFBLOCKINGRETESTDUEINDIRECTBLOCKERLOSS)) {
statusStringList.append("indirect-blocking-loss");
}
if (indi->hasPartialProcessingRestrictionFlags(CIndividualProcessNode::PRFBLOCKINGRETESTDUEDIRECTMODIFIED)) {
statusStringList.append("blocking-retest-direct-modification");
}
if (indi->hasPartialProcessingRestrictionFlags(CIndividualProcessNode::PRFBLOCKINGRETESTDUEBLOCKERMODIFIED)) {
statusStringList.append("blocking-retest-blocker-modification");
}
if (indi->hasPartialProcessingRestrictionFlags(CIndividualProcessNode::PRFBLOCKINGRETESTDUEANCESTORMODIFIED)) {
statusStringList.append("blocking-retest-ancestor-modification");
}
if (indi->hasPartialProcessingRestrictionFlags(CIndividualProcessNode::PRFSIGNATUREBLOCKINGCACHED)) {
CSignatureBlockingIndividualNodeConceptExpansionData* locSigBlockingData = indi->getSignatureBlockingIndividualNodeConceptExpansionData(false);
cint64 blockerIndiID = -1;
if (locSigBlockingData->getBlockerIndividualNode()) {
blockerIndiID = locSigBlockingData->getBlockerIndividualNode()->getIndividualNodeID();
}
statusStringList.append(QString("signature-blocking-cached by %1").arg(blockerIndiID));
}
if (indi->hasPartialProcessingRestrictionFlags(CIndividualProcessNode::PRFANCESTORSIGNATUREBLOCKINGCACHED)) {
statusStringList.append("ancestor-signature-blocking-cached");
}
if (indi->hasPartialProcessingRestrictionFlags(CIndividualProcessNode::PRFREUSINGINDIVIDUAL)) {
statusStringList.append("reusing-individual-blocked");
}
if (indi->hasPartialProcessingRestrictionFlags(CIndividualProcessNode::PRFANCESTORREUSINGINDIVIDUALBLOCKED)) {
statusStringList.append("ancestor-reusing-individual-blocked");
}
if (indi->hasPartialProcessingRestrictionFlags(CIndividualProcessNode::PRFSATURATIONBLOCKINGCACHED)) {
statusStringList.append("saturation-cached-blocked");
}
if (indi->hasPartialProcessingRestrictionFlags(CIndividualProcessNode::PRFANCESTORSATURATIONBLOCKINGCACHED)) {
statusStringList.append("ancestor-saturation-cached-blocked");
}
if (indi->hasPartialProcessingRestrictionFlags(CIndividualProcessNode::PRFCOMPLETIONGRAPHCACHED)) {
statusStringList.append("completion-graph-cached-blocked");
}
if (indi->hasPartialProcessingRestrictionFlags(CIndividualProcessNode::PRFCOMPLETIONGRAPHCACHINGINVALID)) {
statusStringList.append("completion-graph-caching-invalid");
}
if (indi->hasPartialProcessingRestrictionFlags(CIndividualProcessNode::PRFCOMPLETIONGRAPHCACHEDNODELOCATED)) {
statusStringList.append("completion-graph-caching-node-located");
}
if (indi->hasPartialProcessingRestrictionFlags(CIndividualProcessNode::PRFCOMPLETIONGRAPHCACHEDNODEEXTENDED)) {
statusStringList.append("completion-graph-caching-node-extended");
}
if (indi->hasPartialProcessingRestrictionFlags(CIndividualProcessNode::PRFCOMPLETIONGRAPHCACHINGINVALIDATED)) {
statusStringList.append("completion-graph-caching-invalidated");
}
if (indi->hasPartialProcessingRestrictionFlags(CIndividualProcessNode::PRFRETESTCOMPLETIONGRAPHCACHEDDUEDIRECTMODIFIED)) {
statusStringList.append("completion-graph-caching-retest-due-to-modification");
}
if (indi->hasPartialProcessingRestrictionFlags(CIndividualProcessNode::PRFSUCCESSORNOMINALCONNECTION)) {
statusStringList.append("successor-nominal-connection");
}
if (indi->hasPartialProcessingRestrictionFlags(CIndividualProcessNode::PRFSUCCESSORNEWNOMINALCONNECTION)) {
statusStringList.append("successor-new-nominal-connection");
}
if (indi->hasPartialProcessingRestrictionFlags(CIndividualProcessNode::PRFCONCRETEDATAINDINODE)) {
statusStringList.append("data-node");
}
if (indi->hasPartialProcessingRestrictionFlags(CIndividualProcessNode::PRFSYNCHRONIZEDBACKEND)) {
statusStringList.append("backend-synchronization");
}
if (indi->hasPartialProcessingRestrictionFlags(CIndividualProcessNode::PRFSYNCHRONIZEDBACKENDINDIRECTNOMINALEXPANSIONBLOCKED)) {
statusStringList.append("backend-synchronized-nominal-indirect-connections-expansion-blocked");
}
if (indi->hasPartialProcessingRestrictionFlags(CIndividualProcessNode::PRFSYNCHRONIZEDBACKENDNEIGHBOUREXPANSIONBLOCKED)) {
statusStringList.append("backend-synchronized-neighbour-expansion-blocked");
}
if (indi->hasPartialProcessingRestrictionFlags(CIndividualProcessNode::PRFSYNCHRONIZEDBACKENNEIGHBOURDPARTIALEXPANSION)) {
statusStringList.append("backend-synchronized-neighbour-partial-expansion");
}
if (indi->hasPartialProcessingRestrictionFlags(CIndividualProcessNode::PRFSYNCHRONIZEDBACKENNEIGHBOURDFULLEXPANSION)) {
statusStringList.append("backend-synchronized-neighbour-full-expansion");
}
if (indi->hasPartialProcessingRestrictionFlags(CIndividualProcessNode::PRFSYNCHRONIZEDBACKENDSUCCESSOREXPANSIONBLOCKED)) {
statusStringList.append("backend-synchronized-successor-expansion-blocked");
}
if (indi->hasPartialProcessingRestrictionFlags(CIndividualProcessNode::PRFINCREMENTALEXPANDING)) {
statusStringList.append("incremental-expansion");
}
if (indi->hasPartialProcessingRestrictionFlags(CIndividualProcessNode::PRFINCREMENTALEXPANSIONRETESTDUEDIRECTMODIFIED)) {
statusStringList.append("incremental-expansion-compatibility-checking-due-to-modification");
}
if (indi->hasPartialProcessingRestrictionFlags(CIndividualProcessNode::PRFREUSINGINDIVIDUAL)) {
statusStringList.append("backend-expansion-reusing-individual");
}
if (indi->hasPartialProcessingRestrictionFlags(CIndividualProcessNode::PRFBACKENDEXPANSIONREUSINGINDIVIDUAL)) {
statusStringList.append("backend-expansion-reusing-individual");
}
if (indi->hasPartialProcessingRestrictionFlags(CIndividualProcessNode::PRFBACKENDEXPANSIONREUSEDISCARDED)) {
statusStringList.append("backend-expansion-reuse-discarded");
}
if (indi->isNominalIndividualNode()) {
statusStringList.append("nominal");
}
CConceptProcessingQueue* conProQue = indi->getConceptProcessingQueue(false);
if (conProQue) {
if (!conProQue->isEmpty() && !indi->hasPartialProcessingRestrictionFlags(CIndividualProcessNode::PRFINVALIDATEBLOCKERFLAGSCOMPINATION)) {
statusStringList.append("processing");
}
}
QString statusString;
statusString = statusStringList.join(", ");
return statusString;
}
QString CCalculationTableauCompletionTaskHandleAlgorithm::generateDebugDependencyString(CDependencyTrackPoint* depTrackPoint, CCalculationAlgorithmContextBase* calcAlgContext) {
QString dependencyString = QString("null");
if (depTrackPoint) {
QString depTypeString;
CDependencyNode* depNode = depTrackPoint->getDependencyNode();
switch (depNode->getDependencyType()) {
case CDependencyNode::DNTINDEPENDENTBASE: {
depTypeString = QString("INDEPENDENT");
break;
}
case CDependencyNode::DNTALLDEPENDENCY: {
depTypeString = QString("ALL");
break;
}
case CDependencyNode::DNTSOMEDEPENDENCY: {
depTypeString = QString("SOME");
break;
}
case CDependencyNode::DNTANDDEPENDENCY: {
depTypeString = QString("AND");
break;
}
case CDependencyNode::DNTORDEPENDENCY: {
depTypeString = QString("OR");
break;
}
case CDependencyNode::DNTATLEASTDEPENDENCY: {
depTypeString = QString("ATLEAST");
break;
}
case CDependencyNode::DNTAUTOMATCHOOSEDEPENDENCY: {
depTypeString = QString("AUTOMATCHOOSE");
break;
}
case CDependencyNode::DNTAUTOMATTRANSACTIONDEPENDENCY: {
depTypeString = QString("AUTOMATTRANSACTION");
break;
}
case CDependencyNode::DNTSELFDEPENDENCY: {
depTypeString = QString("SELF");
break;
}
case CDependencyNode::DNTVALUEDEPENDENCY: {
depTypeString = QString("VALUE");
break;
}
case CDependencyNode::DNTNEGVALUEDEPENDENCY: {
depTypeString = QString("NEGVALUE");
break;
}
case CDependencyNode::DNTDISTINCTDEPENDENCY: {
depTypeString = QString("DISTINCT");
break;
}
case CDependencyNode::DNTMERGEDCONCEPT: {
depTypeString = QString("MERGEDCONCEPT");
break;
}
case CDependencyNode::DNTMERGEDLINK: {
depTypeString = QString("MERGEDLINK");
break;
}
case CDependencyNode::DNTMERGEDEPENDENCY: {
depTypeString = QString("MERGE");
break;
}
case CDependencyNode::DNTATMOSTDEPENDENCY: {
depTypeString = QString("ATMOST");
break;
}
case CDependencyNode::DNTQUALIFYDEPENDENCY: {
depTypeString = QString("QUALIFY");
break;
}
case CDependencyNode::DNTFUNCTIONALDEPENDENCY: {
depTypeString = QString("FUNCTIONAL");
break;
}
case CDependencyNode::DNTNOMINALDEPENDENCY: {
depTypeString = QString("NOMINAL");
break;
}
case CDependencyNode::DNTIMPLICATIONDEPENDENCY: {
depTypeString = QString("IMPLICATION");
break;
}
case CDependencyNode::DNTEXPANDEDDEPENDENCY: {
depTypeString = QString("EXPANDED");
break;
}
case CDependencyNode::DNTDATATYPETRIGGERDEPENDENCY: {
depTypeString = QString("DATATYPETRIGGER");
break;
}
case CDependencyNode::DNTROLEASSERTIONDEPENDENCY: {
depTypeString = QString("ROLEASSERTION");
break;
}
}
CConceptDescriptor* depNodeConDes = depNode->getConceptDescriptor();
QString conceptDepNodeString("null");
if (depNodeConDes) {
conceptDepNodeString = CConceptTextFormater::getConceptString(depNodeConDes->getConcept(),depNodeConDes->isNegated());
}
QString depIndiNodeString;
CIndividualProcessNode* depIndiNode = depNode->getAppropriateIndividualNode();
if (depIndiNode) {
depIndiNodeString = QString("@%1 ").arg(depIndiNode->getIndividualNodeID());
}
QString depInfoString;
if (depNode->isNonDeterministiDependencyNode()) {
CNonDeterministicDependencyNode* nonDetDepNode = (CNonDeterministicDependencyNode*)depNode;
depInfoString += QString(" NonDetDep, <%1/%2>").arg(nonDetDepNode->getOpenedDependencyTrackingPointsCount()).arg(nonDetDepNode->getBranchTrackPoints()->getCount());
}
depInfoString += QString(" + ...(%1)").arg(depNode->getAdditionalDependencyCount());
dependencyString = QString("%1-Dependency: {%2}%3%4").arg(depTypeString).arg(conceptDepNodeString).arg(depIndiNodeString).arg(depInfoString);
}
cint64 branchTag = depTrackPoint->getBranchingTag();
dependencyString = QString(" ^%1 ---> %2").arg(branchTag).arg(dependencyString);
return dependencyString;
}
QStringList CCalculationTableauCompletionTaskHandleAlgorithm::generateExtendedDebugConceptSetStringList(CReapplyConceptLabelSet* conSet, CConceptPropagationBindingSetHash* propBindSetHash, CConceptVariableBindingPathSetHash* varBindPathSetHash, CCalculationAlgorithmContextBase* calcAlgContext) {
QStringList conSetStringList;
CReapplyConceptLabelSetIterator conSetIt = conSet->getConceptLabelSetIterator(false,false,false);
while (conSetIt.hasNext()) {
CConceptDescriptor* conDes = conSetIt.next();
CConcept* concept = conDes->getConcept();
cint64 conTag = conDes->getConceptTag();
if (conTag != 1) {
QString conceptString("null");
if (conDes) {
conceptString = CConceptTextFormater::getConceptString(conDes->getConcept(),conDes->isNegated());
}
if (propBindSetHash) {
CPropagationBindingSet* propBindSet = propBindSetHash->getPropagationBindingSet(concept,false);
if (propBindSet) {
QString bindingString;
CPropagationBindingMap* map = propBindSet->getPropagationBindingMap();
for (CPropagationBindingMap::const_iterator it = map->constBegin(), itEnd = map->constEnd(); it != itEnd; ++it) {
cint64 propBindingID = it.key();
if (!bindingString.isEmpty()) {
bindingString += QString(", ");
}
bindingString += QString::number(propBindingID);
}
conceptString += QString(" ~{%1}").arg(bindingString);
}
}
if (varBindPathSetHash) {
CVariableBindingPathSet* varBindPathSet = varBindPathSetHash->getVariableBindingPathSet(concept,false);
if (varBindPathSet) {
QString bindingString;
CVariableBindingPathMap* map = varBindPathSet->getVariableBindingPathMap();
for (CVariableBindingPathMap::const_iterator it = map->constBegin(), itEnd = map->constEnd(); it != itEnd; ++it) {
cint64 varBindingPathID = it.key();
if (!bindingString.isEmpty()) {
bindingString += QString(", ");
}
QString bindString;
CVariableBindingPathDescriptor* varBindPathDes = it.value().getVariableBindingPathDescriptor();
CVariableBindingPath* varBindPath = varBindPathDes->getVariableBindingPath();
CVariableBindingDescriptor* varBindDes = varBindPath->getVariableBindingDescriptorLinker();
for (CVariableBindingDescriptor* varBindDesIt = varBindDes; varBindDesIt; varBindDesIt = varBindDesIt->getNext()) {
CVariableBinding* varBinding = varBindDesIt->getVariableBinding();
if (!bindString.isEmpty()) {
bindString += QString(", ");
}
bindString += QString("v-%1/i-%2").arg(varBinding->getBindedVariable()->getPathVariableID()).arg(varBinding->getBindedIndividual()->getIndividualNodeID());
}
bindingString += QString("{%1:%2}").arg(varBindingPathID).arg(bindString);
}
conceptString += QString(" ~{%1}").arg(bindingString);
}
}
CDependencyTrackPoint* depTrackPoint = conDes->getDependencyTrackPoint();
if (depTrackPoint) {
conceptString += generateDebugDependencyString(depTrackPoint,calcAlgContext);
}
conSetStringList.append(conceptString);
}
}
return conSetStringList;
}
QString CCalculationTableauCompletionTaskHandleAlgorithm::writeGeneratedExtendedDebugIndiModelStringList(const QString& filename, CCalculationAlgorithmContextBase* calcAlgContext) {
QStringList indiStringList;
QString remainingDebugString = generateExtendedDebugIndiModelStringList(calcAlgContext, &indiStringList);
QFile file(filename);
if (file.open(QIODevice::WriteOnly)) {
for (const QString& tmpString : indiStringList) {
QString tmpReplacedString = tmpString;
tmpReplacedString = tmpReplacedString.replace("
", "\r\n");
file.write(tmpReplacedString.toLocal8Bit());
file.write(QString("\r\n\r\n\r\n").toLocal8Bit());
}
file.write(remainingDebugString.toLocal8Bit());
file.close();
}
if (indiStringList.size() < 5000) {
mDebugIndiModelStringList = indiStringList;
mDebugIndiModelString = mDebugIndiModelStringList.join("
\r\n");
mDebugIndiModelString += remainingDebugString;
}
return mDebugIndiModelString;
}
QString CCalculationTableauCompletionTaskHandleAlgorithm::generateExtendedDebugIndiModelStringList(CCalculationAlgorithmContextBase* calcAlgContext, QStringList* list) {
CProcessingDataBox* procDataBox = calcAlgContext->getUsedProcessingDataBox();
CIndividualProcessNodeVector* indiVec = procDataBox->getIndividualProcessNodeVector();
cint64 indiStart = indiVec->getItemMinIndex();
cint64 indiCount = indiVec->getItemCount();
QStringList indiStringList;
if (indiStart > 0) {
indiStart = 0;
}
QSet propCutIndiNodesIds;
CBackendNeighbourExpansionControllingData* expContData = calcAlgContext->getUsedProcessingDataBox()->getBackendNeighbourExpansionControllingData(false);
if (expContData && expContData->getCutBackendNeighbourExpansionIndividualLinker()) {
for (CXLinker* propCutIndiLinkerIt = expContData->getCutBackendNeighbourExpansionIndividualLinker(); propCutIndiLinkerIt; propCutIndiLinkerIt = propCutIndiLinkerIt->getNext()) {
CIndividualProcessNode* propCutIndiNode = propCutIndiLinkerIt->getData();
propCutIndiNodesIds.insert(propCutIndiNode->getIndividualNodeID());
}
}
cint64 indiReplaceOffset = -indiStart;
for (cint64 i = indiStart; i < indiCount; ++i) {
CIndividualProcessNode* indi = getAvailableUpToDateIndividual(i,calcAlgContext);
if (indi) {
CIndividualProcessNode* ancIndi = getAncestorIndividual(indi,calcAlgContext);
CReapplyConceptLabelSet* conSet = indi->getReapplyConceptLabelSet(false);
CConceptPropagationBindingSetHash* propBindSetHash = indi->getConceptPropagationBindingSetHash(false);
CConceptVariableBindingPathSetHash* varBindPathSetHash = indi->getConceptVariableBindingPathSetHash(false);
if (conSet) {
QString nominalString = QString("");
if (indi->getNominalIndividual()) {
nominalString = QString(", ")+CIRIName::getRecentIRIName(indi->getNominalIndividual()->getNameLinker());
}
QString indiString = QString("[ %1%2%3 ] =
").arg(ancIndi?QString("%1->").arg(ancIndi->getIndividualNodeID()):"").arg(indi->getIndividualNodeID()).arg(nominalString);
QString statusString = QString("%1").arg(generateDebugIndiStatusString(indi,calcAlgContext));
if (propCutIndiNodesIds.contains(i)) {
statusString += ", backend-expansion-propagation-cutted";
}
indiString += QString("{{%1}d%2}
").arg(statusString).arg(indi->getIndividualNominalLevelOrAncestorDepth());
QStringList conSetStringList = generateExtendedDebugConceptSetStringList(conSet,propBindSetHash,varBindPathSetHash,calcAlgContext);
//debugTestCriticalConceptSet(conSetStringList,calcAlgContext);
QString depNomString = generateDebugDependentNominalsString(indi,calcAlgContext);
if (!depNomString.isEmpty()) {
indiString += QString("SuccessorDependentNominals: %1
\r\n").arg(depNomString);
}
QString incExpString = generateDebugIncrementalExpansionString(indi,calcAlgContext);
if (!incExpString.isEmpty()) {
indiString += QString("%1
\r\n").arg(incExpString);
}
QString conSetString(conSetStringList.join("
"));
indiString += QString("$%1$
{%2} ").arg(conSet->getConceptSignatureValue()).arg(conSetString);
QString assDataLitString;
for (CProcessAssertedDataLiteralLinker* dataLitLinkerIt = indi->getAssertedDataLiteralLinker(); dataLitLinkerIt; dataLitLinkerIt = dataLitLinkerIt->getNext()) {
CDataLiteral* dataLiteral = dataLitLinkerIt->getDataLiteral();
if (assDataLitString.isEmpty()) {
assDataLitString = "Asserted Data Literals:
\n";
}
if (dataLiteral->getDatatype()) {
assDataLitString += QString("\t\t%1^^%2
\n").arg(dataLiteral->getLexicalDataLiteralValueString()).arg(dataLiteral->getDatatype()->getDatatypeIRI());
} else {
assDataLitString += QString("\t\t%1
\n").arg(dataLiteral->getLexicalDataLiteralValueString());
}
}
if (!assDataLitString.isEmpty()) {
indiString += QString("
\n%1
\n").arg(assDataLitString);
}
if (indi->getIndividualBackendCacheSynchronisationData(false)) {
CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData* backendSyncData = (CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData*)indi->getIndividualBackendCacheSynchronisationData(false);
if (backendSyncData->getAssocitaionData()) {
CBackendNeighbourExpansionQueue* neighExpQue = backendSyncData->getBackendNeighbourExpansionQueue(false);
QString neighExpQueuedString;
if (neighExpQue && neighExpQue->hasQueuedNeighbourExpansions()) {
neighExpQueuedString += ", neighbour-expansion-queued";
}
QStringList mergingHandlingStringList;
if (backendSyncData->hasNonDeterministicallyMergedIndividuals()) {
mergingHandlingStringList += QString("non-deterministically-merged-individuals:true");
} else {
mergingHandlingStringList += QString("non-deterministically-merged-individuals:false");
}
if (backendSyncData->hasNewlyMergedIndividuals()) {
mergingHandlingStringList += QString("newly-merged-individuals:true");
} else {
mergingHandlingStringList += QString("newly-merged-individuals:false");
}
if (backendSyncData->hasNewlyMergedAllNeighbourExpansion()) {
mergingHandlingStringList += QString("newly-merged-individuals-all-neighbour-expansion:true");
} else {
mergingHandlingStringList += QString("newly-merged-individuals-all-neighbour-expansion:false");
}
if (backendSyncData->hasNewlyMergedInferringNeighbourExpansion()) {
mergingHandlingStringList += QString("newly-merged-individuals-inferring-neighbour-expansion:true");
} else {
mergingHandlingStringList += QString("newly-merged-individuals-inferring-neighbour-expansion:false");
}
indiString += QString("
\n(based on backend data update id %1, cache update id %2, %3%4)
\n").arg(backendSyncData->getAssocitaionData()->getAssociationDataUpdateId()).arg(backendSyncData->getAssocitaionData()->getCacheUpdateId()).arg(mergingHandlingStringList.join(", ")).arg(neighExpQueuedString);
}
}
indiStringList.append(indiString);
} else {
bool bug = true;
QString nominalString = QString("");
if (indi->getNominalIndividual()) {
nominalString = QString(", ") + CIRIName::getRecentIRIName(indi->getNominalIndividual()->getNameLinker());
}
QString indiString = QString("[ %1%2%3 ] = concept set missing
").arg(ancIndi ? QString("%1->").arg(ancIndi->getIndividualNodeID()) : "").arg(indi->getIndividualNodeID()).arg(nominalString);
indiStringList.append(indiString);
}
} else {
//indiStringList.append(QString("[ %1, --unused--]
").arg(i));
indiStringList.append(QString());
}
}
for (cint64 i = indiStart; i < indiCount; ++i) {
CIndividualProcessNode* indi = getAvailableUpToDateIndividual(i,calcAlgContext);
if (indi && indi->hasMergedIntoIndividualNodeID()) {
cint64 mergedIntoID = indi->getMergedIntoIndividualNodeID();
QString meIndiString = indiStringList.value(indiReplaceOffset + mergedIntoID);
meIndiString += QString("+%1").arg(i);
if (indiReplaceOffset+mergedIntoID < indiStringList.count()) {
indiStringList.replace(indiReplaceOffset+mergedIntoID,meIndiString);
} else {
LOG(ERROR,"::Konclude::Reasoner::Kernel::Algorithm::TableauCompletionAlgorihm",logTr("Merging of individual %1 into %2 cannot be correctly resolved for completion graph printing.").arg(i).arg(mergedIntoID),this);
}
}
}
for (cint64 i = indiStart; i < indiCount; ++i) {
CIndividualProcessNode* indi = getAvailableUpToDateIndividual(i,calcAlgContext);
if (indi && indi->hasMergedIntoIndividualNodeID()) {
cint64 mergedIntoID = indi->getMergedIntoIndividualNodeID();
QString indiString = indiStringList.value(indiReplaceOffset + i);
indiString += QString(" -> %1").arg(mergedIntoID);
if (indiReplaceOffset+i < indiStringList.count()) {
indiStringList.replace(indiReplaceOffset+i,indiString);
} else {
LOG(ERROR,"::Konclude::Reasoner::Kernel::Algorithm::TableauCompletionAlgorihm",logTr("Merging of individual %1 into %2 cannot be correctly resolved for completion graph printing.").arg(i).arg(mergedIntoID),this);
}
}
}
cint64 succInsertions = 0;
for (cint64 i = indiStart; i < indiCount; ++i) {
CIndividualProcessNode* indi = getAvailableUpToDateIndividual(i,calcAlgContext);
if (indi) {
CSuccessorIterator succIt = indi->getSuccessorIterator();
while (succIt.hasNext()) {
cint64 succIndi = succIt.nextIndividualID();
QString succString = QString("\t--> %1: ").arg(succIndi);
CSuccessorRoleIterator succRoleIt = indi->getSuccessorRoleIterator(succIndi);
while (succRoleIt.hasNext()) {
CIndividualLinkEdge* link = succRoleIt.next();
CRole* role = link->getLinkRole();
succString += QString::number(role->getRoleTag());
if (role->hasPropertyName()) {
succString += CIRIName::getRecentIRIName(role->getPropertyNameLinker());
}
CDependencyTrackPoint* depTrackPoint = link->getDependencyTrackPoint();
if (depTrackPoint) {
succString += generateDebugDependencyString(depTrackPoint,calcAlgContext);
}
if (succRoleIt.hasNext()) {
succString += QString(", \r\n\t\t");
}
}
indiStringList.insert(indiReplaceOffset+i+1+succInsertions++,succString);
}
}
}
QStringList filteredIndiStringList;
for (QStringList::iterator it = indiStringList.begin(), itEnd = indiStringList.end(); it != itEnd; ++it) {
if (!it->isEmpty()) {
filteredIndiStringList.append(*it);
}
}
if (!list) {
if (filteredIndiStringList.size() >= 1000000) {
QFile file(QString("./Debugging/CompletionTasks/tmp-%1.txt").arg(calcAlgContext->getUsedSatisfiableCalculationTask()->getTaskDepth()));
if (file.open(QIODevice::WriteOnly)) {
for (const QString& tmpString : filteredIndiStringList) {
QString tmpReplacedString = tmpString;
tmpReplacedString = tmpReplacedString.replace("
", "\r\n");
file.write(tmpReplacedString.toLocal8Bit());
file.write(QString("\r\n\r\n\r\n").toLocal8Bit());
}
file.close();
}
} else {
mDebugIndiModelStringList = filteredIndiStringList;
mDebugIndiModelString = mDebugIndiModelStringList.join("
\r\n");
}
} else {
mDebugIndiModelString.clear();
*list = filteredIndiStringList;
}
if (calcAlgContext->getProcessingDataBox()->hasClashedDescriptorLinker()) {
CTrackedClashedDescriptor* trackedClashDescriptors = createTrackedClashesDescriptors(calcAlgContext->getProcessingDataBox()->getClashedDescriptorLinker(), calcAlgContext);
CPROCESSINGSET clashedSet(calcAlgContext->getUsedTaskProcessorContext());
CTrackedClashedDependencyLine trackingLine(&clashedSet);
QString clashedString = generateDebugTrackedClashedDescriptorSummaryString(trackedClashDescriptors, calcAlgContext);
if (initializeTrackingLine(&trackingLine, trackedClashDescriptors, calcAlgContext)) {
clashedString += "\r\n\r\n" + writeDebugTrackingLineStringToFile(generateDebugTrackingLineString(&trackingLine, calcAlgContext), "clash-details", &trackingLine, calcAlgContext);
}
mDebugIndiModelString = mDebugIndiModelString + QString("
\r\n
\r\nClashes
\r\n%1").arg(clashedString);
}
return mDebugIndiModelString;
}
QString CCalculationTableauCompletionTaskHandleAlgorithm::generateDebugIndiModelStringList(CCalculationAlgorithmContextBase* calcAlgContext) {
CProcessingDataBox* procDataBox = calcAlgContext->getUsedProcessingDataBox();
CIndividualProcessNodeVector* indiVec = procDataBox->getIndividualProcessNodeVector();
cint64 indiCount = indiVec->getItemCount();
cint64 indiStart = indiVec->getItemMinIndex();
QStringList indiStringList;
if (indiStart > 0) {
indiStart = 0;
}
cint64 indiReplaceOffset = -indiStart;
for (cint64 i = indiStart; i < indiCount; ++i) {
CIndividualProcessNode* indi = getAvailableUpToDateIndividual(i,calcAlgContext);
if (indi) {
CIndividualProcessNode* ancIndi = getAncestorIndividual(indi,calcAlgContext);
CReapplyConceptLabelSet* conSet = indi->getReapplyConceptLabelSet(false);
if (conSet) {
QString nominalString = QString("");
if (indi->getNominalIndividual()) {
nominalString = QString(", ")+CIRIName::getRecentIRIName(indi->getNominalIndividual()->getNameLinker());
}
QString indiString = QString("[ %1%2%3 ] = ").arg(ancIndi?QString("%1->").arg(ancIndi->getIndividualNodeID()):"").arg(indi->getIndividualNodeID()).arg(nominalString);
QString conSetString;
CReapplyConceptLabelSetIterator conSetIt = conSet->getConceptLabelSetIterator(false,false,false);
while (conSetIt.hasNext()) {
CConceptDescriptor* conDes = conSetIt.next();
CConcept* concept = conDes->getConcept();
cint64 conTag = conDes->getConceptTag();
if (conTag != 1) {
QString conString = QString("%1%2").arg((conDes->isNegated())?"-":"").arg(conTag);
if (concept->hasClassName()) {
conString += CIRIName::getRecentIRIName(concept->getClassNameLinker());
}
if (!conSetString.isEmpty()) {
conSetString += QString(", ");
}
conSetString += conString;
}
}
indiString += QString("{%1} ").arg(conSetString);
indiStringList.append(indiString);
}
}
}
for (cint64 i = indiStart; i < indiCount; ++i) {
CIndividualProcessNode* indi = getAvailableUpToDateIndividual(i,calcAlgContext);
if (indi && indi->hasMergedIntoIndividualNodeID()) {
cint64 mergedIntoID = indi->getMergedIntoIndividualNodeID();
QString meIndiString = indiStringList.value(mergedIntoID);
meIndiString += QString("+%1").arg(i);
indiStringList.replace(indiReplaceOffset+mergedIntoID+indiStart,meIndiString);
}
}
for (cint64 i = indiStart; i < indiCount; ++i) {
CIndividualProcessNode* indi = getAvailableUpToDateIndividual(i,calcAlgContext);
if (indi && indi->hasMergedIntoIndividualNodeID()) {
cint64 mergedIntoID = indi->getMergedIntoIndividualNodeID();
QString indiString = indiStringList.value(i);
indiString += QString(" -> %1").arg(mergedIntoID);
indiStringList.replace(indiReplaceOffset + i+indiStart,indiString);
}
}
cint64 succInsertions = 0;
for (cint64 i = indiStart; i < indiCount; ++i) {
CIndividualProcessNode* indi = getAvailableUpToDateIndividual(i,calcAlgContext);
if (indi) {
CSuccessorIterator succIt = indi->getSuccessorIterator();
while (succIt.hasNext()) {
cint64 succIndi = succIt.nextIndividualID();
QString succString = QString("\t--> %1: ").arg(succIndi);
CSuccessorRoleIterator succRoleIt = indi->getSuccessorRoleIterator(succIndi);
while (succRoleIt.hasNext()) {
CIndividualLinkEdge* link = succRoleIt.next();
CRole* role = link->getLinkRole();
succString += QString::number(role->getRoleTag());
if (role->hasPropertyName()) {
succString += CIRIName::getRecentIRIName(role->getPropertyNameLinker());
}
if (succRoleIt.hasNext()) {
succString += QString(", ");
}
}
indiStringList.insert(indiReplaceOffset + i+indiStart+1+succInsertions++,succString);
}
}
}
mDebugIndiModelStringList = indiStringList;
mDebugIndiModelString = mDebugIndiModelStringList.join("\n");
return mDebugIndiModelString;
}
bool CCalculationTableauCompletionTaskHandleAlgorithm::initialNodeInitialize(CIndividualProcessNode*& indiProcNode, bool allowPreprocess, CCalculationAlgorithmContextBase* calcAlgContext) {
if (indiProcNode->getNominalIndividual() && !indiProcNode->getNominalIndividual()->isFakeIndividual() && mBackendCacheHandler && !indiProcNode->isNominalIndividualRepresentativeBackendDataLoaded() && !mOptIncrementalCompatibleExpansion) {
if (loadIndividualNodeDataFromBackendCache(indiProcNode, calcAlgContext)) {
CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData* backendSyncData = (CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData*)indiProcNode->getIndividualBackendCacheSynchronisationData(false);
if (!backendSyncData || !backendSyncData->isBackendConceptSetInitialized()) {
if (!allowPreprocess || backendSyncData->isBackendConceptSetInitializationRequired() || !mOptDelayedBackendInitializiation || !tryDelayIndividualNodeInitializationWithBackendConceptSetLabel(indiProcNode, calcAlgContext)) {
initializeIndividualNodeWithBackendCache(indiProcNode, calcAlgContext);
indiProcNode->setNominalIndividualRepresentativeBackendDataLoaded(true);
tryEstablishExpansionBlockingWithBackendCacheSynchronisation(indiProcNode, calcAlgContext);
indiProcNode->clearProcessingRestrictionFlags(CIndividualProcessNode::PRFSYNCHRONIZEDBACKENPROCESSINGDELAYING);
} else {
// mark processing blocked by setting flag
indiProcNode->addProcessingRestrictionFlags(CIndividualProcessNode::PRFSYNCHRONIZEDBACKENPROCESSINGDELAYING);
return false;
}
}
}
}
bool backendExpanded = false;
if (indiProcNode->isNominalIndividualRepresentativeBackendDataLoaded()) {
backendExpanded = true;
detectIndividualNodeBackendCacheSynchronized(indiProcNode, calcAlgContext);
if (!indiProcNode->hasPartialProcessingRestrictionFlags(CIndividualProcessNode::PRFSYNCHRONIZEDBACKENDNEIGHBOUREXPANSIONBLOCKED) && !indiProcNode->hasPartialProcessingRestrictionFlags(CIndividualProcessNode::PRFSYNCHRONIZEDBACKENNEIGHBOURDFULLEXPANSION)) {
if (allowPreprocess || mCurrentRecProcDepth < mCurrentRecProcDepthLimit) {
if (mConfAllowBackendNeighbourExpansionBlocking) {
indiProcNode->addProcessingRestrictionFlags(CIndividualProcessNode::PRFSYNCHRONIZEDBACKENNEIGHBOURDPARTIALEXPANSION);
}
if (!expandDirectlyInfluencedIndividualNeighbourNodesFromBackendCache(indiProcNode, calcAlgContext)) {
if (!mConfAllowBackendNeighbourExpansionBlocking) {
indiProcNode->clearProcessingRestrictionFlags(CIndividualProcessNode::PRFSYNCHRONIZEDBACKENNEIGHBOURDPARTIALEXPANSION);
indiProcNode->addProcessingRestrictionFlags(CIndividualProcessNode::PRFSYNCHRONIZEDBACKENNEIGHBOURDFULLEXPANSION);
}
backendExpanded = false;
}
if (indiProcNode->hasPurgedBlockedProcessingRestrictionFlags()) {
return false;
}
} else {
calcAlgContext->getProcessingDataBox()->getRoleAssertionExpansionProcessingQueue(true)->insertIndiviudalProcessNode(indiProcNode);
}
}
}
if (indiProcNode->hasNominalIndividualTriplesAssertions() && !indiProcNode->areNominalIndividualTriplesAssertionsLoaded()) {
CConcreteOntology* ontology = calcAlgContext->getUsedProcessingDataBox()->getOntology();
COntologyTriplesData* ontologyTriplesData = ontology->getOntologyTriplesData();
if (ontologyTriplesData) {
COntologyTriplesAssertionsAccessor* triplesAssertionAccessor = ontologyTriplesData->getTripleAssertionAccessor();
if (triplesAssertionAccessor && -indiProcNode->getIndividualNodeID() <= triplesAssertionAccessor->getMaxIndexedIndividualId()) {
if (!indiProcNode->getNominalIndividual()) {
CIndexedIndividualAssertionConvertionVisitor indiAssConvVisitor(-indiProcNode->getIndividualNodeID(), calcAlgContext);
triplesAssertionAccessor->visitIndividualAssertions(-indiProcNode->getIndividualNodeID(), &indiAssConvVisitor);
indiProcNode->setNominalIndividual(indiAssConvVisitor.getRetrievalIndividual());
} else {
CIndexedIndividualAssertionConvertionVisitor indiAssConvVisitor(indiProcNode->getNominalIndividual(), calcAlgContext);
triplesAssertionAccessor->visitIndividualAssertions(-indiProcNode->getIndividualNodeID(), &indiAssConvVisitor);
indiProcNode->setNominalIndividual(indiAssConvVisitor.getRetrievalIndividual());
}
CIndividual* nominalIndi = indiProcNode->getNominalIndividual();
indiProcNode->setAssertionConceptLinker(nominalIndi->getAssertionConceptLinker());
indiProcNode->setAssertionRoleLinker(nominalIndi->getAssertionRoleLinker());
indiProcNode->setReverseAssertionRoleLinker(nominalIndi->getReverseAssertionRoleLinker());
indiProcNode->setAssertionDataLinker(nominalIndi->getAssertionDataLinker());
}
}
indiProcNode->setNominalIndividualTriplesAssertionsLoaded(true);
}
CConceptAssertionLinker* assertionConceptLinker = indiProcNode->getAssertionConceptLinker();
CRoleAssertionLinker* assertionRoleLinkerIt = indiProcNode->getAssertionRoleLinker();
CDataAssertionLinker* assertionDataLinkerIt = indiProcNode->getAssertionDataLinker();
CReverseRoleAssertionLinker* reverseAssertionRoleLinkerIt = indiProcNode->getReverseAssertionRoleLinker();
CAdditionalProcessRoleAssertionsLinker* addProcRoleAssertionsLinker = indiProcNode->getAdditionalRoleAssertionsLinker();
CAdditionalProcessDataAssertionsLinker* addProcDataAssertionsLinker = indiProcNode->getAdditionalDataAssertionsLinker();
CXSortedNegLinker* initConceptLinker = indiProcNode->getProcessInitializingConceptLinker();
CReapplyConceptLabelSet* conSet = indiProcNode->getReapplyConceptLabelSet(false);
bool initialized = false;
CConceptSetSignature assInitSignature;
bool assInitSignatureBuilded = false;
if (!indiProcNode->hasBaseConceptsInitialized()) {
bool datatypeNode = indiProcNode->hasPartialProcessingRestrictionFlags(CIndividualProcessNode::PRFCONCRETEDATAINDINODE);
if (assertionConceptLinker || initConceptLinker || !conSet) {
for (CConceptAssertionLinker* assertionConceptLinkerIt = assertionConceptLinker; assertionConceptLinkerIt && !datatypeNode; assertionConceptLinkerIt = assertionConceptLinkerIt->getNext()) {
CConcept* concept = assertionConceptLinkerIt->getData();
if (concept->getConceptOperator()->hasPartialOperatorCodeFlag(CConceptOperator::CCFS_DATATYPE_RELATED_TYPE)) {
datatypeNode = true;
}
}
for (CXSortedNegLinker* initConceptLinkerIt = initConceptLinker; initConceptLinkerIt && !datatypeNode; initConceptLinkerIt = initConceptLinkerIt->getNext()) {
CConcept* concept = initConceptLinkerIt->getData();
if (concept->getConceptOperator()->hasPartialOperatorCodeFlag(CConceptOperator::CCFS_DATATYPE_RELATED_TYPE)) {
datatypeNode = true;
}
}
if (!datatypeNode) {
CDependencyTrackPoint* depTrackPoint = calcAlgContext->getBaseDependencyNode()->getContinueDependencyTrackPoint();
CConcept* topConcept = calcAlgContext->getProcessingDataBox()->getOntologyTopConcept();
addConceptToIndividual(topConcept, false, indiProcNode, depTrackPoint, allowPreprocess, true, calcAlgContext);
} else {
CDependencyTrackPoint* depTrackPoint = calcAlgContext->getBaseDependencyNode()->getContinueDependencyTrackPoint();
CConcept* topDataConcept = calcAlgContext->getProcessingDataBox()->getOntologyTopDataRangeConcept();
addConceptToIndividual(topDataConcept, false, indiProcNode, depTrackPoint, allowPreprocess, true, calcAlgContext);
indiProcNode->addProcessingRestrictionFlags(CIndividualProcessNode::PRFCONCRETEDATAINDINODE);
}
initialized = true;
}
if (indiProcNode->isNominalIndividualNode()) {
if (!indiProcNode->hasPartialProcessingRestrictionFlags(CIndividualProcessNode::PRFSUCCESSORNOMINALCONNECTION)) {
propagateIndividualNodeNominalConnectionToAncestors(indiProcNode, calcAlgContext);
}
//propagateIndividualNodeNominalConnectionStatusToAncestors(indiProcNode,indiProcNode,calcAlgContext);
}
indiProcNode->setBaseConceptsInitialized(true);
}
if (!indiProcNode->hasUniversallyConnectionIndividualInitialized()) {
CConcept* univConnNomValueConcept = calcAlgContext->getProcessingDataBox()->getOntology()->getTBox()->getUniversalConnectionNominalValueConcept();
if (univConnNomValueConcept) {
bool datatypeNode = indiProcNode->hasPartialProcessingRestrictionFlags(CIndividualProcessNode::PRFCONCRETEDATAINDINODE);
if (assertionConceptLinker || initConceptLinker || indiProcNode->getNominalIndividual()) {
CDependencyTrackPoint* depTrackPoint = calcAlgContext->getBaseDependencyNode()->getContinueDependencyTrackPoint();
if (univConnNomValueConcept && !datatypeNode) {
addConceptToIndividual(univConnNomValueConcept, false, indiProcNode, depTrackPoint, allowPreprocess, true, calcAlgContext);
}
}
indiProcNode->setUniversallyConnectionIndividualInitialized(true);
}
}
if (assertionConceptLinker) {
CDependencyTrackPoint* depTrackPoint = calcAlgContext->getBaseDependencyNode()->getContinueDependencyTrackPoint();
for (CConceptAssertionLinker* assertionConceptLinkerIt = assertionConceptLinker; assertionConceptLinkerIt; assertionConceptLinkerIt = assertionConceptLinkerIt->getNext()) {
CConcept* assertionConcept = assertionConceptLinkerIt->getData();
bool assertionConceptNegation = assertionConceptLinkerIt->isNegated();
if (assertionConcept->getOperatorCode() != CCNOMINAL) {
assInitSignature.addConceptSignature(assertionConcept, assertionConceptNegation);
assInitSignatureBuilded = true;
}
}
if (mOptIncrementalCompatibleExpansion || !indiProcNode->isNominalIndividualRepresentativeBackendDataLoaded()) {
addConceptsToIndividual(assertionConceptLinker,false,indiProcNode,depTrackPoint,allowPreprocess,true,nullptr,calcAlgContext);
CIndividual* nominalIndi = indiProcNode->getNominalIndividual();
if (nominalIndi) {
CConcept* nominalConcept = nominalIndi->getIndividualNominalConcept();
if (nominalConcept) {
addConceptToIndividual(nominalConcept,false,indiProcNode,depTrackPoint,true,true,calcAlgContext);
}
}
}
initialized = true;
indiProcNode->clearAssertionConcepts();
}
if (initConceptLinker) {
if (!calcAlgContext->getUsedProcessingDataBox()->hasConstructedIndividualNodeInitialized()) {
calcAlgContext->getUsedProcessingDataBox()->setConstructedIndividualNodeInitialized(true);
tryCompletionGraphReuse(indiProcNode,calcAlgContext);
}
CDependencyTrackPoint* depTrackPoint = calcAlgContext->getBaseDependencyNode()->getContinueDependencyTrackPoint();
if (!mConfExpandCreatedSuccessorsFromSaturation || !tryInitalizingFromSaturatedData(indiProcNode,initConceptLinker,depTrackPoint,allowPreprocess,calcAlgContext) || initConceptLinker->hasNext()) {
addConceptsToIndividual(initConceptLinker,false,indiProcNode,depTrackPoint,allowPreprocess,true,nullptr,calcAlgContext);
}
indiProcNode->clearProcessInitializingConcepts();
initialized = true;
for (CXSortedNegLinker* initConceptLinkerIt = initConceptLinker; initConceptLinkerIt; initConceptLinkerIt = initConceptLinkerIt->getNext()) {
CConcept* initConcept = initConceptLinkerIt->getData();
bool initConceptNegation = initConceptLinkerIt->isNegated();
if (initConcept->getOperatorCode() != CCNOMINAL) {
assInitSignature.addConceptSignature(initConcept,initConceptNegation);
assInitSignatureBuilded = true;
}
}
}
if (assertionRoleLinkerIt || reverseAssertionRoleLinkerIt || addProcRoleAssertionsLinker) {
detectIndividualNodeBackendCacheSynchronized(indiProcNode, calcAlgContext);
if (!indiProcNode->hasPartialProcessingRestrictionFlags(CIndividualProcessNode::PRFSYNCHRONIZEDBACKENDNEIGHBOUREXPANSIONBLOCKED)) {
if (allowPreprocess || mCurrentRecProcDepth < mCurrentRecProcDepthLimit) {
if (mConfAllowBackendNeighbourExpansionBlocking) {
indiProcNode->addProcessingRestrictionFlags(CIndividualProcessNode::PRFSYNCHRONIZEDBACKENNEIGHBOURDPARTIALEXPANSION);
}
if (!indiProcNode->getIndividualBackendCacheSynchronisationData(false) || !expandDirectlyInfluencedIndividualNeighbourNodesFromBackendCache(indiProcNode, calcAlgContext)) {
if (!mConfAllowBackendNeighbourExpansionBlocking) {
indiProcNode->clearProcessingRestrictionFlags(CIndividualProcessNode::PRFSYNCHRONIZEDBACKENNEIGHBOURDPARTIALEXPANSION);
indiProcNode->addProcessingRestrictionFlags(CIndividualProcessNode::PRFSYNCHRONIZEDBACKENNEIGHBOURDFULLEXPANSION);
}
indiProcNode->clearAssertionRoles();
indiProcNode->clearReverseAssertionRoles();
indiProcNode->clearAdditionalRoleAssertionsLinker();
indiProcNode->clearAdditionalRoleAssertionsLinker();
CDependencyTrackPoint* depTrackPoint = calcAlgContext->getBaseDependencyNode()->getContinueDependencyTrackPoint();
while (assertionRoleLinkerIt) {
addRoleAssertion(indiProcNode, assertionRoleLinkerIt, depTrackPoint, calcAlgContext);
assertionRoleLinkerIt = assertionRoleLinkerIt->getNext();
}
for (CAdditionalProcessRoleAssertionsLinker* addProcRoleAssertionsLinkerIt = addProcRoleAssertionsLinker; addProcRoleAssertionsLinkerIt; addProcRoleAssertionsLinkerIt = addProcRoleAssertionsLinkerIt->getNext()) {
assertionRoleLinkerIt = addProcRoleAssertionsLinkerIt->getRoleAssertionLinker();
CDependencyTrackPoint* addDepTrackPoint = addProcRoleAssertionsLinkerIt->getDependencyTrackPoint();
while (assertionRoleLinkerIt) {
addRoleAssertion(indiProcNode, assertionRoleLinkerIt, addDepTrackPoint, calcAlgContext);
assertionRoleLinkerIt = assertionRoleLinkerIt->getNext();
}
}
indiProcNode->setRoleAssertionsInitialized(true);
while (reverseAssertionRoleLinkerIt) {
addReverseRoleAssertion(indiProcNode, reverseAssertionRoleLinkerIt, depTrackPoint, calcAlgContext);
reverseAssertionRoleLinkerIt = reverseAssertionRoleLinkerIt->getNext();
}
for (CAdditionalProcessRoleAssertionsLinker* addProcRoleAssertionsLinkerIt = addProcRoleAssertionsLinker; addProcRoleAssertionsLinkerIt; addProcRoleAssertionsLinkerIt = addProcRoleAssertionsLinkerIt->getNext()) {
reverseAssertionRoleLinkerIt = addProcRoleAssertionsLinkerIt->getReverseRoleAssertionLinker();
CDependencyTrackPoint* addDepTrackPoint = addProcRoleAssertionsLinkerIt->getDependencyTrackPoint();
while (reverseAssertionRoleLinkerIt) {
addReverseRoleAssertion(indiProcNode, reverseAssertionRoleLinkerIt, addDepTrackPoint, calcAlgContext);
reverseAssertionRoleLinkerIt = reverseAssertionRoleLinkerIt->getNext();
}
}
indiProcNode->setReverseRoleAssertionsInitialized(true);
}
} else {
calcAlgContext->getProcessingDataBox()->getRoleAssertionExpansionProcessingQueue(true)->insertIndiviudalProcessNode(indiProcNode);
}
initialized = true;
}
}
if (indiProcNode->getLastAssertedDataLiteralLinker() != indiProcNode->getAssertedDataLiteralLinker()) {
for (CProcessAssertedDataLiteralLinker* dataLiteralLinkerIt = indiProcNode->getAssertedDataLiteralLinker(); dataLiteralLinkerIt && dataLiteralLinkerIt != indiProcNode->getLastAssertedDataLiteralLinker(); dataLiteralLinkerIt = dataLiteralLinkerIt->getNext()) {
CDataLiteral* dataLiteral = dataLiteralLinkerIt->getDataLiteral();
CDependencyTrackPoint* depTrackPoint = dataLiteralLinkerIt->getDependencyTrackPoint();
if (mDatatypeHandler && mConfDatatypeReasoning) {
mDatatypeHandler->addDataLiteral(indiProcNode, dataLiteral, false, depTrackPoint, calcAlgContext);
CDatatype* datatype = dataLiteral->getDatatype();
if (datatype && datatype->getDatatypeConcept()) {
addConceptToIndividual(datatype->getDatatypeConcept(), false, indiProcNode, depTrackPoint, true, false, calcAlgContext);
}
}
}
indiProcNode->setLastAssertedDataLiteralLinker(indiProcNode->getAssertedDataLiteralLinker());
}
if (assertionDataLinkerIt || addProcDataAssertionsLinker) {
CDependencyTrackPoint* depTrackPoint = calcAlgContext->getBaseDependencyNode()->getContinueDependencyTrackPoint();
while (assertionDataLinkerIt && assertionDataLinkerIt != indiProcNode->getLastProcessedAssertionDataLinker()) {
addDataAssertion(indiProcNode, assertionDataLinkerIt, depTrackPoint, calcAlgContext);
assertionDataLinkerIt = assertionDataLinkerIt->getNext();
}
indiProcNode->setLastProcessedAssertionDataLinker(indiProcNode->getAssertionDataLinker());
if (addProcDataAssertionsLinker != indiProcNode->getLastProcessedAdditionalDataAssertionLinker()) {
for (CAdditionalProcessDataAssertionsLinker* addProcDataAssertionsLinkerIt = indiProcNode->getAdditionalDataAssertionsLinker(); addProcDataAssertionsLinkerIt && addProcDataAssertionsLinkerIt != indiProcNode->getLastProcessedAdditionalDataAssertionLinker(); addProcDataAssertionsLinkerIt = addProcDataAssertionsLinkerIt->getNext()) {
CDependencyTrackPoint* depTrackPoint = addProcDataAssertionsLinkerIt->getDependencyTrackPoint();
for (CDataAssertionLinker* dataLiteralLinkerIt = addProcDataAssertionsLinkerIt->getDataAssertionLinker(); dataLiteralLinkerIt && dataLiteralLinkerIt; dataLiteralLinkerIt = dataLiteralLinkerIt->getNext()) {
addDataAssertion(indiProcNode, dataLiteralLinkerIt, depTrackPoint, calcAlgContext);
}
}
indiProcNode->setLastProcessedAdditionalDataAssertionLinker(indiProcNode->getAdditionalDataAssertionsLinker());
}
}
if (assInitSignatureBuilded && mOptDetExpPreporcessing) {
cint64 assInitSigValue = assInitSignature.getSignatureValue();
indiProcNode->setAssertionInitialisationSignatureValue(assInitSigValue);
STATINC(SIGNATURESAVINGCOUNT,calcAlgContext);
CProcessingDataBox* processingDataBox = calcAlgContext->getProcessingDataBox();
CSignatureBlockingCandidateHash* sigNomDelCandHash = processingDataBox->getSignatureNominalDelayingCandidateHash(true);
sigNomDelCandHash->insertSignatureBlockingCandidate(assInitSigValue,indiProcNode);
}
if (mConfAddCachedComputedConsequences && indiProcNode->isNominalIndividualNode() && !mOptIncrementalExpansion) {
addCachedComputedTypes(indiProcNode,calcAlgContext);
}
return initialized;
}
bool CCalculationTableauCompletionTaskHandleAlgorithm::addCachedComputedTypes(CIndividualProcessNode*& indiProcNode, CCalculationAlgorithmContextBase* calcAlgContext) {
bool addedConcepts = false;
CIndividual* individual = indiProcNode->getNominalIndividual();
if (individual && mCompConsCacheHandler && !indiProcNode->hasPartialProcessingRestrictionFlags(CIndividualProcessNode::PRFCACHEDCOMPUTEDTYPESADDED)) {
indiProcNode->addProcessingRestrictionFlags(CIndividualProcessNode::PRFCACHEDCOMPUTEDTYPESADDED);
CSortedNegLinker* typeConceptLinker = mCompConsCacheHandler->getCachedTypesConceptLinker(individual,calcAlgContext);
if (typeConceptLinker) {
CDependencyTrackPoint* depTrackPoint = calcAlgContext->getBaseDependencyNode()->getContinueDependencyTrackPoint();
CDependencyTrackPoint* expDepTrackPoint = nullptr;
createANDDependency(expDepTrackPoint,indiProcNode,nullptr,depTrackPoint,calcAlgContext);
addConceptsToIndividual(typeConceptLinker,false,indiProcNode,expDepTrackPoint,true,false,nullptr,calcAlgContext);
addedConcepts = true;
}
}
return addedConcepts;
}
bool CCalculationTableauCompletionTaskHandleAlgorithm::individualNodeInitializing(CIndividualProcessNode*& indiProcNode, CCalculationAlgorithmContextBase* calcAlgContext) {
CIndividualProcessNode* lastIndiProcNode = indiProcNode;
indiProcNode = getLocalizedIndividual(indiProcNode,true,calcAlgContext);
indiProcNode->setProcessingQueued(false);
indiProcNode->setExtendedQueueProcessing(true);
calcAlgContext->setCurrentIndividualNode(indiProcNode);
if (mIndiNodeFromQueueType == INQT_IMMEDIATE) {
indiProcNode->setImmediatelyProcessingQueued(false);
} else if (mIndiNodeFromQueueType == INQT_DELAYEDBACKENDINIT) {
CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData* backendSyncData = (CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData*)indiProcNode->getIndividualBackendCacheSynchronisationData(false);
if (!backendSyncData->isBackendConceptSetInitializationRequired()) {
CIndividualRepresentativeBackendCacheConceptSetLabelProcessingHash* useBackendConceptSetLabelProcessingHash = calcAlgContext->getProcessingDataBox()->getBackendCacheConceptSetLabelProcessingHash(true);
CIndividualRepresentativeBackendCacheConceptSetLabelProcessingHasher hasher = getIndividualRepresentativeBackendCacheConceptSetLabelProcessingHasher(indiProcNode, calcAlgContext);
CIndividualRepresentativeBackendCacheConceptSetLabelProcessingData& processingData = (*useBackendConceptSetLabelProcessingHash)[hasher];
processingData.decQueuedNodeInitializingCount();
CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData* locBackendSyncData = (CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData*)indiProcNode->getIndividualBackendCacheSynchronisationData(true);
if (!locBackendSyncData) {
locBackendSyncData = getLocalizedIndividualBackendCacheSnychronisationData(indiProcNode, calcAlgContext);
}
locBackendSyncData->setBackendConceptSetInitializationRequired(true);
}
} else if (mIndiNodeFromQueueType == INQT_DETEXP) {
indiProcNode->setDeterministicExpandingProcessingQueued(false);
} else if (mIndiNodeFromQueueType == INQT_DEPTHNORMAL || mIndiNodeFromQueueType == INQT_NOMINAL) {
indiProcNode->setRegularDepthProcessingQueued(false);
} else if (mIndiNodeFromQueueType == INQT_BLOCKREACT) {
indiProcNode->setBlockedReactivationProcessingQueued(false);
} else if (mIndiNodeFromQueueType == INQT_DELAYEDNOMINAL) {
indiProcNode->setDelayedNominalProcessingQueued(false);
} else if (mIndiNodeFromQueueType == INQT_BACKENDSYNCRETEST) {
indiProcNode->setBackendSynchronRetestProcessingQueued(false);
} else if (mIndiNodeFromQueueType == INQT_BACKENDDIRECTINFLUENCEEXPANSION) {
indiProcNode->setBackendDirectInfluenceExpansionQueued(false);
} else if (mIndiNodeFromQueueType == INQT_BACKENDINDIRECTCOMPATIBILITYEXPANSION) {
indiProcNode->setBackendIndirectCompatibilityExpansionQueued(false);
}
indiProcNode->resetLastProcessingPriority();
//if (indiProcNode->getNominalIndividual()) {
// if (CIRIName::getRecentIRIName(indiProcNode->getNominalIndividual()->getIndividualNameLinker()) == "#robert_david_bright_1965") {
// bool bug = true;
// }
//}
//}
if (!indiProcNode->hasPurgedBlockedProcessingRestrictionFlags()) {
initialNodeInitialize(indiProcNode, true, calcAlgContext);
if (mIndiNodeFromQueueType == INQT_CACHETEST) {
testIndividualNodeUnsatisfiableCached(indiProcNode, calcAlgContext);
} else if (mIndiNodeFromQueueType == INQT_VSTSATTESTING) {
checkValueSpaceDistinctSatisfiability(indiProcNode, calcAlgContext);
} else if (mIndiNodeFromQueueType == INQT_VSTRIGGERING) {
triggerValueSpaceConcepts(indiProcNode, calcAlgContext);
} else if (mIndiNodeFromQueueType == INQT_BACKENDEXPANSIONREUSE) {
indiProcNode->setBackendReuseExpansionQueued(false);
if (!indiProcNode->hasPurgedBlockedProcessingRestrictionFlags()) {
CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData* backendSyncData = (CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData*)indiProcNode->getIndividualBackendCacheSynchronisationData(false);
if (!indiProcNode->hasPartialProcessingRestrictionFlags(CIndividualProcessNode::PRFBACKENDEXPANSIONREUSEDISCARDED) && !backendSyncData->getBackendExpansionReuseDependencyTrackPoint() && checkIndividualBackendExpansionReuseable(indiProcNode, calcAlgContext)) {
CBackendNeighbourExpansionControllingData* expContData = calcAlgContext->getProcessingDataBox()->getBackendNeighbourExpansionControllingData(true);
if (expContData->isFixedReuseExpansionMode()) {
prepareBackendIndividualFixedReuseExpansion(indiProcNode, calcAlgContext);
}
if (expContData->isPrioritizedReuseExpansionMode()) {
prepareBackendIndividualPrioritizedReuseExpansion(indiProcNode, calcAlgContext);
}
}
if (!indiProcNode->hasPartialProcessingRestrictionFlags(CIndividualProcessNode::PRFBACKENDEXPANSIONREUSEDISCARDED)) {
reuseIndividualBackendExpansion(indiProcNode, calcAlgContext);
}
}
}
if (isIndividualNodeProcessingBlocked(indiProcNode, calcAlgContext)) {
eliminiateBlockedIndividuals(indiProcNode, calcAlgContext);
return false;
}
// counting same concept signature
//conSet = indiProcNode->getReapplyConceptLabelSet(false);
//if (conSet) {
// cint64 sigVal = conSet->getConceptSignature()->getSignatureValue();
// cint64 prevCountVal = mIndiNodeInitConceptSigCountHash.value(sigVal,0);
// mIndiNodeInitConceptSigCountHash.insert(sigVal,prevCountVal+1);
//}
if (mConfSignatureSaving) {
addSignatureIndividualNodeBlockerCandidate(indiProcNode, calcAlgContext);
}
return true;
}
return false;
}
void CCalculationTableauCompletionTaskHandleAlgorithm::checkValueSpaceDistinctSatisfiability(CIndividualProcessNode* processIndi, CCalculationAlgorithmContextBase* calcAlgContext) {
if (mDatatypeHandler && mConfDatatypeReasoning) {
//mEndTaskDebugIndiModelString = generateExtendedDebugIndiModelStringList(calcAlgContext);
//QFile file(QString("datatype-error.txt"));
//if (file.open(QIODevice::WriteOnly)) {
// file.write(mEndTaskDebugIndiModelString.replace("
","\r\n").toLocal8Bit());
// file.close();
//}
CTaskProcessorContext* taskProcessorContext = calcAlgContext->getUsedTaskProcessorContext();
CPROCESSINGSET* distinctIndividualNodeCollectionSet = CObjectParameterizingAllocator< CPROCESSINGSET,CContext* >::allocateAndConstructAndParameterize(taskProcessorContext->getMemoryAllocationManager(),taskProcessorContext);
CPROCESSINGLIST* distinctIndividualNodeCollectionList = CObjectParameterizingAllocator< CPROCESSINGLIST,CContext* >::allocateAndConstructAndParameterize(taskProcessorContext->getMemoryAllocationManager(),taskProcessorContext);
if (mDatatypeHandler->requiresSatisfiabilityChecking(processIndi,calcAlgContext)) {
distinctIndividualNodeCollectionSet->insert(processIndi);
distinctIndividualNodeCollectionList->append(processIndi);
while (!distinctIndividualNodeCollectionList->isEmpty()) {
CIndividualProcessNode* distinctIndiNode = distinctIndividualNodeCollectionList->takeFirst();
CDistinctHash* distinctHash = distinctIndiNode->getDistinctHash(false);
if (distinctHash) {
CDistinctIterator distinctIterator = distinctHash->getDistinctIterator();
while (distinctIterator.hasNext()) {
cint64 nextDistinctIndiID = distinctIterator.nextDistinctIndividualID();
CIndividualProcessNode* nextDistinctIndiNode = getLocalizedIndividual(nextDistinctIndiID,calcAlgContext);
if (mDatatypeHandler->involveDistinctNodeForSatisfiabilityChecking(nextDistinctIndiNode,calcAlgContext)) {
if (!distinctIndividualNodeCollectionSet->contains(nextDistinctIndiNode)) {
distinctIndividualNodeCollectionSet->insert(nextDistinctIndiNode);
distinctIndividualNodeCollectionList->append(nextDistinctIndiNode);
}
}
}
}
}
}
mDatatypeHandler->checkSatisfiability(processIndi,distinctIndividualNodeCollectionSet,calcAlgContext);
}
}
void CCalculationTableauCompletionTaskHandleAlgorithm::triggerValueSpaceConcepts(CIndividualProcessNode* processIndi, CCalculationAlgorithmContextBase* calcAlgContext) {
if (mDatatypeHandler && mConfDatatypeReasoning) {
CConceptDescriptor* triggeredConceptLinker = nullptr;
//mEndTaskDebugIndiModelString = generateExtendedDebugIndiModelStringList(calcAlgContext);
//QFile file(QString("debug-model.txt"));
//if (file.open(QIODevice::WriteOnly)) {
// file.write(mEndTaskDebugIndiModelString.replace("
","\r\n").toLocal8Bit());
// file.close();
//}
mDatatypeHandler->triggerValueSpaceConcepts(processIndi,triggeredConceptLinker,calcAlgContext);
addtriggeredValueSpaceConcepts(processIndi, triggeredConceptLinker, calcAlgContext);
}
}
void CCalculationTableauCompletionTaskHandleAlgorithm::addtriggeredValueSpaceConcepts(CIndividualProcessNode* processIndi, CConceptDescriptor* triggeredConceptLinker, CCalculationAlgorithmContextBase* calcAlgContext) {
CConceptDescriptor* invTriggeredConceptLinker = nullptr;
while (triggeredConceptLinker) {
CConceptDescriptor* tmpTriggeredConceptLinker = triggeredConceptLinker;
triggeredConceptLinker = triggeredConceptLinker->getNextConceptDesciptor();
tmpTriggeredConceptLinker->clearNext();
invTriggeredConceptLinker = tmpTriggeredConceptLinker->append(invTriggeredConceptLinker);
}
for (CConceptDescriptor* triggeredConceptLinkerIt = invTriggeredConceptLinker; triggeredConceptLinkerIt; triggeredConceptLinkerIt = triggeredConceptLinkerIt->getNext()) {
CConcept* triggeredConcept = triggeredConceptLinkerIt->getConcept();
bool triggeredNegation = triggeredConceptLinkerIt->isNegated();
CDependencyTrackPoint* triggeredDependencyTrackPoint = triggeredConceptLinkerIt->getDependencyTrackPoint();
addConceptToIndividual(triggeredConcept, triggeredNegation, processIndi, triggeredDependencyTrackPoint, true, false, calcAlgContext);
}
}
void CCalculationTableauCompletionTaskHandleAlgorithm::tryCompletionGraphReuse(CIndividualProcessNode* processIndi, CCalculationAlgorithmContextBase* calcAlgContext) {
bool minimalCompletionGraph = false;
bool minimalCompletionGraphConnection = false;
if (mReuseCompGraphCacheHandler && mConfCompGraphReuseCacheRetrieval) {
STATINC(COMPLETIONGRAPHREUSECACHERETRIEVALCOUNT,calcAlgContext);
KONCLUCE_TASK_ALGORITHM_TIME_MEASURE_INSTRUCTION(
mComplGraphReuseCacheRetrieval.start();
);
CReuseCompletionGraphCacheEntry* reuseCompGraphCacheEntry = mReuseCompGraphCacheHandler->getReuseCompletionGraphEntry(processIndi,&minimalCompletionGraph,&minimalCompletionGraphConnection,calcAlgContext);
KONCLUCE_TASK_ALGORITHM_TIME_MEASURE_INSTRUCTION(
cint64 timeElapsed = mComplGraphReuseCacheRetrieval.elapsed();
STATINCM(TIMECOMPLETIONGRAPHREUSERETRIVAL,timeElapsed,calcAlgContext);
);
if (reuseCompGraphCacheEntry) {
STATINC(COMPLETIONGRAPHREUSECACHERETRIEVALSUCCESSCOUNT,calcAlgContext);
CXSortedNegLinker* initConceptLinkerIt = processIndi->getProcessInitializingConceptLinker();
CTaskProcessorContext* processorContext = calcAlgContext->getUsedTaskProcessorContext();
CSatisfiableCalculationTask* reuseSatCalcTask = (CSatisfiableCalculationTask*)reuseCompGraphCacheEntry->getJobInstantiation();
CProcessingDataBox* reuseProcessingDataBox = reuseSatCalcTask->getProcessingDataBox();
cint64 reuseBranchingTag = reuseProcessingDataBox->getProcessContext()->getUsedProcessTagger()->getCurrentBranchingTag();
bool deterministicReuse = reuseBranchingTag == 0 && minimalCompletionGraph && minimalCompletionGraphConnection;
if (!deterministicReuse && mConfCompGraphNonDeterministicReuse || deterministicReuse && mConfCompGraphDeterministicReuse) {
cint64 taskCreationCount = 2;
if (deterministicReuse) {
STATINC(COMPLETIONGRAPHREUSECACHEREUSINGDETCOUNT,calcAlgContext);
taskCreationCount = 1;
} else {
STATINC(COMPLETIONGRAPHREUSECACHEREUSINGNONDETCOUNT,calcAlgContext);
}
CSatisfiableCalculationTask* newTaskList = createDependendBranchingTaskList(taskCreationCount,calcAlgContext);
CSatisfiableCalculationTask* newTaskIt = newTaskList;
CREUSECOMPLETIONGRAPHDependencyNode* reuseDepNode = createREUSECOMPLETIONGRAPHDependency(processIndi,nullptr,nullptr,calcAlgContext);
for (cint64 i = 0; i < taskCreationCount; ++i) {
CSatisfiableCalculationTask* newSatCalcTask = newTaskIt;
bool reusingAlternative = i == 0;
if (reusingAlternative) {
CDependencyTrackPoint* newDependencyTrackPoint = nullptr;
if (deterministicReuse) {
newDependencyTrackPoint = calcAlgContext->getBaseDependencyNode()->getContinueDependencyTrackPoint();
} else {
newDependencyTrackPoint = createNonDeterministicDependencyTrackPointBranch(reuseDepNode,false,calcAlgContext);
}
CProcessingDataBox* newProcessingDataBox = newSatCalcTask->getProcessingDataBox();
newProcessingDataBox->initProcessingDataBox(reuseProcessingDataBox);
CProcessContext* newProcessContext = newSatCalcTask->getProcessContext(processorContext);
CCalculationAlgorithmContextBase* newCalcAlgContext = createCalculationAlgorithmContext(processorContext,newProcessContext,newSatCalcTask);
CMemoryAllocationManager* newAllocMemMan = newCalcAlgContext->getUsedProcessTaskMemoryAllocationManager();
CProcessTagger* newProcessTagger = newCalcAlgContext->getUsedProcessTagger();
if (!deterministicReuse) {
newProcessTagger->incBranchingTag();
if (!minimalCompletionGraphConnection) {
newProcessingDataBox->setMaximumDeterministicBranchTag(-1);
}
}
newProcessTagger->incLocalizationTag();
CIndividualProcessNodeVector* indiNodeVec = newProcessingDataBox->getIndividualProcessNodeVector();
cint64 nextIndiID = indiNodeVec->getItemMaxIndex()+1;
CIndividualProcessNode* newIndi = CObjectParameterizingAllocator< CIndividualProcessNode,CProcessContext* >::allocateAndConstructAndParameterize(newAllocMemMan,newProcessContext);
newIndi->setIndividualNodeID(nextIndiID);
newIndi->addProcessingRestrictionFlags(CIndividualProcessNode::PRFINVALIDBLOCKINGORCACHING);
newProcessingDataBox->setConstructedIndividualNode(newIndi);
indiNodeVec->setData(nextIndiID,newIndi);
addConceptsToIndividual(initConceptLinkerIt,false,newIndi,newDependencyTrackPoint,false,true,nullptr,newCalcAlgContext);
CConcept* topConcept = calcAlgContext->getProcessingDataBox()->getOntologyTopConcept();
addConceptToIndividual(topConcept,false,newIndi,newDependencyTrackPoint,false,true,newCalcAlgContext);
prepareBranchedTaskProcessing(newIndi,newSatCalcTask,newCalcAlgContext);
} else {
CProcessContext* newProcessContext = newSatCalcTask->getProcessContext(processorContext);
CCalculationAlgorithmContextBase* newCalcAlgContext = createCalculationAlgorithmContext(processorContext,newProcessContext,newSatCalcTask);
CMemoryAllocationManager* newAllocMemMan = newCalcAlgContext->getUsedProcessTaskMemoryAllocationManager();
CIndividualProcessNode* newLocIndiNode = getLocalizedIndividual(processIndi,false,newCalcAlgContext);
prepareBranchedTaskProcessing(newLocIndiNode,newSatCalcTask,newCalcAlgContext);
}
// set new task priority
double newTaskPriority = calcAlgContext->getUsedTaskPriorityStrategy()->getPriorityForTaskReusing(newSatCalcTask,calcAlgContext->getUsedSatisfiableCalculationTask(),reusingAlternative);
newSatCalcTask->setTaskPriority(newTaskPriority);
newTaskIt = (CSatisfiableCalculationTask*)newTaskIt->getNext();
}
processorContext->getTaskProcessorCommunicator()->communicateTaskCreation(newTaskList);
throw CCalculationStopProcessingException(true);
}
} else {
STATINC(COMPLETIONGRAPHREUSECACHERETRIEVALFAILEDCOUNT,calcAlgContext);
}
}
}
void CCalculationTableauCompletionTaskHandleAlgorithm::eliminiateBlockedIndividuals(CIndividualProcessNode*& indiProcNode, CCalculationAlgorithmContextBase* calcAlgContext) {
//if (indiProcNode->hasPartialProcessingRestrictionFlags(CIndividualProcessNode::PRFINVALIDATEBLOCKERFLAGSCOMPINATION)) {
if (indiProcNode->hasBlockedIndividualsLinker()) {
// reactivate all blocked individuals
reactivateBlockedIndividuals(indiProcNode,calcAlgContext);
}
if (indiProcNode->hasBlockingFollower()) {
CBlockingFollowSet* followerSet = indiProcNode->getBlockingFollowSet(false);
for (CPROCESSSET::const_iterator it = followerSet->constBegin(), itEnd = followerSet->constEnd(); it != itEnd; ++it) {
cint64 blockingIndiNodeID = *it;
CIndividualProcessNode* blockingIndiNode = getUpToDateIndividual(blockingIndiNodeID,calcAlgContext);
addIndividualToBlockingUpdateReviewProcessingQueue(blockingIndiNode,calcAlgContext);
}
}
CXLinker* processingBlockedNodeLinker = indiProcNode->getProcessingBlockedIndividualsLinker();
while (processingBlockedNodeLinker) {
CIndividualProcessNode* blockedNode = processingBlockedNodeLinker->getData();
CIndividualProcessNode* locBlockedNode = getLocalizedIndividual(blockedNode,true,calcAlgContext);
locBlockedNode->addProcessingRestrictionFlags(CIndividualProcessNode::PRFBLOCKINGRETESTDUEPROCESSINGCOMPLETED);
addIndividualToProcessingQueue(locBlockedNode,calcAlgContext);
processingBlockedNodeLinker = processingBlockedNodeLinker->getNext();
}
indiProcNode->clearBlockedIndividualsLinker();
//}
}
CIndividualProcessNode* CCalculationTableauCompletionTaskHandleAlgorithm::getDelayProcessingBlockingNominalNode(CIndividualProcessNode* testIndi, CCalculationAlgorithmContextBase* calcAlgContext) {
CIndividualProcessNode* nominalBlockerIndividual = nullptr;
CProcessingDataBox* processingDataBox = calcAlgContext->getProcessingDataBox();
CSignatureBlockingCandidateHash* sigNomDelCandHash = processingDataBox->getSignatureNominalDelayingCandidateHash(false);
CReapplyConceptLabelSet* conSet = testIndi->getReapplyConceptLabelSet(false);
if (conSet && sigNomDelCandHash) {
cint64 assConSig = testIndi->getAssertionInitialisationSignatureValue();
CSignatureBlockingCandidateIterator candIt(sigNomDelCandHash->getBlockingCandidatesIterator(assConSig));
while (!nominalBlockerIndividual && candIt.hasNext()) {
cint64 candIndiID = candIt.next(true);
if (candIndiID != testIndi->getIndividualNodeID()) {
CIndividualProcessNode* candIndiNode = getUpToDateIndividual(candIndiID,calcAlgContext);
if (candIndiNode->isNominalIndividualNode() && candIndiNode->getNominalIndividual() && !candIndiNode->hasPartialProcessingRestrictionFlags(CIndividualProcessNode::PRFPURGEDBLOCKED)) {
CReapplyConceptLabelSet* blockerConSet = candIndiNode->getReapplyConceptLabelSet(false);
if (isLabelConceptSubSetIgnoreNominals(conSet,blockerConSet, nullptr,calcAlgContext)) {
nominalBlockerIndividual = candIndiNode;
}
}
}
}
}
return nominalBlockerIndividual;
}
bool CCalculationTableauCompletionTaskHandleAlgorithm::tryDelayNominalProcessing(CConceptProcessDescriptor* conProDes, CIndividualProcessNode* testIndi, CCalculationAlgorithmContextBase* calcAlgContext) {
if (canDelayNominalProcessing(conProDes,testIndi,calcAlgContext)) {
testIndi->setNominalProcessingDelayingChecked(true);
bool notConnectedNominal = false;
CSuccessorIterator succIt(testIndi->getSuccessorIterator());
if (!succIt.hasNext()) {
notConnectedNominal = true;
}
if (notConnectedNominal) {
CIndividualProcessNode* blockerNominalIndiNode = getDelayProcessingBlockingNominalNode(testIndi,calcAlgContext);
if (blockerNominalIndiNode) {
CProcessingDataBox* processingDataBox = calcAlgContext->getProcessingDataBox();
CIndividualUnsortedProcessingQueue* delayingNominalProcessingQueu = processingDataBox->getDelayingNominalProcessingQueue(true);
delayingNominalProcessingQueu->insertIndiviudalProcessNode(testIndi);
testIndi->setDelayedNominalProcessingQueued(true);
return true;
}
}
}
return false;
}
bool CCalculationTableauCompletionTaskHandleAlgorithm::canDelayNominalProcessing(CConceptProcessDescriptor* conProDes, CIndividualProcessNode* testIndi, CCalculationAlgorithmContextBase* calcAlgContext) {
if (testIndi->isNominalIndividualNode() && testIndi->getNominalIndividual()) {
if (conProDes->getProcessPriority() < mImmediatelyProcessPriority) {
if (!testIndi->hasNominalProcessingDelayingChecked()) {
return true;
}
}
}
return false;
}
void CCalculationTableauCompletionTaskHandleAlgorithm::individualNodeConclusion(CIndividualProcessNode*& indiProcNode, CCalculationAlgorithmContextBase* calcAlgContext) {
if (mIndiNodeConcludeUnsatCaching) {
testIndividualNodeUnsatisfiableCached(indiProcNode,calcAlgContext);
}
calcAlgContext->setCurrentIndividualNode(nullptr);
addIndividualToProcessingQueue(indiProcNode,calcAlgContext);
//CConceptProcessingQueue* conProQue = indiProcNode->getConceptProcessingQueue(false);
//if (nodeProcessingBreaked && conProQue && !conProQue->isEmpty()) {
// addIndividualToProcessingQueue(indiProcNode,false,calcAlgContext);
//} else if (!conProQue || conProQue->isEmpty()) {
// propagateIndividualProcessedAndReactivate(indiProcNode,calcAlgContext);
//}
}
bool CCalculationTableauCompletionTaskHandleAlgorithm::tableauRuleProcessing(CIndividualProcessNode*& indiProcNode,CConceptProcessDescriptor*& conProcDes, CCalculationAlgorithmContextBase* calcAlgContext) {
CConceptDescriptor* conDes = conProcDes->getConceptDescriptor();
bool conNeg = conDes->getNegation();
CConcept* concept = conDes->getConcept();
cint64 conOpCode = concept->getOperatorCode();
if (tryDelayNominalProcessing(conProcDes,indiProcNode,calcAlgContext)) {
return false;
}
if (needsIndividualNodeExpansionBlockingTest(conProcDes,indiProcNode,calcAlgContext)) {
if (isIndividualNodeBackendCacheSynchronizationProcessingBlocked(indiProcNode,calcAlgContext)) {
return false;
}
if (isIndividualNodeExpansionBlocked(indiProcNode,calcAlgContext)) {
return false;
}
}
tableauRuleChoice(indiProcNode,conProcDes,calcAlgContext);
return true;
}
void CCalculationTableauCompletionTaskHandleAlgorithm::tableauRuleChoice(CIndividualProcessNode*& indiProcNode,CConceptProcessDescriptor*& conProcDes, CCalculationAlgorithmContextBase* calcAlgContext) {
CConceptDescriptor* conDes = conProcDes->getConceptDescriptor();
bool conNeg = conDes->getNegation();
CConcept* concept = conDes->getConcept();
cint64 conOpCode = concept->getOperatorCode();
++mCurrentRecProcDepth;
TableauRuleFunction func = nullptr;
if (!conNeg) {
func = mPosJumpFuncVec[conOpCode];
if (func) {
(this->*func)(indiProcNode,conProcDes,false,calcAlgContext);
}
mLastJumpFunc = func;
} else {
func = mNegJumpFuncVec[conOpCode];
if (func) {
(this->*func)(indiProcNode,conProcDes,true,calcAlgContext);
}
mLastJumpFunc = func;
}
--mCurrentRecProcDepth;
}
void CCalculationTableauCompletionTaskHandleAlgorithm::applyNegAutomatChooseRule(CIndividualProcessNode*& processIndi, CConceptProcessDescriptor*& conProDes, bool negate, CCalculationAlgorithmContextBase* calcAlgContext) {
applyAutomatChooseRule(processIndi,conProDes,!negate,calcAlgContext);
}
void CCalculationTableauCompletionTaskHandleAlgorithm::applyNegANDRule(CIndividualProcessNode*& processIndi, CConceptProcessDescriptor*& conProDes, bool negate, CCalculationAlgorithmContextBase* calcAlgContext) {
applyANDRule(processIndi,conProDes,!negate,calcAlgContext);
}
void CCalculationTableauCompletionTaskHandleAlgorithm::applyNegSOMERule(CIndividualProcessNode*& processIndi, CConceptProcessDescriptor*& conProDes, bool negate, CCalculationAlgorithmContextBase* calcAlgContext) {
applySOMERule(processIndi,conProDes,!negate,calcAlgContext);
}
void CCalculationTableauCompletionTaskHandleAlgorithm::applyNegALLRule(CIndividualProcessNode*& processIndi, CConceptProcessDescriptor*& conProDes, bool negate, CCalculationAlgorithmContextBase* calcAlgContext) {
applyALLRule(processIndi,conProDes,!negate,calcAlgContext);
}
void CCalculationTableauCompletionTaskHandleAlgorithm::applyNegORRule(CIndividualProcessNode*& processIndi, CConceptProcessDescriptor*& conProDes, bool negate, CCalculationAlgorithmContextBase* calcAlgContext) {
applyORRule(processIndi,conProDes,!negate,calcAlgContext);
}
void CCalculationTableauCompletionTaskHandleAlgorithm::applyNegATMOSTRule(CIndividualProcessNode*& processIndi, CConceptProcessDescriptor*& conProDes, bool negate, CCalculationAlgorithmContextBase* calcAlgContext) {
applyATLEASTRule(processIndi,conProDes,negate,calcAlgContext);
}
void CCalculationTableauCompletionTaskHandleAlgorithm::applyNegATLEASTRule(CIndividualProcessNode*& processIndi, CConceptProcessDescriptor*& conProDes, bool negate, CCalculationAlgorithmContextBase* calcAlgContext) {
applyATMOSTRule(processIndi,conProDes,negate,calcAlgContext);
}
void CCalculationTableauCompletionTaskHandleAlgorithm::applyAutomatChooseRule(CIndividualProcessNode*& processIndi, CConceptProcessDescriptor*& conProDes, bool negate, CCalculationAlgorithmContextBase* calcAlgContext) {
STATINC(AUTOMATEINITCOUNT,calcAlgContext);
CConceptDescriptor* conDes = conProDes->getConceptDescriptor();
CConcept* concept = conDes->getConcept();
bool conceptNegation = negate;
CDependencyTrackPoint* depTrackPoint = conProDes->getDependencyTrackPoint();
CSortedNegLinker* conceptOpLinkerIt = concept->getOperandList();
// create dependency
CDependencyTrackPoint* nextDepTrackPoint = nullptr;
CAUTOMATCHOOSEDependencyNode* andDepNode = createAUTOMATCHOOSEDependency(nextDepTrackPoint,processIndi,conDes,depTrackPoint,calcAlgContext);
while (conceptOpLinkerIt) {
CConcept* opConcept = conceptOpLinkerIt->getData();
bool opNegation = conceptOpLinkerIt->isNegated();
if (opNegation == negate) {
addConceptToIndividual(opConcept,false,processIndi,nextDepTrackPoint,true,false,calcAlgContext);
}
conceptOpLinkerIt = conceptOpLinkerIt->getNext();
}
}
void CCalculationTableauCompletionTaskHandleAlgorithm::applyAutomatANDRule(CIndividualProcessNode*& processIndi, CConceptProcessDescriptor*& conProDes, bool negate, CCalculationAlgorithmContextBase* calcAlgContext) {
CConceptDescriptor* conDes = conProDes->getConceptDescriptor();
CConcept* concept = conDes->getConcept();
bool conceptNegation = negate;
CDependencyTrackPoint* depTrackPoint = conProDes->getDependencyTrackPoint();
applyAutomatTransactions(processIndi,conProDes,concept,negate,calcAlgContext);
}
bool CCalculationTableauCompletionTaskHandleAlgorithm::isRestrictedTopObjectPropertyPropagation(CIndividualProcessNode*& processIndi, CIndividualProcessNode*& destIndi, CConcept* concept, bool negated, CCalculationAlgorithmContextBase* calcAlgContext) {
CSatisfiableTaskAnswererBindingPropagationAdapter* answererMessageAdapter = calcAlgContext->getSatisfiableCalculationTask()->getSatisfiableAnswererBindingPropagationAdapter();
if (answererMessageAdapter) {
CAnsweringPropagationSteeringController* propagationSteeringController = answererMessageAdapter->getAnswererPropagationSteeringController();
if (propagationSteeringController) {
if (propagationSteeringController->isRestrictedTopPropagation(concept)) {
cint64 univConnIndiId = calcAlgContext->getProcessingDataBox()->getOntology()->getABox()->getUniversalConnectionIndividualID();
if (processIndi->getIndividualNodeID() == -univConnIndiId || destIndi->getIndividualNodeID() == -univConnIndiId || processIndi->getNominalIndividual() && destIndi->getNominalIndividual() || destIndi->getNominalIndividual()) {
return true;
}
}
}
}
return false;
}
void CCalculationTableauCompletionTaskHandleAlgorithm::applyAutomatTransactions(CIndividualProcessNode*& processIndi, CConceptProcessDescriptor*& conProDes, CConcept* concept, bool negated, CCalculationAlgorithmContextBase* calcAlgContext) {
STATINC(AUTOMATERULEAPPLICATIONCOUNT,calcAlgContext);
CConceptDescriptor* baseConDes = conProDes->getConceptDescriptor();
bool reapplied = conProDes->isConceptReapplied();
CIndividualLinkEdge* restLink = getLinkProcessingRestriction(conProDes);
CDependencyTrackPoint* depTrackPoint = conProDes->getDependencyTrackPoint();
cint64 opCode = concept->getOperatorCode();
CSortedNegLinker* opConcepts = concept->getOperandList();
if (opCode == CCAQAND || opCode == CCIMPLAQAND || opCode == CCBRANCHAQAND) {
while (opConcepts) {
++mAppliedALLRuleCount;
STATINC(AUTOMATESTATECOUNT,calcAlgContext);
CConcept* opCon = opConcepts->getData();
bool opConNeg = opConcepts->isNegated();
applyAutomatTransactions(processIndi,conProDes,opCon,opConNeg,calcAlgContext);
opConcepts = opConcepts->getNext();
}
} else if (opCode == CCAQALL || opCode == CCIMPLAQALL || opCode == CCBRANCHAQALL) {
CRole* role = concept->getRole();
if (restLink) {
if (restLink->getLinkRole() == role) {
++mAppliedALLRuleCount;
STATINC(AUTOMATETRANSACTIONCOUNT,calcAlgContext);
CDependencyTrackPoint* nextDepTrackPoint = nullptr;
CAUTOMATTRANSACTIONDependencyNode* allDepNode = nullptr;
bool allDepNodeCreated = false;
CIndividualProcessNode* succIndi = getSuccessorIndividual(processIndi,restLink,calcAlgContext);
if (!isRestrictedTopObjectPropertyPropagation(processIndi, succIndi, concept, negated, calcAlgContext)) {
CIndividualProcessNode* locSuccIndi = nullptr;
CReapplyConceptLabelSet* conLabelSet = succIndi->getReapplyConceptLabelSet(false);
CSortedNegLinker* conceptOpLinkerIt = opConcepts;
while (conceptOpLinkerIt) {
CConcept* opConcept = conceptOpLinkerIt->getData();
bool opConNeg = conceptOpLinkerIt->isNegated() ^ negated;
if (!conLabelSet->containsConcept(opConcept, opConNeg)) {
// create dependency
if (!allDepNodeCreated) {
allDepNodeCreated = true;
allDepNode = createAUTOMATTRANSACTIONDependency(nextDepTrackPoint, processIndi, baseConDes, depTrackPoint, restLink->getDependencyTrackPoint(), calcAlgContext);
}
// add concept
if (!locSuccIndi) {
locSuccIndi = getLocalizedIndividual(succIndi, false, calcAlgContext);
conLabelSet = locSuccIndi->getReapplyConceptLabelSet(true);
}
addConceptToIndividual(opConcept, opConNeg, locSuccIndi, nextDepTrackPoint, true, true, calcAlgContext);
}
conceptOpLinkerIt = conceptOpLinkerIt->getNext();
}
if (locSuccIndi) {
addIndividualToProcessingQueue(locSuccIndi, calcAlgContext);
}
}
}
} else {
CReapplyRoleSuccessorHash* roleSuccHash = processIndi->getReapplyRoleSuccessorHash(false);
if (roleSuccHash) {
CRoleSuccessorLinkIterator roleSuccIt = roleSuccHash->getRoleSuccessorLinkIterator(role);
while (roleSuccIt.hasNext()) {
++mAppliedALLRuleCount;
STATINC(AUTOMATETRANSACTIONCOUNT,calcAlgContext);
CDependencyTrackPoint* nextDepTrackPoint = nullptr;
CAUTOMATTRANSACTIONDependencyNode* allDepNode = nullptr;
bool allDepNodeCreated = false;
CIndividualLinkEdge* link = roleSuccIt.next(true);
CIndividualProcessNode* succIndi = getSuccessorIndividual(processIndi,link,calcAlgContext);
if (!isRestrictedTopObjectPropertyPropagation(processIndi, succIndi, concept, negated, calcAlgContext)) {
CIndividualProcessNode* locSuccIndi = nullptr;
CReapplyConceptLabelSet* conLabelSet = succIndi->getReapplyConceptLabelSet(false);
CSortedNegLinker* conceptOpLinkerIt = opConcepts;
while (conceptOpLinkerIt) {
CConcept* opConcept = conceptOpLinkerIt->getData();
bool opConNeg = conceptOpLinkerIt->isNegated() ^ negated;
if (!conLabelSet->containsConcept(opConcept, opConNeg)) {
// create dependency
if (!allDepNodeCreated) {
allDepNodeCreated = true;
allDepNode = createAUTOMATTRANSACTIONDependency(nextDepTrackPoint, processIndi, baseConDes, depTrackPoint, link->getDependencyTrackPoint(), calcAlgContext);
}
// add concept
if (!locSuccIndi) {
locSuccIndi = getLocalizedIndividual(succIndi, false, calcAlgContext);
conLabelSet = locSuccIndi->getReapplyConceptLabelSet(true);
}
addConceptToIndividual(opConcept, opConNeg, locSuccIndi, nextDepTrackPoint, true, true, calcAlgContext);
}
conceptOpLinkerIt = conceptOpLinkerIt->getNext();
}
if (locSuccIndi) {
addIndividualToProcessingQueue(locSuccIndi, calcAlgContext);
}
}
}
}
}
if (!reapplied) {
// add to reapply queue
addConceptToReapplyQueue(baseConDes,role,processIndi,true,depTrackPoint,calcAlgContext);
}
} else if (!reapplied) {
addConceptToIndividual(concept,negated,processIndi,depTrackPoint,true,true,calcAlgContext);
}
}
CREPRESENTATIVEGROUNDINGDependencyNode* CCalculationTableauCompletionTaskHandleAlgorithm::createREPRESENTATIVEGROUNDINGDependency(CDependencyTrackPoint*& implContinueDepTrackPoint, CIndividualProcessNode*& processIndi, CConceptDescriptor* conDes, CDependencyTrackPoint* prevDepTrackPoint, CVariableBindingPath* selectVarBindPath, CCalculationAlgorithmContextBase* calcAlgContext) {
CREPRESENTATIVEGROUNDINGDependencyNode* depNode = nullptr;
if (mConfBuildDependencies) {
depNode = calcAlgContext->getUsedDependencyFactory()->createREPRESENTATIVEGROUNDINGDependency(implContinueDepTrackPoint,processIndi,conDes,prevDepTrackPoint,selectVarBindPath,calcAlgContext);
}
return depNode;
}
CREPRESENTATIVEJOINDependencyNode* CCalculationTableauCompletionTaskHandleAlgorithm::createREPRESENTATIVEJOINDependency(CDependencyTrackPoint*& joinContinueDepTrackPoint, CIndividualProcessNode*& processIndi, CConceptDescriptor* conDes, CDependencyTrackPoint* prevDepTrackPoint, CDependencyTrackPoint* otherDepTrackPoint, CCalculationAlgorithmContextBase* calcAlgContext) {
CREPRESENTATIVEJOINDependencyNode* depNode = nullptr;
if (mConfBuildDependencies) {
depNode = calcAlgContext->getUsedDependencyFactory()->createREPRESENTATIVEJOINDependency(joinContinueDepTrackPoint,processIndi,conDes,prevDepTrackPoint,otherDepTrackPoint,calcAlgContext);
}
return depNode;
}
CREPRESENTATIVEBINDVARIABLEDependencyNode* CCalculationTableauCompletionTaskHandleAlgorithm::createREPRESENTATIVEBINDVARIABLEDependency(CDependencyTrackPoint*& andDepTrackPoint, CIndividualProcessNode*& processIndi, CConceptDescriptor* conDes, CDependencyTrackPoint* prevDepTrackPoint, CCalculationAlgorithmContextBase* calcAlgContext) {
CREPRESENTATIVEBINDVARIABLEDependencyNode* depNode = nullptr;
if (mConfBuildDependencies) {
depNode = calcAlgContext->getUsedDependencyFactory()->createREPRESENTATIVEBINDVARIABLEDependency(andDepTrackPoint,processIndi,conDes,prevDepTrackPoint,calcAlgContext);
}
return depNode;
}
CREPRESENTATIVEIMPLICATIONDependencyNode* CCalculationTableauCompletionTaskHandleAlgorithm::createREPRESENTATIVEIMPLICATIONDependency(CDependencyTrackPoint*& implContinueDepTrackPoint, CIndividualProcessNode*& processIndi, CConceptDescriptor* conDes, CDependencyTrackPoint* prevDepTrackPoint, CDependency* prevOtherDependencies, CCalculationAlgorithmContextBase* calcAlgContext) {
CREPRESENTATIVEIMPLICATIONDependencyNode* depNode = nullptr;
if (mConfBuildDependencies) {
depNode = calcAlgContext->getUsedDependencyFactory()->createREPRESENTATIVEIMPLICATIONDependency(implContinueDepTrackPoint,processIndi,conDes,prevDepTrackPoint,prevOtherDependencies,calcAlgContext);
}
return depNode;
}
CREPRESENTATIVEALLDependencyNode* CCalculationTableauCompletionTaskHandleAlgorithm::createREPRESENTATIVEALLDependency(CDependencyTrackPoint*& allDepTrackPoint, CIndividualProcessNode*& processIndi, CConceptDescriptor* conDes, CDependencyTrackPoint* prevDepTrackPoint, CDependencyTrackPoint* linkDepTrackPoint, CCalculationAlgorithmContextBase* calcAlgContext) {
CREPRESENTATIVEALLDependencyNode* depNode = nullptr;
if (mConfBuildDependencies) {
depNode = calcAlgContext->getUsedDependencyFactory()->createREPRESENTATIVEALLDependency(allDepTrackPoint,processIndi,conDes,prevDepTrackPoint,linkDepTrackPoint,calcAlgContext);
}
return depNode;
}
CREPRESENTATIVEANDDependencyNode* CCalculationTableauCompletionTaskHandleAlgorithm::createREPRESENTATIVEANDDependency(CDependencyTrackPoint*& andDepTrackPoint, CIndividualProcessNode*& processIndi, CConceptDescriptor* conDes, CDependencyTrackPoint* prevDepTrackPoint, CCalculationAlgorithmContextBase* calcAlgContext) {
CREPRESENTATIVEANDDependencyNode* depNode = nullptr;
if (mConfBuildDependencies) {
depNode = calcAlgContext->getUsedDependencyFactory()->createREPRESENTATIVEANDDependency(andDepTrackPoint,processIndi,conDes,prevDepTrackPoint,calcAlgContext);
}
return depNode;
}
CRESOLVEREPRESENTATIVEDependencyNode* CCalculationTableauCompletionTaskHandleAlgorithm::createRESOLVEREPRESENTATIVEDependency(CDependencyTrackPoint*& andDepTrackPoint, CIndividualProcessNode*& processIndi, CConceptDescriptor* conDes, CRepresentativeVariableBindingPathMap* resolveVarBindPathMap, CRepresentativePropagationMap* resolveRepPropMap, CDependencyTrackPoint* prevDepTrackPoint, CDependencyTrackPoint* additionalDepTrackPoint, CCalculationAlgorithmContextBase* calcAlgContext) {
CRESOLVEREPRESENTATIVEDependencyNode* depNode = nullptr;
if (mConfBuildDependencies) {
depNode = calcAlgContext->getUsedDependencyFactory()->createRESOLVEREPRESENTATIVEDependency(andDepTrackPoint,processIndi,conDes,resolveVarBindPathMap,resolveRepPropMap,prevDepTrackPoint,additionalDepTrackPoint,calcAlgContext);
}
return depNode;
}
CPROPAGATEVARIABLECONNECTIONDependencyNode* CCalculationTableauCompletionTaskHandleAlgorithm::createPROPAGATEVARIABLECONNECTIONDependency(CIndividualProcessNode* processIndi, CConceptDescriptor* conDes, CDependencyTrackPoint* prevDepTrackPoint, CCalculationAlgorithmContextBase* calcAlgContext) {
CPROPAGATEVARIABLECONNECTIONDependencyNode* depNode = nullptr;
if (mConfBuildDependencies) {
depNode = calcAlgContext->getUsedDependencyFactory()->createPROPAGATEVARIABLECONNECTIONDependency(processIndi,conDes,prevDepTrackPoint,calcAlgContext);
}
return depNode;
}
CVARBINDPROPAGATEIMPLICATIONDependencyNode* CCalculationTableauCompletionTaskHandleAlgorithm::createVARBINDPROPAGATEIMPLICATIONDependency(CDependencyTrackPoint*& implContinueDepTrackPoint, CIndividualProcessNode*& processIndi, CConceptDescriptor* conDes, CDependencyTrackPoint* prevDepTrackPoint, CDependency* prevOtherDependencies, CCalculationAlgorithmContextBase* calcAlgContext) {
CVARBINDPROPAGATEIMPLICATIONDependencyNode* depNode = nullptr;
if (mConfBuildDependencies) {
depNode = calcAlgContext->getUsedDependencyFactory()->createVARBINDPROPAGATEIMPLICATIONDependency(implContinueDepTrackPoint,processIndi,conDes,prevDepTrackPoint,prevOtherDependencies,calcAlgContext);
}
return depNode;
}
CVARBINDPROPAGATEGROUNDINGDependencyNode* CCalculationTableauCompletionTaskHandleAlgorithm::createVARBINDPROPAGATEGROUNDINGDependency(CDependencyTrackPoint*& implContinueDepTrackPoint, CIndividualProcessNode*& processIndi, CConceptDescriptor* conDes, CDependencyTrackPoint* prevDepTrackPoint, CDependency* prevOtherDependencies, CCalculationAlgorithmContextBase* calcAlgContext) {
CVARBINDPROPAGATEGROUNDINGDependencyNode* depNode = nullptr;
if (mConfBuildDependencies) {
depNode = calcAlgContext->getUsedDependencyFactory()->createVARBINDPROPAGATEGROUNDINGDependency(implContinueDepTrackPoint,processIndi,conDes,prevDepTrackPoint,prevOtherDependencies,calcAlgContext);
}
return depNode;
}
CVARBINDPROPAGATEALLDependencyNode* CCalculationTableauCompletionTaskHandleAlgorithm::createVARBINDPROPAGATEALLDependency(CDependencyTrackPoint*& allDepTrackPoint, CIndividualProcessNode*& processIndi, CConceptDescriptor* conDes, CDependencyTrackPoint* prevDepTrackPoint, CDependencyTrackPoint* linkDepTrackPoint, CCalculationAlgorithmContextBase* calcAlgContext) {
CVARBINDPROPAGATEALLDependencyNode* depNode = nullptr;
if (mConfBuildDependencies) {
depNode = calcAlgContext->getUsedDependencyFactory()->createVARBINDPROPAGATEALLDependency(allDepTrackPoint,processIndi,conDes,prevDepTrackPoint,linkDepTrackPoint,calcAlgContext);
}
return depNode;
}
CVARBINDPROPAGATEANDDependencyNode* CCalculationTableauCompletionTaskHandleAlgorithm::createVARBINDPROPAGATEANDDependency(CDependencyTrackPoint*& andDepTrackPoint, CIndividualProcessNode*& processIndi, CConceptDescriptor* conDes, CDependencyTrackPoint* prevDepTrackPoint, CCalculationAlgorithmContextBase* calcAlgContext) {
CVARBINDPROPAGATEANDDependencyNode* depNode = nullptr;
if (mConfBuildDependencies) {
depNode = calcAlgContext->getUsedDependencyFactory()->createVARBINDPROPAGATEANDDependency(andDepTrackPoint,processIndi,conDes,prevDepTrackPoint,calcAlgContext);
}
return depNode;
}
CPROPAGATEVARIABLEBINDINGDependencyNode* CCalculationTableauCompletionTaskHandleAlgorithm::createPROPAGATEVARIABLEBINDINGDependency(CDependencyTrackPoint*& andDepTrackPoint, CIndividualProcessNode*& processIndi, CConceptDescriptor* conDes, CDependencyTrackPoint* prevDepTrackPoint, CDependency* prevOtherDependencies, CCalculationAlgorithmContextBase* calcAlgContext) {
CPROPAGATEVARIABLEBINDINGDependencyNode* depNode = nullptr;
if (mConfBuildDependencies) {
depNode = calcAlgContext->getUsedDependencyFactory()->createPROPAGATEVARIABLEBINDINGDependency(andDepTrackPoint,processIndi,conDes,prevDepTrackPoint,prevOtherDependencies,calcAlgContext);
}
return depNode;
}
CPROPAGATEVARIABLEBINDINGSSUCCESSORDependencyNode* CCalculationTableauCompletionTaskHandleAlgorithm::createPROPAGATEVARIABLEBINDINGSSUCCESSORDependency(CDependencyTrackPoint*& allDepTrackPoint, CIndividualProcessNode*& processIndi, CConceptDescriptor* conDes, CDependencyTrackPoint* prevDepTrackPoint, CDependencyTrackPoint* linkDepTrackPoint, CCalculationAlgorithmContextBase* calcAlgContext) {
CPROPAGATEVARIABLEBINDINGSSUCCESSORDependencyNode* depNode = nullptr;
if (mConfBuildDependencies) {
depNode = calcAlgContext->getUsedDependencyFactory()->createPROPAGATEVARIABLEBINDINGSSUCCESSORDependency(allDepTrackPoint,processIndi,conDes,prevDepTrackPoint,linkDepTrackPoint,calcAlgContext);
}
return depNode;
}
CVARBINDVARIABLEDependencyNode* CCalculationTableauCompletionTaskHandleAlgorithm::createVARBINDVARIABLEDependency(CDependencyTrackPoint*& andDepTrackPoint, CIndividualProcessNode*& processIndi, CConceptDescriptor* conDes, CDependencyTrackPoint* prevDepTrackPoint, CCalculationAlgorithmContextBase* calcAlgContext) {
CVARBINDVARIABLEDependencyNode* depNode = nullptr;
if (mConfBuildDependencies) {
depNode = calcAlgContext->getUsedDependencyFactory()->createVARBINDVARIABLEDependency(andDepTrackPoint,processIndi,conDes,prevDepTrackPoint,calcAlgContext);
}
return depNode;
}
CVARBINDPROPAGATEJOINDependencyNode* CCalculationTableauCompletionTaskHandleAlgorithm::createVARBINDPROPAGATEJOINDependency(CDependencyTrackPoint*& continueDepTrackPoint, CIndividualProcessNode*& processIndi, CConceptDescriptor* conDes, CDependencyTrackPoint* prevDepTrackPoint, CDependencyTrackPoint* otherDepTrackPoint, CCalculationAlgorithmContextBase* calcAlgContext) {
CVARBINDPROPAGATEJOINDependencyNode* depNode = nullptr;
if (mConfBuildDependencies) {
depNode = calcAlgContext->getUsedDependencyFactory()->createVARBINDPROPAGATEJOINDependency(continueDepTrackPoint,processIndi,conDes,prevDepTrackPoint,otherDepTrackPoint,calcAlgContext);
}
return depNode;
}
CBINDPROPAGATEGROUNDINGDependencyNode* CCalculationTableauCompletionTaskHandleAlgorithm::createBINDPROPAGATEGROUNDINGDependency(CDependencyTrackPoint*& implContinueDepTrackPoint, CIndividualProcessNode*& processIndi, CConceptDescriptor* conDes, CDependencyTrackPoint* prevDepTrackPoint, CDependency* prevOtherDependencies, CCalculationAlgorithmContextBase* calcAlgContext) {
CBINDPROPAGATEGROUNDINGDependencyNode* depNode = nullptr;
if (mConfBuildDependencies) {
depNode = calcAlgContext->getUsedDependencyFactory()->createBINDPROPAGATEGROUNDINGDependency(implContinueDepTrackPoint,processIndi,conDes,prevDepTrackPoint,prevOtherDependencies,calcAlgContext);
}
return depNode;
}
CPROPAGATECONNECTIONAWAYDependencyNode* CCalculationTableauCompletionTaskHandleAlgorithm::createPROPAGATECONNECTIONAWAYDependency(CIndividualProcessNode* processIndi, CConceptDescriptor* conDes, CDependencyTrackPoint* prevDepTrackPoint, CCalculationAlgorithmContextBase* calcAlgContext) {
CPROPAGATECONNECTIONAWAYDependencyNode* depNode = nullptr;
if (mConfBuildDependencies) {
depNode = calcAlgContext->getUsedDependencyFactory()->createPROPAGATECONNECTIONAWAYDependency(processIndi,conDes,prevDepTrackPoint,calcAlgContext);
}
return depNode;
}
CPROPAGATECONNECTIONDependencyNode* CCalculationTableauCompletionTaskHandleAlgorithm::createPROPAGATECONNECTIONDependency(CIndividualProcessNode* processIndi, CConceptDescriptor* conDes, CDependencyTrackPoint* prevDepTrackPoint, CCalculationAlgorithmContextBase* calcAlgContext) {
CPROPAGATECONNECTIONDependencyNode* depNode = nullptr;
if (mConfBuildDependencies) {
depNode = calcAlgContext->getUsedDependencyFactory()->createPROPAGATECONNECTIONDependency(processIndi,conDes,prevDepTrackPoint,calcAlgContext);
}
return depNode;
}
CBINDPROPAGATECYCLEDependencyNode* CCalculationTableauCompletionTaskHandleAlgorithm::createBINDPROPAGATECYCLEDependency(CDependencyTrackPoint*& continueDepTrackPoint, CIndividualProcessNode*& processIndi, CConceptDescriptor* conDes, CDependencyTrackPoint* prevDepTrackPoint, CDependencyTrackPoint* triggDepTrackPoint, CCalculationAlgorithmContextBase* calcAlgContext) {
CBINDPROPAGATECYCLEDependencyNode* depNode = nullptr;
if (mConfBuildDependencies) {
depNode = calcAlgContext->getUsedDependencyFactory()->createBINDPROPAGATECYCLEDependency(continueDepTrackPoint,processIndi,conDes,prevDepTrackPoint,triggDepTrackPoint,calcAlgContext);
}
return depNode;
}
CBINDPROPAGATEALLDependencyNode* CCalculationTableauCompletionTaskHandleAlgorithm::createBINDPROPAGATEALLDependency(CDependencyTrackPoint*& allDepTrackPoint, CIndividualProcessNode*& processIndi, CConceptDescriptor* conDes, CDependencyTrackPoint* prevDepTrackPoint, CDependencyTrackPoint* linkDepTrackPoint, CCalculationAlgorithmContextBase* calcAlgContext) {
CBINDPROPAGATEALLDependencyNode* depNode = nullptr;
if (mConfBuildDependencies) {
depNode = calcAlgContext->getUsedDependencyFactory()->createBINDPROPAGATEALLDependency(allDepTrackPoint,processIndi,conDes,prevDepTrackPoint,linkDepTrackPoint,calcAlgContext);
}
return depNode;
}
CPROPAGATEBINDINGSSUCCESSORDependencyNode* CCalculationTableauCompletionTaskHandleAlgorithm::createPROPAGATEBINDINGSSUCCESSORDependency(CDependencyTrackPoint*& allDepTrackPoint, CIndividualProcessNode*& processIndi, CConceptDescriptor* conDes, CDependencyTrackPoint* prevDepTrackPoint, CDependencyTrackPoint* linkDepTrackPoint, CCalculationAlgorithmContextBase* calcAlgContext) {
CPROPAGATEBINDINGSSUCCESSORDependencyNode* depNode = nullptr;
if (mConfBuildDependencies) {
depNode = calcAlgContext->getUsedDependencyFactory()->createPROPAGATEBINDINGSSUCCESSORDependency(allDepTrackPoint,processIndi,conDes,prevDepTrackPoint,linkDepTrackPoint,calcAlgContext);
}
return depNode;
}
CBINDPROPAGATEIMPLICATIONDependencyNode* CCalculationTableauCompletionTaskHandleAlgorithm::createBINDPROPAGATEIMPLICATIONDependency(CDependencyTrackPoint*& implContinueDepTrackPoint, CIndividualProcessNode*& processIndi, CConceptDescriptor* conDes, CDependencyTrackPoint* prevDepTrackPoint, CDependency* prevOtherDependencies, CCalculationAlgorithmContextBase* calcAlgContext) {
CBINDPROPAGATEIMPLICATIONDependencyNode* depNode = nullptr;
if (mConfBuildDependencies) {
depNode = calcAlgContext->getUsedDependencyFactory()->createBINDPROPAGATEIMPLICATIONDependency(implContinueDepTrackPoint,processIndi,conDes,prevDepTrackPoint,prevOtherDependencies,calcAlgContext);
}
return depNode;
}
CANDDependencyNode* CCalculationTableauCompletionTaskHandleAlgorithm::createANDDependency(CDependencyTrackPoint*& andDepTrackPoint, CIndividualProcessNode*& processIndi, CConceptDescriptor* conDes, CDependencyTrackPoint* prevDepTrackPoint, CCalculationAlgorithmContextBase* calcAlgContext) {
CANDDependencyNode* depNode = nullptr;
if (mConfBuildDependencies) {
depNode = calcAlgContext->getUsedDependencyFactory()->createANDDependency(andDepTrackPoint,processIndi,conDes,prevDepTrackPoint,calcAlgContext);
}
return depNode;
}
CBINDPROPAGATEANDDependencyNode* CCalculationTableauCompletionTaskHandleAlgorithm::createBINDPROPAGATEANDDependency(CDependencyTrackPoint*& andDepTrackPoint, CIndividualProcessNode*& processIndi, CConceptDescriptor* conDes, CDependencyTrackPoint* prevDepTrackPoint, CCalculationAlgorithmContextBase* calcAlgContext) {
CBINDPROPAGATEANDDependencyNode* depNode = nullptr;
if (mConfBuildDependencies) {
depNode = calcAlgContext->getUsedDependencyFactory()->createBINDPROPAGATEANDDependency(andDepTrackPoint,processIndi,conDes,prevDepTrackPoint,calcAlgContext);
}
return depNode;
}
CPROPAGATEBINDINGDependencyNode* CCalculationTableauCompletionTaskHandleAlgorithm::createPROPAGATEBINDINGDependency(CDependencyTrackPoint*& andDepTrackPoint, CIndividualProcessNode*& processIndi, CConceptDescriptor* conDes, CDependencyTrackPoint* prevDepTrackPoint, CDependency* prevOtherDependencies, CCalculationAlgorithmContextBase* calcAlgContext) {
CPROPAGATEBINDINGDependencyNode* depNode = nullptr;
if (mConfBuildDependencies) {
depNode = calcAlgContext->getUsedDependencyFactory()->createPROPAGATEBINDINGDependency(andDepTrackPoint,processIndi,conDes,prevDepTrackPoint,prevOtherDependencies,calcAlgContext);
}
return depNode;
}
CBINDVARIABLEDependencyNode* CCalculationTableauCompletionTaskHandleAlgorithm::createBINDVARIABLEDependency(CDependencyTrackPoint*& andDepTrackPoint, CIndividualProcessNode*& processIndi, CConceptDescriptor* conDes, CDependencyTrackPoint* prevDepTrackPoint, CCalculationAlgorithmContextBase* calcAlgContext) {
CBINDVARIABLEDependencyNode* depNode = nullptr;
if (mConfBuildDependencies) {
depNode = calcAlgContext->getUsedDependencyFactory()->createBINDVARIABLEDependency(andDepTrackPoint,processIndi,conDes,prevDepTrackPoint,calcAlgContext);
}
return depNode;
}
CNOMINALDependencyNode* CCalculationTableauCompletionTaskHandleAlgorithm::createNOMINALDependency(CDependencyTrackPoint*& nominalContDepTrackPoint, CIndividualProcessNode*& processIndi, CConceptDescriptor* conDes, CDependencyTrackPoint* prevDepTrackPoint, CDependencyTrackPoint* nominalDepTrackPoint, CCalculationAlgorithmContextBase* calcAlgContext) {
CNOMINALDependencyNode* depNode = nullptr;
if (mConfBuildDependencies) {
depNode = calcAlgContext->getUsedDependencyFactory()->createNOMINALDependency(nominalContDepTrackPoint,processIndi,conDes,prevDepTrackPoint,nominalDepTrackPoint,calcAlgContext);
}
return depNode;
}
CAUTOMATCHOOSEDependencyNode* CCalculationTableauCompletionTaskHandleAlgorithm::createAUTOMATCHOOSEDependency(CDependencyTrackPoint*& andDepTrackPoint, CIndividualProcessNode*& processIndi, CConceptDescriptor* conDes, CDependencyTrackPoint* prevDepTrackPoint, CCalculationAlgorithmContextBase* calcAlgContext) {
CAUTOMATCHOOSEDependencyNode* depNode = nullptr;
if (mConfBuildDependencies) {
depNode = calcAlgContext->getUsedDependencyFactory()->createAUTOMATCHOOSEDependency(andDepTrackPoint,processIndi,conDes,prevDepTrackPoint,calcAlgContext);
}
return depNode;
}
CSOMEDependencyNode* CCalculationTableauCompletionTaskHandleAlgorithm::createSOMEDependency(CDependencyTrackPoint*& someDepTrackPoint, CIndividualProcessNode*& processIndi, CConceptDescriptor* conDes, CDependencyTrackPoint* prevDepTrackPoint, CCalculationAlgorithmContextBase* calcAlgContext) {
CSOMEDependencyNode* depNode = nullptr;
if (mConfBuildDependencies) {
depNode = calcAlgContext->getUsedDependencyFactory()->createSOMEDependency(someDepTrackPoint,processIndi,conDes,prevDepTrackPoint,calcAlgContext);
}
return depNode;
}
CSELFDependencyNode* CCalculationTableauCompletionTaskHandleAlgorithm::createSELFDependency(CDependencyTrackPoint*& someDepTrackPoint, CIndividualProcessNode*& processIndi, CConceptDescriptor* conDes, CDependencyTrackPoint* prevDepTrackPoint, CCalculationAlgorithmContextBase* calcAlgContext) {
CSELFDependencyNode* depNode = nullptr;
if (mConfBuildDependencies) {
depNode = calcAlgContext->getUsedDependencyFactory()->createSELFDependency(someDepTrackPoint,processIndi,conDes,prevDepTrackPoint,calcAlgContext);
}
return depNode;
}
CVALUEDependencyNode* CCalculationTableauCompletionTaskHandleAlgorithm::createVALUEDependency(CDependencyTrackPoint*& valueDepTrackPoint, CIndividualProcessNode*& processIndi, CConceptDescriptor* conDes, CDependencyTrackPoint* prevDepTrackPoint, CDependencyTrackPoint* nominalDepTrackPoint, CCalculationAlgorithmContextBase* calcAlgContext) {
CVALUEDependencyNode* depNode = nullptr;
if (mConfBuildDependencies) {
depNode = calcAlgContext->getUsedDependencyFactory()->createVALUEDependency(valueDepTrackPoint,processIndi,conDes,prevDepTrackPoint,nominalDepTrackPoint,calcAlgContext);
}
return depNode;
}
CROLEASSERTIONDependencyNode* CCalculationTableauCompletionTaskHandleAlgorithm::createROLEASSERTIONDependency(CDependencyTrackPoint*& valueDepTrackPoint, CIndividualProcessNode*& processIndi, CDependencyTrackPoint* prevDepTrackPoint, CDependencyTrackPoint* nominalDepTrackPoint, CRole* baseAssertionRole, CIndividual* baseAssertionIndi, CCalculationAlgorithmContextBase* calcAlgContext) {
CROLEASSERTIONDependencyNode* depNode = nullptr;
if (mConfBuildDependencies) {
depNode = calcAlgContext->getUsedDependencyFactory()->createROLEASSERTIONDependency(valueDepTrackPoint,processIndi,prevDepTrackPoint,nominalDepTrackPoint, baseAssertionRole, baseAssertionIndi ,calcAlgContext);
}
return depNode;
}
CDATAASSERTIONDependencyNode* CCalculationTableauCompletionTaskHandleAlgorithm::createDATAASSERTIONDependency(CDependencyTrackPoint*& valueDepTrackPoint, CIndividualProcessNode*& processIndi, CDependencyTrackPoint* prevDepTrackPoint, CCalculationAlgorithmContextBase* calcAlgContext) {
CDATAASSERTIONDependencyNode* depNode = nullptr;
if (mConfBuildDependencies) {
depNode = calcAlgContext->getUsedDependencyFactory()->createDATAASSERTIONDependency(valueDepTrackPoint, processIndi, prevDepTrackPoint, calcAlgContext);
}
return depNode;
}
CNEGVALUEDependencyNode* CCalculationTableauCompletionTaskHandleAlgorithm::createNEGVALUEDependency(CDependencyTrackPoint*& negValueDepTrackPoint, CIndividualProcessNode*& processIndi, CConceptDescriptor* conDes, CDependencyTrackPoint* prevDepTrackPoint, CDependencyTrackPoint* nominalDepTrackPoint, CCalculationAlgorithmContextBase* calcAlgContext) {
CNEGVALUEDependencyNode* depNode = nullptr;
if (mConfBuildDependencies) {
depNode = calcAlgContext->getUsedDependencyFactory()->createNEGVALUEDependency(negValueDepTrackPoint,processIndi,conDes,prevDepTrackPoint,nominalDepTrackPoint,calcAlgContext);
}
return depNode;
}
CALLDependencyNode* CCalculationTableauCompletionTaskHandleAlgorithm::createALLDependency(CDependencyTrackPoint*& allDepTrackPoint, CIndividualProcessNode*& processIndi, CConceptDescriptor* conDes, CDependencyTrackPoint* prevDepTrackPoint, CDependencyTrackPoint* linkDepTrackPoint, CCalculationAlgorithmContextBase* calcAlgContext) {
CALLDependencyNode* depNode = nullptr;
if (mConfBuildDependencies) {
depNode = calcAlgContext->getUsedDependencyFactory()->createALLDependency(allDepTrackPoint,processIndi,conDes,prevDepTrackPoint,linkDepTrackPoint,calcAlgContext);
}
return depNode;
}
CMERGEDCONCEPTDependencyNode* CCalculationTableauCompletionTaskHandleAlgorithm::createMERGEDCONCEPTDependency(CDependencyTrackPoint*& mergedConceptContinueDepTrackPoint, CIndividualProcessNode*& processIndi, CConceptDescriptor* conDes, CDependencyTrackPoint* mergePrevDepTrackPoint, CDependencyTrackPoint* conceptPrevDepTrackPoint, CCalculationAlgorithmContextBase* calcAlgContext) {
CMERGEDCONCEPTDependencyNode* depNode = nullptr;
if (mConfBuildDependencies) {
depNode = calcAlgContext->getUsedDependencyFactory()->createMERGEDCONCEPTDependency(mergedConceptContinueDepTrackPoint,processIndi,conDes,mergePrevDepTrackPoint,conceptPrevDepTrackPoint,calcAlgContext);
}
return depNode;
}
CMERGEDLINKDependencyNode* CCalculationTableauCompletionTaskHandleAlgorithm::createMERGEDLINKDependency(CDependencyTrackPoint*& mergedLinkContinueDepTrackPoint, CIndividualProcessNode*& processIndi, CDependencyTrackPoint* mergePrevDepTrackPoint, CDependencyTrackPoint* linkPrevDepTrackPoint, CCalculationAlgorithmContextBase* calcAlgContext) {
CMERGEDLINKDependencyNode* depNode = nullptr;
if (mConfBuildDependencies) {
depNode = calcAlgContext->getUsedDependencyFactory()->createMERGEDLINKDependency(mergedLinkContinueDepTrackPoint,processIndi,mergePrevDepTrackPoint,linkPrevDepTrackPoint,calcAlgContext);
}
return depNode;
}
CMERGEDIndividualDependencyNode* CCalculationTableauCompletionTaskHandleAlgorithm::createMERGEDINDIVIDUALDependency(CDependencyTrackPoint*& mergedIndividualContinueDepTrackPoint, CIndividualProcessNode*& processIndi, CDependencyTrackPoint* mergePrevDepTrackPoint, CDependencyTrackPoint* individualPrevDepTrackPoint, CCalculationAlgorithmContext* calcAlgContext) {
CMERGEDIndividualDependencyNode* depNode = nullptr;
if (mConfBuildDependencies) {
depNode = calcAlgContext->getUsedDependencyFactory()->createMERGEDINDIVIDUALDependency(mergedIndividualContinueDepTrackPoint,processIndi,mergePrevDepTrackPoint,individualPrevDepTrackPoint,calcAlgContext);
}
return depNode;
}
CFUNCTIONALDependencyNode* CCalculationTableauCompletionTaskHandleAlgorithm::createFUNCTIONALDependency(CDependencyTrackPoint*& functionalContinueDepTrackPoint, CIndividualProcessNode*& processIndi, CConceptDescriptor* conDes, CDependencyTrackPoint* prevDepTrackPoint, CDependencyTrackPoint* prevLink1DependencyTrackPoint, CDependencyTrackPoint* prevLink2DependencyTrackPoint, CCalculationAlgorithmContextBase* calcAlgContext) {
CFUNCTIONALDependencyNode* depNode = nullptr;
if (mConfBuildDependencies) {
depNode = calcAlgContext->getUsedDependencyFactory()->createFUNCTIONALDependency(functionalContinueDepTrackPoint,processIndi,conDes,prevDepTrackPoint,prevLink1DependencyTrackPoint,prevLink2DependencyTrackPoint,calcAlgContext);
}
return depNode;
}
CDISTINCTDependencyNode* CCalculationTableauCompletionTaskHandleAlgorithm::createDISTINCTDependency(CDependencyTrackPoint*& distinctDepTrackPoint, CIndividualProcessNode*& processIndi, CConceptDescriptor* conDes, CDependencyTrackPoint* prevDepTrackPoint, CCalculationAlgorithmContextBase* calcAlgContext) {
CDISTINCTDependencyNode* depNode = nullptr;
if (mConfBuildDependencies) {
depNode = calcAlgContext->getUsedDependencyFactory()->createDISTINCTDependency(distinctDepTrackPoint,processIndi,conDes,prevDepTrackPoint,calcAlgContext);
}
return depNode;
}
CAUTOMATTRANSACTIONDependencyNode* CCalculationTableauCompletionTaskHandleAlgorithm::createAUTOMATTRANSACTIONDependency(CDependencyTrackPoint*& allDepTrackPoint, CIndividualProcessNode*& processIndi, CConceptDescriptor* conDes, CDependencyTrackPoint* prevDepTrackPoint, CDependencyTrackPoint* linkDepTrackPoint, CCalculationAlgorithmContextBase* calcAlgContext) {
CAUTOMATTRANSACTIONDependencyNode* depNode = nullptr;
if (mConfBuildDependencies) {
depNode = calcAlgContext->getUsedDependencyFactory()->createAUTOMATTRANSACTIONDependency(allDepTrackPoint,processIndi,conDes,prevDepTrackPoint,linkDepTrackPoint,calcAlgContext);
}
return depNode;
}
CATLEASTDependencyNode* CCalculationTableauCompletionTaskHandleAlgorithm::createATLEASTDependency(CDependencyTrackPoint*& atleastDepTrackPoint, CIndividualProcessNode*& processIndi, CConceptDescriptor* conDes, CDependencyTrackPoint* prevDepTrackPoint, CCalculationAlgorithmContextBase* calcAlgContext) {
CATLEASTDependencyNode* depNode = nullptr;
if (mConfBuildDependencies) {
depNode = calcAlgContext->getUsedDependencyFactory()->createATLEASTDependency(atleastDepTrackPoint,processIndi,conDes,prevDepTrackPoint,calcAlgContext);
}
return depNode;
}
CORDependencyNode* CCalculationTableauCompletionTaskHandleAlgorithm::createORDependency(CIndividualProcessNode*& processIndi, CConceptDescriptor* conDes, CDependencyTrackPoint* prevDepTrackPoint, CCalculationAlgorithmContextBase* calcAlgContext) {
CORDependencyNode* depNode = nullptr;
if (mConfBuildDependencies) {
depNode = calcAlgContext->getUsedDependencyFactory()->createORDependency(processIndi,conDes,prevDepTrackPoint,calcAlgContext);
}
return depNode;
}
CATMOSTDependencyNode* CCalculationTableauCompletionTaskHandleAlgorithm::createATMOSTDependency(CIndividualProcessNode*& processIndi, CConceptDescriptor* conDes, CDependencyTrackPoint* prevDepTrackPoint, CCalculationAlgorithmContextBase* calcAlgContext) {
CATMOSTDependencyNode* depNode = nullptr;
if (mConfBuildDependencies) {
depNode = calcAlgContext->getUsedDependencyFactory()->createATMOSTDependency(processIndi,conDes,prevDepTrackPoint,calcAlgContext);
}
return depNode;
}
CMERGEDependencyNode* CCalculationTableauCompletionTaskHandleAlgorithm::createMERGEDependency(CIndividualProcessNode*& processIndi, CConceptDescriptor* conDes, CDependencyTrackPoint* prevDepTrackPoint, CCalculationAlgorithmContextBase* calcAlgContext) {
CMERGEDependencyNode* depNode = nullptr;
if (mConfBuildDependencies) {
depNode = calcAlgContext->getUsedDependencyFactory()->createMERGEDependency(processIndi,conDes,prevDepTrackPoint,calcAlgContext);
}
return depNode;
}
CREUSEINDIVIDUALDependencyNode* CCalculationTableauCompletionTaskHandleAlgorithm::createREUSEINDIVIDUALDependency(CIndividualProcessNode*& processIndi, CConceptDescriptor* conDes, CDependencyTrackPoint* prevDepTrackPoint, CCalculationAlgorithmContextBase* calcAlgContext) {
CREUSEINDIVIDUALDependencyNode* depNode = nullptr;
if (mConfBuildDependencies) {
depNode = calcAlgContext->getUsedDependencyFactory()->createREUSEINDIVIDUALDependency(processIndi,conDes,prevDepTrackPoint,calcAlgContext);
}
return depNode;
}
CREUSECOMPLETIONGRAPHDependencyNode* CCalculationTableauCompletionTaskHandleAlgorithm::createREUSECOMPLETIONGRAPHDependency(CIndividualProcessNode*& processIndi, CConceptDescriptor* conDes, CDependencyTrackPoint* prevDepTrackPoint, CCalculationAlgorithmContextBase* calcAlgContext) {
CREUSECOMPLETIONGRAPHDependencyNode* depNode = nullptr;
if (mConfBuildDependencies) {
depNode = calcAlgContext->getUsedDependencyFactory()->createREUSECOMPLETIONGRAPHDependency(processIndi,conDes,prevDepTrackPoint,calcAlgContext);
}
return depNode;
}
CMERGEPOSSIBLEINSTANCEINDIVIDUALDependencyNode* CCalculationTableauCompletionTaskHandleAlgorithm::createMERGEPOSSIBLEINSTANCEINDIVIDUALDependencyNode(CIndividualProcessNode*& processIndi, CDependencyTrackPoint* prevDepTrackPoint, CIndividualProcessNode* mergingIndi, CCalculationAlgorithmContextBase* calcAlgContext) {
CMERGEPOSSIBLEINSTANCEINDIVIDUALDependencyNode* depNode = nullptr;
if (mConfBuildDependencies) {
depNode = calcAlgContext->getUsedDependencyFactory()->createMERGEPOSSIBLEINSTANCEINDIVIDUALDependencyNode(processIndi, prevDepTrackPoint, mergingIndi, calcAlgContext);
}
return depNode;
}
CREUSECONCEPTSDependencyNode* CCalculationTableauCompletionTaskHandleAlgorithm::createREUSECONCEPTSDependency(CIndividualProcessNode*& processIndi, CConceptDescriptor* conDes, CDependencyTrackPoint* prevDepTrackPoint, CCalculationAlgorithmContextBase* calcAlgContext) {
CREUSECONCEPTSDependencyNode* depNode = nullptr;
if (mConfBuildDependencies) {
depNode = calcAlgContext->getUsedDependencyFactory()->createREUSECONCEPTSDependency(processIndi,conDes,prevDepTrackPoint,calcAlgContext);
}
return depNode;
}
CQUALIFYDependencyNode* CCalculationTableauCompletionTaskHandleAlgorithm::createQUALIFYDependency(CIndividualProcessNode*& processIndi, CConceptDescriptor* conDes, CDependencyTrackPoint* prevDepTrackPoint, CCalculationAlgorithmContextBase* calcAlgContext) {
CQUALIFYDependencyNode* depNode = nullptr;
if (mConfBuildDependencies) {
depNode = calcAlgContext->getUsedDependencyFactory()->createQUALIFYDependency(processIndi,conDes,prevDepTrackPoint,calcAlgContext);
}
return depNode;
}
CORONLYOPTIONDependencyNode* CCalculationTableauCompletionTaskHandleAlgorithm::createORONLYOPTIONDependency(CDependencyTrackPoint*& orContinueDepTrackPoint, CIndividualProcessNode*& processIndi, CConceptDescriptor* conDes, CDependencyTrackPoint* prevDepTrackPoint, CDependency* prevOtherDependencies, CCalculationAlgorithmContextBase* calcAlgContext) {
CORONLYOPTIONDependencyNode* depNode = nullptr;
if (mConfBuildDependencies) {
depNode = calcAlgContext->getUsedDependencyFactory()->createORONLYOPTIONDependency(orContinueDepTrackPoint, processIndi, conDes, prevDepTrackPoint, prevOtherDependencies, calcAlgContext);
}
return depNode;
}
CIMPLICATIONDependencyNode* CCalculationTableauCompletionTaskHandleAlgorithm::createIMPLICATIONDependency(CDependencyTrackPoint*& implContinueDepTrackPoint, CIndividualProcessNode*& processIndi, CConceptDescriptor* conDes, CDependencyTrackPoint* prevDepTrackPoint, CDependency* prevOtherDependencies, CCalculationAlgorithmContextBase* calcAlgContext) {
CIMPLICATIONDependencyNode* depNode = nullptr;
if (mConfBuildDependencies) {
depNode = calcAlgContext->getUsedDependencyFactory()->createIMPLICATIONDependency(implContinueDepTrackPoint,processIndi,conDes,prevDepTrackPoint,prevOtherDependencies,calcAlgContext);
}
return depNode;
}
CEXPANDEDDependencyNode* CCalculationTableauCompletionTaskHandleAlgorithm::createEXPANDEDDependency(CDependencyTrackPoint*& expContinueDepTrackPoint, CIndividualProcessNode*& processIndi, CDependencyTrackPoint* prevDepTrackPoint, CDependency* prevOtherDependencies, CCalculationAlgorithmContextBase* calcAlgContext) {
CEXPANDEDDependencyNode* depNode = nullptr;
if (mConfBuildDependencies) {
depNode = calcAlgContext->getUsedDependencyFactory()->createEXPANDEDDependency(expContinueDepTrackPoint,processIndi,prevDepTrackPoint,prevOtherDependencies,calcAlgContext);
}
return depNode;
}
CCONNECTIONDependencyNode* CCalculationTableauCompletionTaskHandleAlgorithm::createCONNECTIONDependency(CIndividualProcessNode*& processIndi, CConceptDescriptor* conDes, CDependencyTrackPoint* prevDepTrackPoint, CCalculationAlgorithmContextBase* calcAlgContext) {
CCONNECTIONDependencyNode* depNode = nullptr;
if (mConfBuildDependencies) {
depNode = calcAlgContext->getUsedDependencyFactory()->createCONNECTIONDependency(processIndi,conDes,prevDepTrackPoint,calcAlgContext);
}
return depNode;
}
CSAMEINDIVIDUALSMERGEDependencyNode* CCalculationTableauCompletionTaskHandleAlgorithm::createSAMEINDIVIDUALMERGEDependency(CDependencyTrackPoint*& expContinueDepTrackPoint, CIndividualProcessNode*& processIndi, CDependencyTrackPoint* prevDepTrackPoint, CDependencyTrackPoint* prevOtherDepTrackPoint, CCalculationAlgorithmContextBase* calcAlgContext) {
CSAMEINDIVIDUALSMERGEDependencyNode* depNode = nullptr;
if (mConfBuildDependencies) {
depNode = calcAlgContext->getUsedDependencyFactory()->createSAMEINDIVIDUALMERGEDependency(expContinueDepTrackPoint, processIndi, prevDepTrackPoint, prevOtherDepTrackPoint, calcAlgContext);
}
return depNode;
}
CREUSEBACKENDEXPANSIONMODESDependencyNode* CCalculationTableauCompletionTaskHandleAlgorithm::createREUSEBACKENDEXPANSIONMODESDependency(CDependencyTrackPoint* prevDepTrackPoint, CCalculationAlgorithmContextBase* calcAlgContext) {
CREUSEBACKENDEXPANSIONMODESDependencyNode* depNode = nullptr;
if (mConfBuildDependencies) {
depNode = calcAlgContext->getUsedDependencyFactory()->createREUSEBACKENDEXPANSIONMODESDependency(prevDepTrackPoint, calcAlgContext);
}
return depNode;
}
CREUSEBACKENDFIXEDINDIVIDUALEXPANSIONDependencyNode* CCalculationTableauCompletionTaskHandleAlgorithm::createREUSEBACKENDFIXEDINDIVIDUALEXPANSIONDependency(CIndividualProcessNode*& processIndi, CDependencyTrackPoint* prevDepTrackPoint, CCalculationAlgorithmContextBase* calcAlgContext) {
CREUSEBACKENDFIXEDINDIVIDUALEXPANSIONDependencyNode* depNode = nullptr;
if (mConfBuildDependencies) {
depNode = calcAlgContext->getUsedDependencyFactory()->createREUSEBACKENDFIXEDINDIVIDUALEXPANSIONDependency(processIndi, prevDepTrackPoint, calcAlgContext);
}
return depNode;
}
CREUSEBACKENDPRIORITIZEDINDIVIDUALEXPANSIONDependencyNode* CCalculationTableauCompletionTaskHandleAlgorithm::createREUSEBACKENDPRIORITIZEDINDIVIDUALEXPANSIONDependency(CIndividualProcessNode*& processIndi, CDependencyTrackPoint* prevDepTrackPoint, CCalculationAlgorithmContextBase* calcAlgContext) {
CREUSEBACKENDPRIORITIZEDINDIVIDUALEXPANSIONDependencyNode* depNode = nullptr;
if (mConfBuildDependencies) {
depNode = calcAlgContext->getUsedDependencyFactory()->createREUSEBACKENDPRIORITIZEDINDIVIDUALEXPANSIONDependency(processIndi, prevDepTrackPoint, calcAlgContext);
}
return depNode;
}
CREUSEBACKENDVALUEDependencyNode* CCalculationTableauCompletionTaskHandleAlgorithm::createREUSEBACKENDVALUEDependency(CDependencyTrackPoint*& valueDepTrackPoint, CIndividualProcessNode*& processIndi, CConceptDescriptor* conDes, CDependencyTrackPoint* prevDepTrackPoint, CDependencyTrackPoint* nominalDepTrackPoint, CCalculationAlgorithmContextBase* calcAlgContext) {
CREUSEBACKENDVALUEDependencyNode* depNode = nullptr;
if (mConfBuildDependencies) {
depNode = calcAlgContext->getUsedDependencyFactory()->createREUSEBACKENDVALUEDependency(valueDepTrackPoint, processIndi, conDes, prevDepTrackPoint, nominalDepTrackPoint, calcAlgContext);
}
return depNode;
}
void CCalculationTableauCompletionTaskHandleAlgorithm::applyREPRESENTATIVEGROUNDINGRule(CIndividualProcessNode*& processIndi, CConceptProcessDescriptor*& conProDes, bool negate, CCalculationAlgorithmContextBase* calcAlgContext) {
CMemoryAllocationManager* taskMemMan = calcAlgContext->getUsedProcessTaskMemoryAllocationManager();
CConceptDescriptor* conDes = conProDes->getConceptDescriptor();
CDependencyTrackPoint* depTrackPoint = conProDes->getDependencyTrackPoint();
CConcept* concept = conDes->getConcept();
bool negated = conDes->isNegated();
cint64 opCount = concept->getOperandCount();
CReapplyConceptLabelSet* conSet = processIndi->getReapplyConceptLabelSet(false);
CConceptRepresentativePropagationSetHash* repPropSetHash = processIndi->getConceptRepresentativePropagationSetHash(false);
CRepresentativePropagationSet* repPropSet = repPropSetHash->getRepresentativePropagationSet(concept,false);
STATINC(VARBINDRULEGROUNDINGAPPLICATIONCOUNT,calcAlgContext);
if (repPropSet) {
CRepresentativePropagationDescriptor* outRepPropDes = repPropSet->getOutgoingRepresentativePropagationDescriptorLinker();
if (outRepPropDes) {
CRepresentativeVariableBindingPathSetData* repVarBindPathSetData = outRepPropDes->getRepresentativeVariableBindingPathSetData();
if (repVarBindPathSetData) {
CRepresentativeVariableBindingPathSetMigrateData* repVarBindPathSetMigData = repVarBindPathSetData->getMigrateData(false);
if (repVarBindPathSetMigData) {
CRepresentativeVariableBindingPathMap* repVarBindPathSetMap = repVarBindPathSetMigData->getRepresentativeVariableBindingPathMap();
KONCLUCE_TASK_ALGORITHM_MODEL_STRING_INSTRUCTION(mBeforeGroundingDebugIndiModelString = generateExtendedDebugIndiModelStringList(calcAlgContext));
CPROCESSINGHASH* groundedConVarBindPathHash = nullptr;
CSortedNegLinker* newGroundedLinker = mGroundingHandler->getGroundingConceptLinker(processIndi,repVarBindPathSetMap,concept,negated,groundedConVarBindPathHash,calcAlgContext);
if (newGroundedLinker) {
for (CSortedNegLinker* newGroundedLinkerIt = newGroundedLinker; newGroundedLinkerIt; newGroundedLinkerIt = newGroundedLinkerIt->getNext()) {
STATINC(VARBINDGROUNDINGCOUNT,calcAlgContext);
++mStatRepresentativeGroundingCount;
CConcept* newGroundedCocnept = newGroundedLinkerIt->getData();
bool newGroundedConceptNegation = newGroundedLinkerIt->isNegated();
CVariableBindingPath* selectedVarBindPath = groundedConVarBindPathHash->value(newGroundedCocnept);
CDependencyTrackPoint* nextDepTrackPoint = nullptr;
CREPRESENTATIVEGROUNDINGDependencyNode* groundingDepNode = createREPRESENTATIVEGROUNDINGDependency(nextDepTrackPoint,processIndi,conDes,outRepPropDes->getDependencyTrackPoint(),selectedVarBindPath,calcAlgContext);
addConceptToIndividual(newGroundedCocnept,newGroundedConceptNegation,processIndi,nextDepTrackPoint,true,false,calcAlgContext);
}
}
KONCLUCE_TASK_ALGORITHM_MODEL_STRING_INSTRUCTION(mAfterGroundingDebugIndiModelString = generateExtendedDebugIndiModelStringList(calcAlgContext));
}
}
}
}
}
void CCalculationTableauCompletionTaskHandleAlgorithm::applyREPRESENTATIVEJOINRule(CIndividualProcessNode*& processIndi, CConceptProcessDescriptor*& conProDes, bool negate, CCalculationAlgorithmContextBase* calcAlgContext) {
CConceptDescriptor* conDes = conProDes->getConceptDescriptor();
CConcept* concept = conDes->getConcept();
CDependencyTrackPoint* depTrackPoint = conProDes->getDependencyTrackPoint();
cint64 opCount = concept->getOperandCount();
CSortedNegLinker* opLinker = concept->getOperandList();
CMemoryAllocationManager* taskMemMan = calcAlgContext->getUsedProcessTaskMemoryAllocationManager();
CProcessingDataBox* procDataBox = calcAlgContext->getUsedProcessingDataBox();
CReapplyConceptLabelSet* conSet = processIndi->getReapplyConceptLabelSet(false);
CConceptDescriptor* joinConDes = nullptr;
CDependencyTrackPoint* joinDepTrackPoint = nullptr;
CCondensedReapplyQueue* reapplyQueue = nullptr;
CConcept* joinConcept = opLinker->getData();
bool joinConceptNegation = opLinker->isNegated();
CSortedNegLinker* triggerLinker = opLinker->getNext();
CSortedLinker* varLinker = concept->getVariableLinker();
STATINC(VARBINDRULEJOINAPPLICATIONCOUNT,calcAlgContext);
bool propagateJoins = false;
bool createJoinConcept = false;
if (!conSet->getConceptDescriptorAndReapplyQueue(joinConcept,joinConDes,joinDepTrackPoint,reapplyQueue)) {
// search next not existing trigger
bool allTriggersAvailable = true;
conSet = processIndi->getReapplyConceptLabelSet(true);
CSortedNegLinker* triggerLinkerIt = nullptr;
for (triggerLinkerIt = triggerLinker; triggerLinkerIt && allTriggersAvailable; triggerLinkerIt = triggerLinkerIt->getNext()) {
CSortedNegLinker* nextTrigger = triggerLinkerIt;
CConcept* triggerConcept = nextTrigger->getData();
CConceptDescriptor* triggerConDes = nullptr;
CDependencyTrackPoint* triggerDepTrackPoint = nullptr;
if (conSet->getConceptDescriptor(triggerConcept,triggerConDes,triggerDepTrackPoint)) {
if (triggerConDes->isNegated() == nextTrigger->isNegated()) {
return;
}
} else {
allTriggersAvailable = false;
break;
}
}
if (!allTriggersAvailable) {
// install to trigger
CSortedNegLinker* nextTrigger = triggerLinkerIt;
CConcept* triggerConcept = nextTrigger->getData();
bool triggerNegation = !nextTrigger->isNegated();
if (!isConceptInReapplyQueue(conDes,triggerConcept,triggerNegation,processIndi,calcAlgContext)) {
addConceptToReapplyQueue(conDes,triggerConcept,triggerNegation,processIndi,(CProcessingRestrictionSpecification*)nullptr,depTrackPoint,calcAlgContext);
}
} else {
propagateJoins = true;
createJoinConcept = true;
}
} else {
propagateJoins = true;
}
//mEndTaskDebugIndiModelString = generateExtendedDebugIndiModelStringList(calcAlgContext);
bool propagationsDone = false;
if (propagateJoins) {
for (CSortedNegLinker* triggerLinkerIt = triggerLinker; triggerLinkerIt; triggerLinkerIt = triggerLinkerIt->getNext()) {
CSortedNegLinker* nextTrigger = triggerLinkerIt;
CConcept* triggerConcept = nextTrigger->getData();
if (!isConceptInReapplyQueue(conDes,triggerConcept,false,processIndi,calcAlgContext)) {
addConceptToReapplyQueue(conDes,triggerConcept,false,processIndi,(CProcessingRestrictionSpecification*)nullptr,depTrackPoint,calcAlgContext);
}
}
CConceptPropagationBindingSetHash* conPropBindingSetHash = processIndi->getConceptPropagationBindingSetHash(false);
CConceptRepresentativePropagationSetHash* repPropSetHash = processIndi->getConceptRepresentativePropagationSetHash(false);
CPropagationBindingSet* propBindingSet = nullptr;
if (conPropBindingSetHash && repPropSetHash) {
propBindingSet = conPropBindingSetHash->getPropagationBindingSet(concept,false);
if (propBindingSet) {
CPropagationRepresentativeTransitionExtension* propRepTransExt = propBindingSet->getPropagationRepresentativeTransitionExtension(false);
CSortedNegLinker* leftTriggerLinker = triggerLinker;
CSortedNegLinker* rightTriggerLinker = triggerLinker->getNext();
CConcept* leftConcept = leftTriggerLinker->getData();
CConcept* rightConcept = rightTriggerLinker->getData();
CRepresentativePropagationSet* leftRepPropSet = repPropSetHash->getRepresentativePropagationSet(leftConcept,false);
CRepresentativePropagationSet* rightRepPropSet = repPropSetHash->getRepresentativePropagationSet(rightConcept,false);
bool examineTransExt = false;
CRepresentativePropagationDescriptor* leftRepPropDes = leftRepPropSet->getOutgoingRepresentativePropagationDescriptorLinker();
CRepresentativePropagationDescriptor* rightRepPropDes = rightRepPropSet->getOutgoingRepresentativePropagationDescriptorLinker();
if (leftRepPropSet && rightRepPropSet && leftRepPropDes && rightRepPropDes) {
if (!propRepTransExt) {
examineTransExt = true;
} else {
if (propRepTransExt->getLastAnalysedPropagateAllFlag() != propBindingSet->getPropagateAllFlag() ||
propRepTransExt->getLastAnalysedPropagationBindingDescriptor() != propBindingSet->getPropagationBindingDescriptorLinker() ||
propRepTransExt->getLeftLastRepresentativeJoiningDescriptor() != leftRepPropDes ||
propRepTransExt->getRightLastRepresentativeJoiningDescriptor() != rightRepPropDes) {
examineTransExt = true;
}
}
}
if (examineTransExt) {
++mStatRepresentativeJoinCount;
conPropBindingSetHash = processIndi->getConceptPropagationBindingSetHash(true);
repPropSetHash = processIndi->getConceptRepresentativePropagationSetHash(true);
propBindingSet = conPropBindingSetHash->getPropagationBindingSet(concept,true);
propRepTransExt = propBindingSet->getPropagationRepresentativeTransitionExtension(true);
CRepresentativePropagationSet* joinRepPropSet = repPropSetHash->getRepresentativePropagationSet(joinConcept,true);
CPropagationBindingDescriptor* lastAnalyPropBindDes = propRepTransExt->getLastAnalysedPropagationBindingDescriptor();
CPropagationBindingDescriptor* propBindDes = propBindingSet->getPropagationBindingDescriptorLinker();
bool propAllFlag = propBindingSet->hasPropagateAllFlag();
CRepresentativeVariableBindingPathSetData* leftRepData = leftRepPropDes->getRepresentativeVariableBindingPathSetData();
CRepresentativeVariableBindingPathSetData* rightRepData = rightRepPropDes->getRepresentativeVariableBindingPathSetData();
if (areRepresentativesJoinable(processIndi,leftRepData,rightRepData,varLinker,calcAlgContext)) {
CRepresentativeJoiningData* joinData = nullptr;
CRepresentativeJoiningData* locJoinData = nullptr;
CRepresentativeJoiningHash* repJoiningHash = procDataBox->getRepresentativeJoiningHash(false);
if (repJoiningHash) {
joinData = repJoiningHash->getRepresentativeJoiningData(leftRepData,rightRepData,false);
}
if (!joinData) {
CRepresentativeVariableBindingPathSetHash* repVarBindPathSetHash = nullptr;
if (!leftRepData->hasJoiningData(concept)) {
if (!repVarBindPathSetHash) {
repVarBindPathSetHash = procDataBox->getRepresentativeVariableBindingPathSetHash(true);
}
leftRepData = repVarBindPathSetHash->getRepresentativeVariableBindingPathSetData(leftRepData,true);
}
if (!rightRepData->hasJoiningData(concept)) {
if (!repVarBindPathSetHash) {
repVarBindPathSetHash = procDataBox->getRepresentativeVariableBindingPathSetHash(true);
}
rightRepData = repVarBindPathSetHash->getRepresentativeVariableBindingPathSetData(rightRepData,true);
}
if (!locJoinData) {
repJoiningHash = procDataBox->getRepresentativeJoiningHash(true);
locJoinData = repJoiningHash->getRepresentativeJoiningData(leftRepData,rightRepData,true);
joinData = locJoinData;
}
CRepresentativeVariableBindingPathSetJoiningKeyMap* leftJoiningKeyMap = getRepresentativeJoiningKeyData(leftRepData,concept,calcAlgContext);
CRepresentativeVariableBindingPathSetJoiningKeyMap* rightJoiningKeyMap = getRepresentativeJoiningKeyData(rightRepData,concept,calcAlgContext);
CRepresentativeJoiningCommonKeyMap* repJoinCommonKeyMap = joinData->getRepresentativeJoiningCommonKeyMap();
createCommonJoiningKeyMap(repJoinCommonKeyMap,leftJoiningKeyMap,leftRepData,rightJoiningKeyMap,rightRepData,true,calcAlgContext);
}
CRepresentativeJoiningCommonKeyMap* repJoinCommonKeyMap = joinData->getRepresentativeJoiningCommonKeyMap();
if (!repJoinCommonKeyMap->isEmpty()) {
++mStatRepresentativeJoinedCount;
if (propAllFlag) {
CRepresentativeJoiningAllDataExtension* joinAllExtData = joinData->getJoiningAllExtension(false);
if (!joinAllExtData) {
if (!locJoinData) {
repJoiningHash = procDataBox->getRepresentativeJoiningHash(true);
locJoinData = repJoiningHash->getRepresentativeJoiningData(leftRepData,rightRepData,true);
joinData = locJoinData;
}
joinAllExtData = joinData->getJoiningAllExtension(true);
createCommonJoiningAll(joinData->getRepresentativeJoiningCommonKeyMap(),joinAllExtData,leftRepData,rightRepData,calcAlgContext);
}
CRepresentativeVariableBindingPathSetData* joinedRepData = joinAllExtData->getRepresentativeVariableBindingPathSetData();
CRepresentativePropagationMap* leftRepPropMap = propRepTransExt->getLeftRepresentativePropagationMap();
CRepresentativePropagationMap* rightRepPropMap = propRepTransExt->getRightRepresentativePropagationMap();
if (!leftRepPropMap->contains(leftRepData->getRepresentativeID())) {
CDependencyTrackPoint* nextDepTrackPoint = nullptr;
CREPRESENTATIVEANDDependencyNode* repPropDepNode = createREPRESENTATIVEANDDependency(nextDepTrackPoint,processIndi,conDes,leftRepPropDes->getDependencyTrackPoint(),calcAlgContext);
CRepresentativePropagationDescriptor* propagateRepDes = CObjectAllocator::allocateAndConstruct(taskMemMan);
propagateRepDes->initRepresentativeDescriptor(leftRepData,nextDepTrackPoint);
leftRepPropMap->insert(leftRepData->getRepresentativeID(),CRepresentativePropagationMapData(propagateRepDes));
}
if (!rightRepPropMap->contains(rightRepData->getRepresentativeID())) {
CDependencyTrackPoint* nextDepTrackPoint = nullptr;
CREPRESENTATIVEANDDependencyNode* repPropDepNode = createREPRESENTATIVEANDDependency(nextDepTrackPoint,processIndi,conDes,rightRepPropDes->getDependencyTrackPoint(),calcAlgContext);
CRepresentativePropagationDescriptor* propagateRepDes = CObjectAllocator::allocateAndConstruct(taskMemMan);
propagateRepDes->initRepresentativeDescriptor(rightRepData,nextDepTrackPoint);
rightRepPropMap->insert(rightRepData->getRepresentativeID(),CRepresentativePropagationMapData(propagateRepDes));
}
CDependencyTrackPoint* leftNextResolveDepTrackPoint = nullptr;
CRESOLVEREPRESENTATIVEDependencyNode* leftResolveRepNode = createRESOLVEREPRESENTATIVEDependency(leftNextResolveDepTrackPoint,processIndi,nullptr,joinAllExtData->getLeftResolveVariableBindingPathMap(false),leftRepPropMap,leftRepPropDes->getDependencyTrackPoint(),nullptr,calcAlgContext);
CDependencyTrackPoint* rightNextResolveDepTrackPoint = nullptr;
CRESOLVEREPRESENTATIVEDependencyNode* rightResolveRepNode = createRESOLVEREPRESENTATIVEDependency(rightNextResolveDepTrackPoint,processIndi,nullptr,joinAllExtData->getRightResolveVariableBindingPathMap(false),rightRepPropMap,rightRepPropDes->getDependencyTrackPoint(),nullptr,calcAlgContext);
CDependencyTrackPoint* joinNextDepTrackPoint = nullptr;
CREPRESENTATIVEJOINDependencyNode* joinResolveRepNode = createREPRESENTATIVEJOINDependency(joinNextDepTrackPoint,processIndi,conDes,leftNextResolveDepTrackPoint,rightNextResolveDepTrackPoint,calcAlgContext);
CRepresentativePropagationDescriptor* propagateRepDes = CObjectAllocator::allocateAndConstruct(taskMemMan);
propagateRepDes->initRepresentativeDescriptor(joinedRepData,joinNextDepTrackPoint);
joinRepPropSet->addIncomingRepresentativePropagation(propagateRepDes);
updateRepresentativePropagationSet(processIndi,joinRepPropSet,calcAlgContext);
if (!joinConDes) {
joinDepTrackPoint = joinNextDepTrackPoint;
joinConDes = addConceptToIndividualReturnConceptDescriptor(joinConcept,false,processIndi,joinNextDepTrackPoint,false,false,calcAlgContext);
}
} else {
// ToDo!
}
propagationsDone = true;
}
}
propRepTransExt->setLeftLastRepresentativeJoiningDescriptor(leftRepPropDes);
propRepTransExt->setRightLastRepresentativeJoiningDescriptor(rightRepPropDes);
propRepTransExt->setLastAnalysedPropagationBindingDescriptor(propBindDes);
propRepTransExt->setLastAnalysedPropagateAllFlag(propBindingSet->hasPropagateAllFlag());
}
}
}
}
if (propagationsDone) {
if (!createJoinConcept) {
reapplyConceptUpdatedRepresentative(processIndi,joinConDes,joinDepTrackPoint,conSet,reapplyQueue,calcAlgContext);
}
}
}
bool CCalculationTableauCompletionTaskHandleAlgorithm::hasCommonVariableBindings(CIndividualProcessNode*& processIndi, CRepresentativeVariableBindingPathMap* leftRepVarBindMap, CRepresentativeVariableBindingPathMap* rightRepVarBindMap, CCalculationAlgorithmContextBase* calcAlgContext) {
if (rightRepVarBindMap->count() < leftRepVarBindMap->count()) {
return hasCommonVariableBindings(processIndi,rightRepVarBindMap,leftRepVarBindMap,calcAlgContext);
}
if (leftRepVarBindMap->count()*mMapComparisonDirectLookupFactor < rightRepVarBindMap->count()) {
for (CRepresentativeVariableBindingPathMap::const_iterator it1 = leftRepVarBindMap->constBegin(), it1End = leftRepVarBindMap->constEnd(); it1 != it1End; ++it1) {
if (rightRepVarBindMap->contains(it1.key())) {
return true;
}
}
return false;
} else {
CRepresentativeVariableBindingPathMap::const_iterator it1 = leftRepVarBindMap->constBegin(), it1End = leftRepVarBindMap->constEnd();
CRepresentativeVariableBindingPathMap::const_iterator it2 = rightRepVarBindMap->constBegin(), it2End = rightRepVarBindMap->constEnd();
while (it1 != it1End && it2 != it2End) {
cint64 key1 = it1.key();
cint64 key2 = it2.key();
if (key1 == key2) {
return true;
}
if (key1 < key2) {
++it1;
} else if (key2 < key1) {
++it2;
}
}
return false;
}
}
bool CCalculationTableauCompletionTaskHandleAlgorithm::areRepresentativesJoinable(CIndividualProcessNode*& processIndi, CRepresentativeVariableBindingPathSetData* leftRepData, CRepresentativeVariableBindingPathSetData* rightRepData, CSortedLinker* varLinker, CCalculationAlgorithmContextBase* calcAlgContext) {
CRepresentativeVariableBindingPathSetMigrateData* leftRepMigData = leftRepData->getMigrateData();
CRepresentativeVariableBindingPathSetMigrateData* rightRepMigData = rightRepData->getMigrateData();
if (varLinker && leftRepMigData && rightRepMigData) {
CRepresentativeVariableBindingPathMap* leftRepVarBindMap = leftRepMigData->getRepresentativeVariableBindingPathMap();
CRepresentativeVariableBindingPathMap* rightRepVarBindMap = rightRepMigData->getRepresentativeVariableBindingPathMap();
const CRepresentativeVariableBindingPathMapData& leftRepVarBindData = leftRepVarBindMap->constBegin().value();
const CRepresentativeVariableBindingPathMapData& rightRepVarBindData = rightRepVarBindMap->constBegin().value();
CVariableBindingPath* leftVarBindPath = leftRepVarBindData.getVariableBindingPath();
CVariableBindingPath* rightVarBindPath = rightRepVarBindData.getVariableBindingPath();
if (leftVarBindPath->getVariableBindingCount() == 1 && rightVarBindPath->getVariableBindingCount() == 1) {
if (!hasCommonVariableBindings(processIndi,leftRepVarBindMap,rightRepVarBindMap,calcAlgContext)) {
++mStatRepresentativeJoinQuickFailCount;
return false;
}
}
}
return true;
}
void CCalculationTableauCompletionTaskHandleAlgorithm::createCommonJoiningAll(CRepresentativeJoiningCommonKeyMap* repJoinCommonKeyMap, CRepresentativeJoiningAllDataExtension* joinAllExtData, CRepresentativeVariableBindingPathSetData* leftRepData, CRepresentativeVariableBindingPathSetData* rightRepData, CCalculationAlgorithmContextBase* calcAlgContext) {
CMemoryAllocationManager* taskMemMan = calcAlgContext->getUsedProcessTaskMemoryAllocationManager();
CProcessingDataBox* procDataBox = calcAlgContext->getUsedProcessingDataBox();
CProcessContext* processContext = calcAlgContext->getUsedProcessContext();
CRepresentativeVariableBindingPathSetData* repData = CObjectParameterizingAllocator< CRepresentativeVariableBindingPathSetData,CProcessContext* >::allocateAndConstructAndParameterize(taskMemMan,processContext);
repData->initRepresentativeVariableBindingPathData(nullptr);
repData->setRepresentativeID(procDataBox->getNextRepresentativeVariableBindingPathID(true));
repData->setMigratable(false);
repData->incUseCount();
repData->incShareCount();
CRepresentativeVariableBindingPathSetMigrateData* repMigData = repData->getMigrateData(true);
CRepresentativeVariableBindingPathMap* varBindPathResolveMap = repMigData->getRepresentativeVariableBindingPathMap();
CRepresentativeVariableBindingPathMap* leftRepVarBindPathResolveMap = joinAllExtData->getLeftResolveVariableBindingPathMap(true);
CRepresentativeVariableBindingPathMap* rightRepVarBindPathResolveMap = joinAllExtData->getRightResolveVariableBindingPathMap(true);
for (CRepresentativeJoiningCommonKeyMap::const_iterator it = repJoinCommonKeyMap->constBegin(), itEnd = repJoinCommonKeyMap->constEnd(); it != itEnd; ++it) {
cint64 joiningKey = it.key();
const CRepresentativeJoiningCommonKeyData& commonKeyData = it.value();
CRepresentativeVariableBindingPathSetJoiningKeyDataMap* leftKeyDataMap = commonKeyData.getLeftJoiningDataMap();
CRepresentativeVariableBindingPathSetJoiningKeyDataMap* rightKeyDataMap = commonKeyData.getRightJoiningDataMap();
for (CRepresentativeVariableBindingPathSetJoiningKeyDataMap::const_iterator it1 = leftKeyDataMap->constBegin(), it1End = leftKeyDataMap->constEnd(); it1 != it1End; ++it1) {
for (CRepresentativeVariableBindingPathSetJoiningKeyDataMap::const_iterator it2 = rightKeyDataMap->constBegin(), it2End = rightKeyDataMap->constEnd(); it2 != it2End; ++it2) {
CVariableBindingPath* varBindPath1 = it1.value();
CVariableBindingPath* varBindPath2 = it2.value();
CVariableBindingPath* mergedVarBindPath = getJoinedVariableBindingPath(varBindPath1,varBindPath2,calcAlgContext);
leftRepVarBindPathResolveMap->insert(mergedVarBindPath->getPropagationID(),CRepresentativeVariableBindingPathMapData(mergedVarBindPath,varBindPath1,leftRepData));
rightRepVarBindPathResolveMap->insert(mergedVarBindPath->getPropagationID(),CRepresentativeVariableBindingPathMapData(mergedVarBindPath,varBindPath2,rightRepData));
varBindPathResolveMap->insert(mergedVarBindPath->getPropagationID(),CRepresentativeVariableBindingPathMapData(mergedVarBindPath,repData));
}
}
}
++mStatRepresentativeJoinCombinesCount;
repMigData->getRepresentativeContainingMap()->insertContainedRepresentative(repData,false);
repData->addKeySignatureValue(repData->getRepresentativeID());
CRepresentativeVariableBindingPathSetHash* repVarBindPathSetHash = procDataBox->getRepresentativeVariableBindingPathSetHash(true);
repVarBindPathSetHash->insertRepresentativeVariableBindingPathSetData(repData);
joinAllExtData->setRepresentativeVariableBindingPathSetData(repData);
}
void CCalculationTableauCompletionTaskHandleAlgorithm::createCommonJoiningKeyMap(CRepresentativeJoiningCommonKeyMap* repJoinCommonKeyMap, CRepresentativeVariableBindingPathSetJoiningKeyMap* firstJoiningKeyMap, CRepresentativeVariableBindingPathSetData* firstRepData,
CRepresentativeVariableBindingPathSetJoiningKeyMap* secJoiningKeyMap, CRepresentativeVariableBindingPathSetData* secRepData, bool firstLeft, CCalculationAlgorithmContextBase* calcAlgContext) {
if (secJoiningKeyMap->count() < firstJoiningKeyMap->count()) {
createCommonJoiningKeyMap(repJoinCommonKeyMap,secJoiningKeyMap,secRepData,firstJoiningKeyMap,firstRepData,!firstLeft,calcAlgContext);
}
if (firstJoiningKeyMap->count()*mMapComparisonDirectLookupFactor < secJoiningKeyMap->count()) {
for (CRepresentativeVariableBindingPathSetJoiningKeyMap::const_iterator it = firstJoiningKeyMap->constBegin(), itEnd = firstJoiningKeyMap->constEnd(); it != itEnd; ++it) {
cint64 joiningKey = it.key();
CRepresentativeVariableBindingPathSetJoiningKeyDataMap* firstJoiningDataMap = it.value().getRepresentativeVariableBindingPathSetJoiningKeyDataMap();
CRepresentativeVariableBindingPathSetJoiningKeyDataMap* secJoiningDataMap = secJoiningKeyMap->value(joiningKey).getRepresentativeVariableBindingPathSetJoiningKeyDataMap();
if (secJoiningDataMap) {
CRepresentativeVariableBindingPathSetJoiningKeyDataMap* leftJoiningDataMap = firstJoiningDataMap;
CRepresentativeVariableBindingPathSetJoiningKeyDataMap* rightJoiningDataMap = secJoiningDataMap;
if (!firstLeft) {
leftJoiningDataMap = secJoiningDataMap;
rightJoiningDataMap = firstJoiningDataMap;
}
repJoinCommonKeyMap->insert(joiningKey,CRepresentativeJoiningCommonKeyData(leftJoiningDataMap,rightJoiningDataMap));
}
}
} else {
CRepresentativeVariableBindingPathSetJoiningKeyMap::const_iterator it1 = firstJoiningKeyMap->constBegin(), it1End = firstJoiningKeyMap->constEnd();
CRepresentativeVariableBindingPathSetJoiningKeyMap::const_iterator it2 = secJoiningKeyMap->constBegin(), it2End = secJoiningKeyMap->constEnd();
while (it1 != it1End && it2 != it2End) {
cint64 joiningKey1 = it1.key();
cint64 joiningKey2 = it2.key();
if (joiningKey1 == joiningKey2) {
CRepresentativeVariableBindingPathSetJoiningKeyDataMap* firstJoiningDataMap = it1.value().getRepresentativeVariableBindingPathSetJoiningKeyDataMap();
CRepresentativeVariableBindingPathSetJoiningKeyDataMap* secJoiningDataMap = it2.value().getRepresentativeVariableBindingPathSetJoiningKeyDataMap();
if (firstJoiningDataMap && secJoiningDataMap) {
CRepresentativeVariableBindingPathSetJoiningKeyDataMap* leftJoiningDataMap = firstJoiningDataMap;
CRepresentativeVariableBindingPathSetJoiningKeyDataMap* rightJoiningDataMap = secJoiningDataMap;
if (!firstLeft) {
leftJoiningDataMap = secJoiningDataMap;
rightJoiningDataMap = firstJoiningDataMap;
}
repJoinCommonKeyMap->insert(joiningKey1,CRepresentativeJoiningCommonKeyData(leftJoiningDataMap,rightJoiningDataMap));
}
++it1;
++it2;
} else if (joiningKey1 < joiningKey2) {
++it1;
} else if (joiningKey2 < joiningKey1) {
++it2;
}
}
}
}
CRepresentativeVariableBindingPathSetJoiningKeyMap* CCalculationTableauCompletionTaskHandleAlgorithm::getRepresentativeJoiningKeyData(CRepresentativeVariableBindingPathSetData* repVarBindPathSetData, CConcept* joinConcept, CCalculationAlgorithmContextBase* calcAlgContext) {
CProcessContext* processContext = calcAlgContext->getUsedProcessContext();
CProcessingDataBox* procDataBox = calcAlgContext->getUsedProcessingDataBox();
CMemoryAllocationManager* taskMemMan = calcAlgContext->getUsedProcessTaskMemoryAllocationManager();
CSortedLinker* keyVarLinker = joinConcept->getVariableLinker();
CRepresentativeVariableBindingPathSetJoiningData* joiningData = nullptr;
CRepresentativeVariableBindingPathSetJoiningHash* joiningHash = repVarBindPathSetData->getJoiningHash(false);
if (joiningHash) {
joiningData = joiningHash->getRepresentativeVariableBindingPathSetJoiningData(joinConcept,false);
}
if (!joiningData) {
joiningHash = repVarBindPathSetData->getJoiningHash(true);
joiningData = joiningHash->getRepresentativeVariableBindingPathSetJoiningData(joinConcept,true);
CRepresentativeVariableBindingPathJoiningKeyHash* varBindPathJoiningKeyHash = procDataBox->getRepresentativeVariableBindingPathJoiningKeyHash(true);
CRepresentativeVariableBindingPathSetJoiningKeyMap* joiningKeyMap = joiningData->getJoiningKeyMap();
CRepresentativeVariableBindingPathMap* varBindPathMap = repVarBindPathSetData->getMigrateData(false)->getRepresentativeVariableBindingPathMap();
for (CRepresentativeVariableBindingPathMap::const_iterator it = varBindPathMap->constBegin(), itEnd = varBindPathMap->constEnd(); it != itEnd; ++it) {
CVariableBindingPath* varBindPath = it.value().getVariableBindingPath();
cint64 joinKey = varBindPathJoiningKeyHash->getRepresentativeVariableBindingPathJoiningKey(varBindPath,keyVarLinker,true);
CRepresentativeVariableBindingPathSetJoiningKeyDataMap* joiningKeyDataMap = joiningKeyMap->getJoiningKeyDataMap(joinKey,true);
joiningKeyDataMap->insert(varBindPath->getPropagationID(),varBindPath);
}
}
return joiningData->getJoiningKeyMap();
}
void CCalculationTableauCompletionTaskHandleAlgorithm::applyREPRESENTATIVEBINDVARIABLERule(CIndividualProcessNode*& processIndi, CConceptProcessDescriptor*& conProDes, bool negate, CCalculationAlgorithmContextBase* calcAlgContext) {
CConceptDescriptor* conDes = conProDes->getConceptDescriptor();
CConcept* concept = conDes->getConcept();
CVariable* variable = concept->getVariable();
bool conceptNegation = negate;
CDependencyTrackPoint* depTrackPoint = conProDes->getDependencyTrackPoint();
CSortedNegLinker* opConLinker = concept->getOperandList();
CConcept* bindingTriggerConcept = opConLinker->getData();
bool bindingTriggerConceptNegation = opConLinker->isNegated();
CProcessContext* processContext = calcAlgContext->getUsedProcessContext();
CProcessingDataBox* procDataBox = calcAlgContext->getUsedProcessingDataBox();
CMemoryAllocationManager* taskMemMan = calcAlgContext->getUsedProcessTaskMemoryAllocationManager();
CReapplyConceptLabelSet* conSet = processIndi->getReapplyConceptLabelSet(false);
CConceptDescriptor* bindingConDes = nullptr;
CDependencyTrackPoint* bindingDepTrackPoint = nullptr;
CCondensedReapplyQueue* reapplyQueue = nullptr;
STATINC(VARBINDRULEBINDAPPLICATIONCOUNT,calcAlgContext);
bool updateExt = false;
CConceptPropagationBindingSetHash* conPropBindingSetHash = processIndi->getConceptPropagationBindingSetHash(false);
if (conPropBindingSetHash) {
CPropagationBindingSet* propBindingSet = conPropBindingSetHash->getPropagationBindingSet(concept,false);
if (propBindingSet) {
CPropagationVariableBindingTransitionExtension* propVarBindTransExt = propBindingSet->getPropagationVariableBindingTransitionExtension(false);
if (!propVarBindTransExt || !propVarBindTransExt->isProcessingCompleted()) {
if (!propVarBindTransExt || propBindingSet->hasPropagateAllFlag()) {
updateExt = true;
} else {
CPropagationBindingDescriptor* lastAnalyPropBindDes = propVarBindTransExt->getLastAnalysedPropagationBindingDescriptor();
CPropagationBindingDescriptor* propBindDes = propBindingSet->getPropagationBindingDescriptorLinker();
if (lastAnalyPropBindDes != propBindDes) {
updateExt = true;
}
}
}
}
}
if (updateExt) {
CConceptPropagationBindingSetHash* conPropBindingSetHash = processIndi->getConceptPropagationBindingSetHash(true);
CPropagationBindingSet* propBindingSet = conPropBindingSetHash->getPropagationBindingSet(concept,true);
CPropagationVariableBindingTransitionExtension* propVarBindTransExt = propBindingSet->getPropagationVariableBindingTransitionExtension(true);
CPropagationBindingDescriptor* lastAnalyPropBindDes = propVarBindTransExt->getLastAnalysedPropagationBindingDescriptor();
CPropagationBindingDescriptor* propBindDes = propBindingSet->getPropagationBindingDescriptorLinker();
propVarBindTransExt->setTriggeredVariableIndividualPair(variable,processIndi);
bool createVarBinding = false;
createVarBinding = propBindingSet->hasPropagateAllFlag();
for (CPropagationBindingDescriptor* propBindDesIt = propBindDes; propBindDesIt != lastAnalyPropBindDes; propBindDesIt = propBindDesIt->getNext()) {
if (propVarBindTransExt->addAnalysedPropagationBindingDescriptorReturnMatched(propBindDesIt)) {
createVarBinding = true;
}
}
propVarBindTransExt->setLastAnalysedPropagationBindingDescriptor(propBindDes);
propVarBindTransExt->setLastAnalysedPropagateAllFlag(propBindingSet->hasPropagateAllFlag());
if (createVarBinding) {
++mStatRepresentativeCreatedCount;
STATINC(VARBINDVARIABLEBINDCOUNT,calcAlgContext);
propVarBindTransExt->setProcessingCompleted(true);
CConceptRepresentativePropagationSetHash* conRepPropSetHash = processIndi->getConceptRepresentativePropagationSetHash(true);
CRepresentativePropagationSet* repPropSet = conRepPropSetHash->getRepresentativePropagationSet(bindingTriggerConcept,true);
CProcessingDataBox* processingDataBox = calcAlgContext->getUsedProcessingDataBox();
cint64 nextPathPropID = processingDataBox->getNextVariableBindingPathID(true);
CDependencyTrackPoint* nextDepTrackPoint = nullptr;
CREPRESENTATIVEBINDVARIABLEDependencyNode* bindDepNode = createREPRESENTATIVEBINDVARIABLEDependency(nextDepTrackPoint,processIndi,conDes,depTrackPoint,calcAlgContext);
if (!conSet->getConceptDescriptorAndReapplyQueue(bindingTriggerConcept,bindingConDes,bindingDepTrackPoint,reapplyQueue)) {
bindingConDes = addConceptToIndividualReturnConceptDescriptor(bindingTriggerConcept,bindingTriggerConceptNegation,processIndi,nextDepTrackPoint,false,false,calcAlgContext);
} else {
reapplyConceptUpdatedRepresentative(processIndi,bindingConDes,bindingDepTrackPoint,conSet,reapplyQueue,calcAlgContext);
}
repPropSet->setConceptDescriptor(bindingConDes);
CVariableBinding* varBinding = CObjectAllocator::allocateAndConstruct(taskMemMan);
varBinding->initVariableBinding(nextDepTrackPoint,processIndi,variable);
CVariableBindingDescriptor* varBindingDes = CObjectAllocator::allocateAndConstruct(taskMemMan);
varBindingDes->initVariableBindingDescriptor(varBinding);
CVariableBindingPath* varBindingPath = CObjectAllocator::allocateAndConstruct(taskMemMan);
varBindingPath->initVariableBindingPath(nextPathPropID,varBindingDes);
CRepresentativeVariableBindingPathHash* repVarBindPathHash = procDataBox->getRepresentativeVariableBindingPathHash(true);
CRepresentativeVariableBindingPathSetData* repData = repVarBindPathHash->getRepresentativeVariableBindingPathSetData(varBindingPath,true);
repData->setRepresentativeID(procDataBox->getNextRepresentativeVariableBindingPathID(true));
repData->setMigratable(false);
repData->incUseCount();
repData->incShareCount();
CRepresentativeVariableBindingPathSetMigrateData* repMigData = repData->getMigrateData(true);
repMigData->getRepresentativeVariableBindingPathMap()->insert(varBindingPath->getPropagationID(),CRepresentativeVariableBindingPathMapData(varBindingPath,repData));
repMigData->getRepresentativeContainingMap()->insertContainedRepresentative(repData,false);
repData->addKeySignatureValue(repData->getRepresentativeID());
CRepresentativeVariableBindingPathSetHash* repVarBindPathSetHash = procDataBox->getRepresentativeVariableBindingPathSetHash(true);
repVarBindPathSetHash->insertRepresentativeVariableBindingPathSetData(repData);
CRepresentativePropagationDescriptor* repPropDes = CObjectAllocator::allocateAndConstruct(taskMemMan);
repPropDes->initRepresentativeDescriptor(repData,nextDepTrackPoint);
repPropSet->addIncomingRepresentativePropagationDescriptorLinker(repPropDes);
updateRepresentativePropagationSet(processIndi,repPropSet,calcAlgContext);
}
}
}
void CCalculationTableauCompletionTaskHandleAlgorithm::applyREPRESENTATIVEIMPLICATIONRule(CIndividualProcessNode*& processIndi, CConceptProcessDescriptor*& conProDes, bool negate, CCalculationAlgorithmContextBase* calcAlgContext) {
CConceptDescriptor* conDes = conProDes->getConceptDescriptor();
CConcept* concept = conDes->getConcept();
CDependencyTrackPoint* depTrackPoint = conProDes->getDependencyTrackPoint();
cint64 opCount = concept->getOperandCount();
CSortedNegLinker* opLinker = concept->getOperandList();
CMemoryAllocationManager* taskMemMan = calcAlgContext->getUsedProcessTaskMemoryAllocationManager();
CReapplyConceptLabelSet* conSet = processIndi->getReapplyConceptLabelSet(false);
CConceptDescriptor* bindingConDes = nullptr;
CDependencyTrackPoint* bindingDepTrackPoint = nullptr;
CCondensedReapplyQueue* reapplyQueue = nullptr;
CConcept* bindingTriggerConcept = opLinker->getData();
bool bindingTriggerConceptNegation = opLinker->isNegated();
CSortedNegLinker* triggerLinker = opLinker->getNext();
STATINC(VARBINDRULEIMPLICATIONAPPLICATIONCOUNT,calcAlgContext);
if (!conSet->getConceptDescriptorAndReapplyQueue(bindingTriggerConcept,bindingConDes,bindingDepTrackPoint,reapplyQueue)) {
// search next not existing trigger
bool allTriggersAvailable = true;
conSet = processIndi->getReapplyConceptLabelSet(true);
CSortedNegLinker* triggerLinkerIt = nullptr;
for (triggerLinkerIt = triggerLinker; triggerLinkerIt; triggerLinkerIt = triggerLinkerIt->getNext()) {
CSortedNegLinker* nextTrigger = triggerLinkerIt;
CConcept* triggerConcept = nextTrigger->getData();
CConceptDescriptor* triggerConDes = nullptr;
CDependencyTrackPoint* triggerDepTrackPoint = nullptr;
if (conSet->getConceptDescriptor(triggerConcept,triggerConDes,triggerDepTrackPoint)) {
if (triggerConDes->isNegated() == nextTrigger->isNegated()) {
return;
}
} else {
allTriggersAvailable = false;
break;
}
}
if (!allTriggersAvailable) {
// install to trigger
CSortedNegLinker* nextTrigger = triggerLinkerIt;
CConcept* triggerConcept = nextTrigger->getData();
bool triggerNegation = !nextTrigger->isNegated();
if (!isConceptInReapplyQueue(conDes,triggerConcept,triggerNegation,processIndi,calcAlgContext)) {
addConceptToReapplyQueue(conDes,triggerConcept,triggerNegation,processIndi,(CProcessingRestrictionSpecification*)nullptr,depTrackPoint,calcAlgContext);
}
} else {
CDependency* triggerDeps = nullptr;
for (CSortedNegLinker* triggerLinkerIt = triggerLinker; triggerLinkerIt; triggerLinkerIt = triggerLinkerIt->getNext()) {
CConcept* triggerConcept = triggerLinkerIt->getData();
CConceptDescriptor* triggerConDes = nullptr;
CDependencyTrackPoint* triggerDepTrackPoint = nullptr;
conSet->getConceptDescriptor(triggerConcept,triggerConDes,triggerDepTrackPoint);
CCONNECTIONDependencyNode* connDep = createCONNECTIONDependency(processIndi,triggerConDes,triggerDepTrackPoint,calcAlgContext);
connDep->setNext(triggerDeps);
triggerDeps = connDep;
}
++mStatRepresentativeImplicationCount;
CConceptRepresentativePropagationSetHash* conRepPropSetHash = processIndi->getConceptRepresentativePropagationSetHash(true);
CRepresentativePropagationSet* prevRepPropSet = conRepPropSetHash->getRepresentativePropagationSet(concept,false);
CRepresentativePropagationSet* repPropSet = conRepPropSetHash->getRepresentativePropagationSet(bindingTriggerConcept,true);
CRepresentativePropagationDescriptor* procRepPropDes = nullptr;
CDependencyTrackPoint* propDepTrackPoint = nullptr;
if (prevRepPropSet) {
procRepPropDes = prevRepPropSet->getOutgoingRepresentativePropagationDescriptorLinker();
}
if (procRepPropDes) {
propDepTrackPoint = procRepPropDes->getDependencyTrackPoint();
repPropSet->setConceptDescriptor(bindingConDes);
CDependencyTrackPoint* nextDepTrackPoint = nullptr;
CREPRESENTATIVEIMPLICATIONDependencyNode* implDepNode = createREPRESENTATIVEIMPLICATIONDependency(nextDepTrackPoint,processIndi,conDes,propDepTrackPoint,triggerDeps,calcAlgContext);
bindingConDes = addConceptToIndividualReturnConceptDescriptor(bindingTriggerConcept,bindingTriggerConceptNegation,processIndi,nextDepTrackPoint,true,false,calcAlgContext);
propagateRepresentative(processIndi,procRepPropDes,repPropSet,nextDepTrackPoint,calcAlgContext);
}
}
} else {
CConceptRepresentativePropagationSetHash* conRepPropSetHash = processIndi->getConceptRepresentativePropagationSetHash(true);
CRepresentativePropagationSet* prevRepPropSet = conRepPropSetHash->getRepresentativePropagationSet(concept,false);
CRepresentativePropagationSet* repPropSet = conRepPropSetHash->getRepresentativePropagationSet(bindingTriggerConcept,true);
CRepresentativePropagationDescriptor* procRepPropDes = nullptr;
CDependencyTrackPoint* propDepTrackPoint = nullptr;
if (prevRepPropSet) {
procRepPropDes = prevRepPropSet->getOutgoingRepresentativePropagationDescriptorLinker();
}
if (procRepPropDes) {
propDepTrackPoint = procRepPropDes->getDependencyTrackPoint();
if (requiresRepresentativePropagation(processIndi,procRepPropDes,repPropSet,calcAlgContext)) {
CDependency* triggerDeps = nullptr;
for (CSortedNegLinker* triggerLinkerIt = triggerLinker; triggerLinkerIt; triggerLinkerIt = triggerLinkerIt->getNext()) {
CConcept* triggerConcept = triggerLinkerIt->getData();
CConceptDescriptor* triggerConDes = nullptr;
CDependencyTrackPoint* triggerDepTrackPoint = nullptr;
conSet->getConceptDescriptor(triggerConcept,triggerConDes,triggerDepTrackPoint);
CCONNECTIONDependencyNode* connDep = createCONNECTIONDependency(processIndi,triggerConDes,triggerDepTrackPoint,calcAlgContext);
connDep->setNext(triggerDeps);
triggerDeps = connDep;
}
++mStatRepresentativeImplicationCount;
CDependencyTrackPoint* nextDepTrackPoint = nullptr;
CREPRESENTATIVEIMPLICATIONDependencyNode* implDepNode = createREPRESENTATIVEIMPLICATIONDependency(nextDepTrackPoint,processIndi,conDes,propDepTrackPoint,triggerDeps,calcAlgContext);
propagateRepresentative(processIndi,procRepPropDes,repPropSet,nextDepTrackPoint,calcAlgContext);
reapplyConceptUpdatedRepresentative(processIndi,bindingConDes,bindingDepTrackPoint,conSet,reapplyQueue,calcAlgContext);
}
}
}
}
void CCalculationTableauCompletionTaskHandleAlgorithm::propagateRepresentativeToSuccessor(CIndividualProcessNode* processIndi, CIndividualProcessNode*& succIndi, CSortedNegLinker* conceptOpLinker, bool negate, CConceptDescriptor* conDes, CIndividualLinkEdge* restLink, CCalculationAlgorithmContextBase* calcAlgContext) {
CMemoryAllocationManager* taskMemMan = calcAlgContext->getUsedProcessTaskMemoryAllocationManager();
CDependencyTrackPoint* depTrackPoint = conDes->getDependencyTrackPoint();
CConcept* concept = conDes->getConcept();
succIndi = getLocalizedIndividual(succIndi,false,calcAlgContext);
CReapplyConceptLabelSet* conSet = succIndi->getReapplyConceptLabelSet(false);
// create dependency
CDependencyTrackPoint* nextDepTrackPoint = nullptr;
bool continuePropagation = false;
for (CSortedNegLinker* conceptOpLinkerIt = conceptOpLinker; conceptOpLinkerIt; conceptOpLinkerIt = conceptOpLinkerIt->getNext()) {
CConcept* opConcept = conceptOpLinkerIt->getData();
bool opConNeg = conceptOpLinkerIt->isNegated() ^ negate;
CConceptDescriptor* bindingConDes = nullptr;
CDependencyTrackPoint* bindingDepTrackPoint = nullptr;
CCondensedReapplyQueue* reapplyQueue = nullptr;
CConceptRepresentativePropagationSetHash* conRepPropSetHash = processIndi->getConceptRepresentativePropagationSetHash(true);
CRepresentativePropagationSet* prevRepPropSet = conRepPropSetHash->getRepresentativePropagationSet(concept,false);
CConceptRepresentativePropagationSetHash* succConRepPropSetHash = succIndi->getConceptRepresentativePropagationSetHash(true);
CRepresentativePropagationSet* succRepPropSet = succConRepPropSetHash->getRepresentativePropagationSet(opConcept,true);
CRepresentativePropagationDescriptor* procRepPropDes = nullptr;
CDependencyTrackPoint* propDepTrackPoint = nullptr;
if (prevRepPropSet) {
procRepPropDes = prevRepPropSet->getOutgoingRepresentativePropagationDescriptorLinker();
}
if (procRepPropDes) {
propDepTrackPoint = procRepPropDes->getDependencyTrackPoint();
if (!conSet->getConceptDescriptorAndReapplyQueue(opConcept,bindingConDes,bindingDepTrackPoint,reapplyQueue)) {
++mStatRepresentativePropagateSuccCount;
if (!nextDepTrackPoint) {
conSet = succIndi->getReapplyConceptLabelSet(true);
CREPRESENTATIVEALLDependencyNode* repAllDepNode = createREPRESENTATIVEALLDependency(nextDepTrackPoint,processIndi,conDes,propDepTrackPoint,restLink->getDependencyTrackPoint(),calcAlgContext);
}
bindingConDes = addConceptToIndividualReturnConceptDescriptor(opConcept,opConNeg,succIndi,nextDepTrackPoint,false,false,calcAlgContext);
succRepPropSet->setConceptDescriptor(bindingConDes);
propagateRepresentative(succIndi,procRepPropDes,succRepPropSet,nextDepTrackPoint,calcAlgContext);
continuePropagation = true;
} else {
if (requiresRepresentativePropagation(succIndi,procRepPropDes,succRepPropSet,calcAlgContext)) {
++mStatRepresentativePropagateSuccCount;
if (!nextDepTrackPoint) {
conSet = succIndi->getReapplyConceptLabelSet(true);
CREPRESENTATIVEALLDependencyNode* repAllDepNode = createREPRESENTATIVEALLDependency(nextDepTrackPoint,processIndi,conDes,propDepTrackPoint,restLink->getDependencyTrackPoint(),calcAlgContext);
}
propagateRepresentative(succIndi,procRepPropDes,succRepPropSet,nextDepTrackPoint,calcAlgContext);
cint64 varCount = succRepPropSet->getOutgoingRepresentativePropagationDescriptorLinker()->getRepresentativeVariableBindingPathSetData()->getRepresentatedVariableCount();
reapplyConceptUpdatedRepresentative(succIndi,bindingConDes,bindingDepTrackPoint,varCount,conSet,reapplyQueue,calcAlgContext);
continuePropagation = true;
}
}
}
}
if (continuePropagation) {
addIndividualToProcessingQueue(succIndi,calcAlgContext);
}
}
void CCalculationTableauCompletionTaskHandleAlgorithm::applyREPRESENTATIVEALLRule(CIndividualProcessNode*& processIndi, CConceptProcessDescriptor*& conProDes, bool negate, CCalculationAlgorithmContextBase* calcAlgContext) {
CConceptDescriptor* conDes = conProDes->getConceptDescriptor();
CConcept* concept = conDes->getConcept();
CRole* role = concept->getRole();
CDependencyTrackPoint* depTrackPoint = conProDes->getDependencyTrackPoint();
cint64 opCount = concept->getOperandCount();
CSortedNegLinker* opLinker = concept->getOperandList();
CMemoryAllocationManager* taskMemMan = calcAlgContext->getUsedProcessTaskMemoryAllocationManager();
CSortedNegLinker* conceptOpLinker = concept->getOperandList();
STATINC(VARBINDRULEALLAPPLICATIONCOUNT,calcAlgContext);
CIndividualLinkEdge* restLink = getLinkProcessingRestriction(conProDes);
if (restLink) {
CIndividualProcessNode* succIndi = getSuccessorIndividual(processIndi,restLink,calcAlgContext);
propagateRepresentativeToSuccessor(processIndi,succIndi,opLinker,negate,conDes,restLink,calcAlgContext);
} else {
CReapplyRoleSuccessorHash* roleSuccHash = processIndi->getReapplyRoleSuccessorHash(false);
if (roleSuccHash) {
CRoleSuccessorLinkIterator roleSuccIt = roleSuccHash->getRoleSuccessorLinkIterator(role);
while (roleSuccIt.hasNext()) {
CIndividualLinkEdge* link = roleSuccIt.next(true);
CIndividualProcessNode* succIndi = getSuccessorIndividual(processIndi,link,calcAlgContext);
propagateRepresentativeToSuccessor(processIndi,succIndi,opLinker,negate,conDes,link,calcAlgContext);
}
}
}
if (!conProDes->isConceptReapplied()) {
if (!isConceptInReapplyQueue(conDes,role,processIndi,calcAlgContext)) {
addConceptToReapplyQueue(conDes,role,processIndi,true,depTrackPoint,calcAlgContext);
}
}
}
void CCalculationTableauCompletionTaskHandleAlgorithm::applyREPRESENTATIVEANDRule(CIndividualProcessNode*& processIndi, CConceptProcessDescriptor*& conProDes, bool negate, CCalculationAlgorithmContextBase* calcAlgContext) {
CConceptDescriptor* conDes = conProDes->getConceptDescriptor();
CConcept* concept = conDes->getConcept();
bool conceptNegation = negate;
CDependencyTrackPoint* depTrackPoint = conProDes->getDependencyTrackPoint();
CSortedNegLinker* opConLinker = concept->getOperandList();
CProcessingDataBox* procDataBox = calcAlgContext->getUsedProcessingDataBox();
CMemoryAllocationManager* taskMemMan = calcAlgContext->getUsedProcessTaskMemoryAllocationManager();
CReapplyConceptLabelSet* conSet = processIndi->getReapplyConceptLabelSet(false);
CDependencyTrackPoint* nextDepTrackPoint = nullptr;
CConceptRepresentativePropagationSetHash* conRepPropHash = nullptr;
CRepresentativePropagationSet* prevRepPropSet = nullptr;
CRepresentativePropagationDescriptor* procRepPropDes = nullptr;
CDependencyTrackPoint* propDepTrackPoint = nullptr;
STATINC(VARBINDRULEANDAPPLICATIONCOUNT,calcAlgContext);
for (CSortedNegLinker* opConLinkerIt = opConLinker; opConLinkerIt; opConLinkerIt = opConLinkerIt->getNext()) {
CConcept* bindingTriggerConcept = opConLinkerIt->getData();
bool bindingTriggerConceptNegation = opConLinkerIt->isNegated()^conceptNegation;
if (!conRepPropHash) {
conRepPropHash = processIndi->getConceptRepresentativePropagationSetHash(true);
}
if (!prevRepPropSet) {
prevRepPropSet = conRepPropHash->getRepresentativePropagationSet(concept,false);
}
if (prevRepPropSet) {
procRepPropDes = prevRepPropSet->getOutgoingRepresentativePropagationDescriptorLinker();
}
if (procRepPropDes) {
propDepTrackPoint = procRepPropDes->getDependencyTrackPoint();
CRepresentativePropagationSet* repPropSet = conRepPropHash->getRepresentativePropagationSet(bindingTriggerConcept,true);
CConceptDescriptor* bindingConDes = nullptr;
CDependencyTrackPoint* bindingDepTrackPoint = nullptr;
CCondensedReapplyQueue* reapplyQueue = nullptr;
if (!conSet->getConceptDescriptorAndReapplyQueue(bindingTriggerConcept,bindingConDes,bindingDepTrackPoint,reapplyQueue)) {
++mStatRepresentativePropagateCount;
if (!nextDepTrackPoint) {
conSet = processIndi->getReapplyConceptLabelSet(true);
CREPRESENTATIVEANDDependencyNode* repPropDepNode = createREPRESENTATIVEANDDependency(nextDepTrackPoint,processIndi,conDes,propDepTrackPoint,calcAlgContext);
}
bindingConDes = addConceptToIndividualReturnConceptDescriptor(bindingTriggerConcept,bindingTriggerConceptNegation,processIndi,nextDepTrackPoint,false,false,calcAlgContext);
repPropSet->setConceptDescriptor(bindingConDes);
propagateRepresentative(processIndi,procRepPropDes,repPropSet,nextDepTrackPoint,calcAlgContext);
} else {
if (requiresRepresentativePropagation(processIndi,procRepPropDes,repPropSet,calcAlgContext)) {
++mStatRepresentativePropagateCount;
if (!nextDepTrackPoint) {
conSet = processIndi->getReapplyConceptLabelSet(true);
CREPRESENTATIVEANDDependencyNode* repPropDepNode = createREPRESENTATIVEANDDependency(nextDepTrackPoint,processIndi,conDes,propDepTrackPoint,calcAlgContext);
}
propagateRepresentative(processIndi,procRepPropDes,repPropSet,nextDepTrackPoint,calcAlgContext);
cint64 varCount = repPropSet->getOutgoingRepresentativePropagationDescriptorLinker()->getRepresentativeVariableBindingPathSetData()->getRepresentatedVariableCount();
reapplyConceptUpdatedRepresentative(processIndi,bindingConDes,bindingDepTrackPoint,varCount,conSet,reapplyQueue,calcAlgContext);
}
}
}
}
}
void CCalculationTableauCompletionTaskHandleAlgorithm::reapplyConceptUpdatedRepresentative(CIndividualProcessNode*& processIndi, CConceptDescriptor* bindingConDes, CDependencyTrackPoint* bindingDepTrackPoint, CReapplyConceptLabelSet* conSet, CCondensedReapplyQueue* reapplyQueue, CCalculationAlgorithmContextBase* calcAlgContext) {
setIndividualNodeConceptLabelSetModified(processIndi,calcAlgContext);
CConceptProcessingQueue* conProQueue = processIndi->getConceptProcessingQueue(true);
addConceptPreprocessedToProcessingQueue(bindingConDes,bindingDepTrackPoint,conProQueue,processIndi,true,calcAlgContext);
if (!reapplyQueue->isEmpty()) {
conSet = processIndi->getReapplyConceptLabelSet(true);
CCondensedReapplyQueueIterator reapplyQueueIt(conSet->getConceptReapplyIterator(bindingConDes));
applyReapplyQueueConcepts(processIndi,&reapplyQueueIt,calcAlgContext);
}
}
void CCalculationTableauCompletionTaskHandleAlgorithm::reapplyConceptUpdatedRepresentative(CIndividualProcessNode*& processIndi, CConceptDescriptor* bindingConDes, CDependencyTrackPoint* bindingDepTrackPoint, cint64 bindingCount, CReapplyConceptLabelSet* conSet, CCondensedReapplyQueue* reapplyQueue, CCalculationAlgorithmContextBase* calcAlgContext) {
setIndividualNodeConceptLabelSetModified(processIndi,calcAlgContext);
CConceptProcessingQueue* conProQueue = processIndi->getConceptProcessingQueue(true);
addConceptPreprocessedToProcessingQueue(bindingConDes,bindingDepTrackPoint,conProQueue,processIndi,bindingCount,calcAlgContext);
if (!reapplyQueue->isEmpty()) {
conSet = processIndi->getReapplyConceptLabelSet(true);
CCondensedReapplyQueueIterator reapplyQueueIt(conSet->getConceptReapplyIterator(bindingConDes));
applyReapplyQueueConcepts(processIndi,&reapplyQueueIt,calcAlgContext);
}
}
void CCalculationTableauCompletionTaskHandleAlgorithm::updateRepresentativePropagationSet(CIndividualProcessNode*& processIndi, CRepresentativePropagationSet* repPropSet, CCalculationAlgorithmContextBase* calcAlgContext) {
if (repPropSet->getLastProcessedIncomingRepresentativePropagationDescriptorLinker() != repPropSet->getIncomingRepresentativePropagationDescriptorLinker()) {
CRepresentativePropagationDescriptor* lastRepPropDes = repPropSet->getLastProcessedIncomingRepresentativePropagationDescriptorLinker();
CRepresentativePropagationDescriptor* lastIncRepPropDes = repPropSet->getIncomingRepresentativePropagationDescriptorLinker();
CRepresentativePropagationDescriptor* lastOutRepPropDes = repPropSet->getOutgoingRepresentativePropagationDescriptorLinker();
repPropSet->setLastProcessedIncomingRepresentativePropagationDescriptorLinker(lastIncRepPropDes);
if (!repPropSet->getOutgoingRepresentativePropagationDescriptorLinker() && !lastIncRepPropDes->hasNext()) {
repPropSet->setOutgoingRepresentativePropagationDescriptorLinker(lastIncRepPropDes);
if (lastIncRepPropDes->getRepresentativeVariableBindingPathSetData()->isLocalizationTagUpToDate(calcAlgContext->getUsedProcessTagger())) {
lastIncRepPropDes->getRepresentativeVariableBindingPathSetData()->incShareCount();
}
} else {
++mStatRepresentativePropagateUseRepresentativeCount;
CProcessingDataBox* procDataBox = calcAlgContext->getUsedProcessingDataBox();
CRepresentativeVariableBindingPathSetHash* repVarBindPathSetHash = procDataBox->getRepresentativeVariableBindingPathSetHash(true);
CRepresentativeVariableBindingPathSetData* lastRepVarBindPathSetData = nullptr;
bool migrateable = false;
if (lastOutRepPropDes) {
lastRepVarBindPathSetData = lastOutRepPropDes->getRepresentativeVariableBindingPathSetData();
}
if (lastRepVarBindPathSetData) {
if (lastRepVarBindPathSetData->isLocalizationTagUpToDate(calcAlgContext->getUsedProcessTagger())) {
lastRepVarBindPathSetData->decShareCount();
if (lastRepVarBindPathSetData->isMigratable() && lastRepVarBindPathSetData->getShareCount() <= 0 && lastRepVarBindPathSetData->getUseCount() <= 20) {
migrateable = true;
}
}
}
CRepresentativeVariableBindingPathSetData* repVarBindPathSetData = repVarBindPathSetHash->getRepresentativeVariableBindingPathSetData(repPropSet,true);
repVarBindPathSetData->incShareCount();
repVarBindPathSetData->incUseCount();
if (!repVarBindPathSetData->hasMigrateData()) {
++mStatRepresentativePropagateNewRepresentativeCount;
repVarBindPathSetData->setRepresentativeID(procDataBox->getNextRepresentativeVariableBindingPathID(true));
bool updateNewOnly = false;
if (migrateable) {
updateNewOnly = true;
repVarBindPathSetData->takeMigrateDataFrom(lastRepVarBindPathSetData);
} else if (lastRepVarBindPathSetData) {
updateNewOnly = true;
repVarBindPathSetData->copyMigrateDataFrom(lastRepVarBindPathSetData);
}
CRepresentativeVariableBindingPathSetMigrateData* repMigrateData = repVarBindPathSetData->getMigrateData(true);
CRepresentativeVariableBindingPathMap* repVarBindPathMap = repMigrateData->getRepresentativeVariableBindingPathMap();
CRepresentativePropagationDescriptor* untilUpdateRepPropDes = nullptr;
if (updateNewOnly) {
untilUpdateRepPropDes = lastRepPropDes;
}
for (CRepresentativePropagationDescriptor* newRepPropDesIt = lastIncRepPropDes; newRepPropDesIt != untilUpdateRepPropDes; newRepPropDesIt = newRepPropDesIt->getNext()) {
CRepresentativeVariableBindingPathSetData* newRepVarBindPathSetData = newRepPropDesIt->getRepresentativeVariableBindingPathSetData();
CRepresentativeVariableBindingPathSetMigrateData* newRepMigrateData = newRepVarBindPathSetData->getMigrateData(true);
repMigrateData->getRepresentativeContainingMap()->insertContainedRepresentative(newRepVarBindPathSetData,true);
repVarBindPathSetData->addKeySignatureValue(newRepVarBindPathSetData->getRepresentativeKey());
CRepresentativeVariableBindingPathMap* newRepVarBindPathMap = newRepMigrateData->getRepresentativeVariableBindingPathMap();
if (newRepVarBindPathMap->count()*mMapComparisonDirectLookupFactor <= repVarBindPathMap->count()) {
for (CRepresentativeVariableBindingPathMap::const_iterator propIt = newRepVarBindPathMap->constBegin(), propItEnd = newRepVarBindPathMap->constEnd(); propIt != propItEnd; ++propIt) {
cint64 propVarBindPathID = propIt.key();
if (!repVarBindPathMap->contains(propVarBindPathID)) {
repVarBindPathMap->insert(propVarBindPathID,CRepresentativeVariableBindingPathMapData(propIt.value().getVariableBindingPath(),newRepVarBindPathSetData));
}
}
} else {
CRepresentativeVariableBindingPathMap::const_iterator availIt = repVarBindPathMap->begin(), availItEnd = repVarBindPathMap->end();
CRepresentativeVariableBindingPathMap::const_iterator propIt = newRepVarBindPathMap->constBegin(), propItEnd = newRepVarBindPathMap->constEnd();
while (propIt != propItEnd) {
cint64 propID = propIt.key();
if (availIt == availItEnd) {
availIt = repVarBindPathMap->insert(propID,CRepresentativeVariableBindingPathMapData(propIt.value().getVariableBindingPath(),newRepVarBindPathSetData));
++propIt;
++availIt;
} else {
cint64 availID = availIt.key();
if (availID < propID) {
++availIt;
} else if (availID > propID) {
availIt = repVarBindPathMap->insert(propID,CRepresentativeVariableBindingPathMapData(propIt.value().getVariableBindingPath(),newRepVarBindPathSetData));
++propIt;
++availIt;
} else {
++propIt;
++availIt;
}
}
}
}
}
} else {
++mStatRepresentativePropagateReusedRepresentativeCount;
}
CMemoryAllocationManager* taskMemMan = calcAlgContext->getUsedProcessTaskMemoryAllocationManager();
CRepresentativePropagationDescriptor* outPropRepDes = CObjectAllocator::allocateAndConstruct(taskMemMan);
CDependencyTrackPoint* nextDepTrackPoint = nullptr;
CRepresentativeVariableBindingPathMap* repVarBindPathMap = repVarBindPathSetData->getMigrateData(false)->getRepresentativeVariableBindingPathMap();
CRepresentativeContainingMap* repConMap = repVarBindPathSetData->getMigrateData(false)->getRepresentativeContainingMap();
CRESOLVEREPRESENTATIVEDependencyNode* resolveRepNode = createRESOLVEREPRESENTATIVEDependency(nextDepTrackPoint,processIndi,repPropSet->getConceptDescriptor(),repVarBindPathMap,repPropSet->getRepresentativePropagationMap(),lastIncRepPropDes->getDependencyTrackPoint(),lastOutRepPropDes->getDependencyTrackPoint(),calcAlgContext);
outPropRepDes->initRepresentativeDescriptor(repVarBindPathSetData,nextDepTrackPoint);
repPropSet->addOutgoingRepresentativePropagationDescriptorLinker(outPropRepDes);
}
}
}
void CCalculationTableauCompletionTaskHandleAlgorithm::propagateRepresentative(CIndividualProcessNode*& processIndi, CRepresentativePropagationDescriptor* repPropDes, CRepresentativePropagationSet* repPropSet, CDependencyTrackPoint* nextDepTrackPoint, CCalculationAlgorithmContextBase* calcAlgContext) {
CMemoryAllocationManager* taskMemMan = calcAlgContext->getUsedProcessTaskMemoryAllocationManager();
CRepresentativePropagationDescriptor* propagateRepDes = CObjectAllocator::allocateAndConstruct(taskMemMan);
propagateRepDes->initRepresentativeDescriptor(repPropDes->getRepresentativeVariableBindingPathSetData(),nextDepTrackPoint);
repPropSet->addIncomingRepresentativePropagation(propagateRepDes);
updateRepresentativePropagationSet(processIndi,repPropSet,calcAlgContext);
}
bool CCalculationTableauCompletionTaskHandleAlgorithm::requiresRepresentativePropagation(CIndividualProcessNode*& processIndi, CRepresentativePropagationDescriptor* repPropDes, CRepresentativePropagationSet* testRepPropSet, CCalculationAlgorithmContextBase* calcAlgContext) {
cint64 propRepID = repPropDes->getRepresentativeVariableBindingPathSetData()->getRepresentativeID();
if (testRepPropSet->containsRepresentativePropagation(propRepID)) {
return false;
}
CRepresentativePropagationDescriptor* lastRepPropDes = testRepPropSet->getOutgoingRepresentativePropagationDescriptorLinker();
if (lastRepPropDes) {
CRepresentativeVariableBindingPathSetData* availRepData = lastRepPropDes->getRepresentativeVariableBindingPathSetData();
CRepresentativeVariableBindingPathSetMigrateData* availMigData = availRepData->getMigrateData(false);
if (availMigData) {
CRepresentativeContainingMap* repContMap = availMigData->getRepresentativeContainingMap();
if (repContMap->contains(propRepID)) {
return false;
}
CRepresentativeVariableBindingPathMap* availVarBindPathMap = availMigData->getRepresentativeVariableBindingPathMap();
CRepresentativeVariableBindingPathSetMigrateData* propMigData = repPropDes->getRepresentativeVariableBindingPathSetData()->getMigrateData(false);
CRepresentativeVariableBindingPathMap* propVarBindPathMap = propMigData->getRepresentativeVariableBindingPathMap();
if (propVarBindPathMap->count()*mMapComparisonDirectLookupFactor <= availVarBindPathMap->count()) {
for (CRepresentativeVariableBindingPathMap::const_iterator propIt = propVarBindPathMap->constBegin(), propItEnd = propVarBindPathMap->constEnd(); propIt != propItEnd; ++propIt) {
cint64 propVarBindPathID = propIt.key();
if (!availVarBindPathMap->contains(propVarBindPathID)) {
return true;
}
}
return false;
} else {
CRepresentativeVariableBindingPathMap::const_iterator availIt = availVarBindPathMap->constBegin(), availItEnd = availVarBindPathMap->constEnd();
CRepresentativeVariableBindingPathMap::const_iterator propIt = propVarBindPathMap->constBegin(), propItEnd = propVarBindPathMap->constEnd();
while (propIt != propItEnd) {
cint64 propID = propIt.key();
if (availIt == availItEnd) {
return true;
}
cint64 availID = availIt.key();
if (availID < propID) {
++availIt;
} else if (propID < availID) {
return true;
} else {
++availIt;
++propIt;
}
}
return false;
}
}
}
return true;
}
void CCalculationTableauCompletionTaskHandleAlgorithm::applyVARIABLEBINDINGANDRule(CIndividualProcessNode*& processIndi, CConceptProcessDescriptor*& conProDes, bool negate, CCalculationAlgorithmContextBase* calcAlgContext) {
CConceptDescriptor* conDes = conProDes->getConceptDescriptor();
CConcept* concept = conDes->getConcept();
bool conceptNegation = negate;
CDependencyTrackPoint* depTrackPoint = conProDes->getDependencyTrackPoint();
CSortedNegLinker* opConLinker = concept->getOperandList();
CProcessingDataBox* procDataBox = calcAlgContext->getUsedProcessingDataBox();
CMemoryAllocationManager* taskMemMan = calcAlgContext->getUsedProcessTaskMemoryAllocationManager();
CReapplyConceptLabelSet* conSet = processIndi->getReapplyConceptLabelSet(false);
CDependencyTrackPoint* nextDepTrackPoint = nullptr;
STATINC(VARBINDRULEANDAPPLICATIONCOUNT,calcAlgContext);
for (CSortedNegLinker* opConLinkerIt = opConLinker; opConLinkerIt; opConLinkerIt = opConLinkerIt->getNext()) {
CConcept* bindingTriggerConcept = opConLinkerIt->getData();
bool bindingTriggerConceptNegation = opConLinkerIt->isNegated()^conceptNegation;
CConceptDescriptor* bindingConDes = nullptr;
CDependencyTrackPoint* bindingDepTrackPoint = nullptr;
CCondensedReapplyQueue* reapplyQueue = nullptr;
if (!conSet->getConceptDescriptorAndReapplyQueue(bindingTriggerConcept,bindingConDes,bindingDepTrackPoint,reapplyQueue)) {
if (!nextDepTrackPoint) {
conSet = processIndi->getReapplyConceptLabelSet(true);
CVARBINDPROPAGATEANDDependencyNode* bindDepNode = createVARBINDPROPAGATEANDDependency(nextDepTrackPoint,processIndi,conDes,depTrackPoint,calcAlgContext);
}
bindingConDes = addConceptToIndividualReturnConceptDescriptor(bindingTriggerConcept,bindingTriggerConceptNegation,processIndi,nextDepTrackPoint,false,false,calcAlgContext);
CConceptVariableBindingPathSetHash* conVarBindingSetHash = processIndi->getConceptVariableBindingPathSetHash(true);
CVariableBindingPathSet* prevVarBindingPathSet = conVarBindingSetHash->getVariableBindingPathSet(concept,false);
CVariableBindingPathSet* varBindingPathSet = conVarBindingSetHash->getVariableBindingPathSet(bindingTriggerConcept,true);
varBindingPathSet->setConceptDescriptor(bindingConDes);
propagateInitialVariableBindings(processIndi,bindingConDes,varBindingPathSet,prevVarBindingPathSet,nullptr, conVarBindingSetHash,calcAlgContext);
} else {
CConceptVariableBindingPathSetHash* conVarBindingSetHash = processIndi->getConceptVariableBindingPathSetHash(true);
CVariableBindingPathSet* prevVarBindingPathSet = conVarBindingSetHash->getVariableBindingPathSet(concept,false);
CVariableBindingPathSet* varBindingPathSet = conVarBindingSetHash->getVariableBindingPathSet(bindingTriggerConcept,true);
if (propagateFreshVariableBindings(processIndi,conDes,varBindingPathSet,prevVarBindingPathSet,nullptr, conVarBindingSetHash, calcAlgContext)) {
setIndividualNodeConceptLabelSetModified(processIndi,calcAlgContext);
CConceptProcessingQueue* conProQueue = processIndi->getConceptProcessingQueue(true);;
cint64 bindingCount = varBindingPathSet->getVariableBindingPathMap()->count();
addConceptPreprocessedToProcessingQueue(bindingConDes,bindingDepTrackPoint,conProQueue,processIndi,true,calcAlgContext);
if (!reapplyQueue->isEmpty()) {
conSet = processIndi->getReapplyConceptLabelSet(true);
CCondensedReapplyQueueIterator reapplyQueueIt(conSet->getConceptReapplyIterator(bindingConDes));
applyReapplyQueueConcepts(processIndi,&reapplyQueueIt,calcAlgContext);
}
}
}
}
}
bool CCalculationTableauCompletionTaskHandleAlgorithm::propagateInitialVariableBindings(CIndividualProcessNode*& processIndi, CConceptDescriptor* conDes, CVariableBindingPathSet* newVarBindingSet, CVariableBindingPathSet* prevVarBindingSet, CDependency* otherDependencies, CConceptVariableBindingPathSetHash* conVarBindingSetHash, CCalculationAlgorithmContextBase* calcAlgContext) {
CMemoryAllocationManager* taskMemMan = calcAlgContext->getUsedProcessTaskMemoryAllocationManager();
bool propagations = false;
CVariableBindingPathDescriptor* newVarBindPathDesLinker = nullptr;
if (prevVarBindingSet) {
newVarBindingSet->copyVariableBindingPaths(prevVarBindingSet->getVariableBindingPathMap());
CVariableBindingPathMap* varBindMap = newVarBindingSet->getVariableBindingPathMap();
for (CVariableBindingPathMap::iterator it = varBindMap->begin(), itEnd = varBindMap->end(); it != itEnd; ++it) {
++mStatVarBindingPropagateCount;
++mStatVarBindingPropagateInitialCount;
STATINC(VARBINDPROPAGATEDCOUNT,calcAlgContext);
STATINC(VARBINDPROPAGATEDINITIALCOUNT,calcAlgContext);
CVariableBindingPathMapData& varBindPathMapData = it.value();
CVariableBindingPathDescriptor* prevVarBindPathDes = varBindPathMapData.getVariableBindingPathDescriptor();
CVariableBindingPathDescriptor* newVarBindPathDes = CObjectAllocator::allocateAndConstruct(taskMemMan);
CDependencyTrackPoint* newDepTrackPoint = nullptr;
CPROPAGATEVARIABLEBINDINGDependencyNode* bindDepNode = createPROPAGATEVARIABLEBINDINGDependency(newDepTrackPoint,processIndi,conDes,prevVarBindPathDes->getDependencyTrackPoint(),otherDependencies,calcAlgContext);
newVarBindPathDes->initVariableBindingPathDescriptor(prevVarBindPathDes->getVariableBindingPath(),newDepTrackPoint);
varBindPathMapData.setVariableBindingPathDescriptor(newVarBindPathDes);
newVarBindPathDesLinker = newVarBindPathDes->append(newVarBindPathDesLinker);
propagations = true;
}
if (newVarBindPathDesLinker) {
newVarBindingSet->addVariableBindingPathDescriptorLinker(newVarBindPathDesLinker);
conVarBindingSetHash->setLastVariableBindingDescriptionLinker(newVarBindPathDesLinker);
}
}
return propagations;
}
bool CCalculationTableauCompletionTaskHandleAlgorithm::propagateFreshVariableBindings(CIndividualProcessNode*& processIndi, CConceptDescriptor* conDes, CVariableBindingPathSet* newVarBindingSet, CVariableBindingPathSet* prevVarBindingSet, CDependency* otherDependencies, CConceptVariableBindingPathSetHash* conVarBindingSetHash, CCalculationAlgorithmContextBase* calcAlgContext) {
CMemoryAllocationManager* taskMemMan = calcAlgContext->getUsedProcessTaskMemoryAllocationManager();
bool propagations = false;
if (prevVarBindingSet) {
CVariableBindingPathMap* prevVarBindPathMap = prevVarBindingSet->getVariableBindingPathMap();
CVariableBindingPathMap* newVarBindPathMap = newVarBindingSet->getVariableBindingPathMap();
CVariableBindingPathMap::iterator itNew = newVarBindPathMap->begin();
CVariableBindingPathMap::const_iterator itPrev = prevVarBindPathMap->constBegin(), itPrevEnd = prevVarBindPathMap->constEnd();
CVariableBindingPathDescriptor* newVarBindPathDesLinker = nullptr;
while (itPrev != itPrevEnd) {
cint64 prevPropID = itPrev.key();
bool doPropagation = false;
if (itNew == newVarBindPathMap->end()) {
doPropagation = true;
} else {
cint64 newPropID = itNew.key();
if (newPropID < prevPropID) {
++itNew;
} else if (newPropID == prevPropID) {
++itNew;
++itPrev;
} else {
doPropagation = true;
}
}
if (doPropagation) {
++mStatVarBindingPropagateCount;
++mStatVarBindingPropagateFreshCount;
STATINC(VARBINDPROPAGATEDCOUNT,calcAlgContext);
STATINC(VARBINDPROPAGATEDFRESHCOUNT,calcAlgContext);
const CVariableBindingPathMapData& prevVarBindPathMapData = itPrev.value();
CVariableBindingPathDescriptor* prevVarBindPathDes = prevVarBindPathMapData.getVariableBindingPathDescriptor();
CVariableBindingPathDescriptor* newVarBindPathDes = CObjectAllocator::allocateAndConstruct(taskMemMan);
CDependencyTrackPoint* newDepTrackPoint = nullptr;
CPROPAGATEVARIABLEBINDINGDependencyNode* bindDepNode = createPROPAGATEVARIABLEBINDINGDependency(newDepTrackPoint,processIndi,conDes,prevVarBindPathDes->getDependencyTrackPoint(),otherDependencies,calcAlgContext);
CVariableBindingPath* varBindingPath = prevVarBindPathDes->getVariableBindingPath();
newVarBindPathDes->initVariableBindingPathDescriptor(varBindingPath,newDepTrackPoint);
itNew = newVarBindPathMap->insert(varBindingPath->getPropagationID(),CVariableBindingPathMapData(newVarBindPathDes));
newVarBindPathDesLinker = newVarBindPathDes->append(newVarBindPathDesLinker);
propagations = true;
}
}
if (newVarBindPathDesLinker) {
newVarBindingSet->addVariableBindingPathDescriptorLinker(newVarBindPathDesLinker);
conVarBindingSetHash->setLastVariableBindingDescriptionLinker(newVarBindPathDesLinker);
}
}
return propagations;
}
void CCalculationTableauCompletionTaskHandleAlgorithm::propagateVariableBindingsToSuccessor(CIndividualProcessNode* processIndi, CIndividualProcessNode*& succIndi, CSortedNegLinker* conceptOpLinker, bool negate, CConceptDescriptor* conDes, CIndividualLinkEdge* restLink, CCalculationAlgorithmContextBase* calcAlgContext) {
CMemoryAllocationManager* taskMemMan = calcAlgContext->getUsedProcessTaskMemoryAllocationManager();
CDependencyTrackPoint* depTrackPoint = conDes->getDependencyTrackPoint();
CConcept* concept = conDes->getConcept();
succIndi = getLocalizedIndividual(succIndi,false,calcAlgContext);
CReapplyConceptLabelSet* conSet = succIndi->getReapplyConceptLabelSet(false);
// create dependency
CDependencyTrackPoint* nextDepTrackPoint = nullptr;
bool continuePropagation = false;
for (CSortedNegLinker* conceptOpLinkerIt = conceptOpLinker; conceptOpLinkerIt; conceptOpLinkerIt = conceptOpLinkerIt->getNext()) {
CConcept* opConcept = conceptOpLinkerIt->getData();
bool opConNeg = conceptOpLinkerIt->isNegated() ^ negate;
CConceptDescriptor* bindingConDes = nullptr;
CDependencyTrackPoint* bindingDepTrackPoint = nullptr;
CCondensedReapplyQueue* reapplyQueue = nullptr;
if (!conSet->getConceptDescriptorAndReapplyQueue(opConcept,bindingConDes,bindingDepTrackPoint,reapplyQueue)) {
if (!nextDepTrackPoint) {
conSet = succIndi->getReapplyConceptLabelSet(true);
CVARBINDPROPAGATEALLDependencyNode* bindDepNode = createVARBINDPROPAGATEALLDependency(nextDepTrackPoint,processIndi,conDes,depTrackPoint,restLink->getDependencyTrackPoint(),calcAlgContext);
}
bindingConDes = addConceptToIndividualReturnConceptDescriptor(opConcept,opConNeg,succIndi,nextDepTrackPoint,false,false,calcAlgContext);
CConceptVariableBindingPathSetHash* conVarBindingPathSetHash = processIndi->getConceptVariableBindingPathSetHash(true);
CVariableBindingPathSet* prevVarBindingPathSet = conVarBindingPathSetHash->getVariableBindingPathSet(concept,false);
CConceptVariableBindingPathSetHash* succConVarBindingPathSetHash = succIndi->getConceptVariableBindingPathSetHash(true);
CVariableBindingPathSet* succVarBindingPathSet = succConVarBindingPathSetHash->getVariableBindingPathSet(opConcept,true);
succVarBindingPathSet->setConceptDescriptor(bindingConDes);
propagateInitialVariableBindingsToSuccessor(processIndi,succIndi,bindingConDes,succVarBindingPathSet,prevVarBindingPathSet,restLink, succConVarBindingPathSetHash,calcAlgContext);
continuePropagation = true;
} else {
CConceptVariableBindingPathSetHash* conVarBindingPathSetHash = processIndi->getConceptVariableBindingPathSetHash(true);
CVariableBindingPathSet* prevVarBindingPathSet = conVarBindingPathSetHash->getVariableBindingPathSet(concept,false);
CConceptVariableBindingPathSetHash* succConVarBindingPathSetHash = succIndi->getConceptVariableBindingPathSetHash(true);
CVariableBindingPathSet* succVarBindingPathSet = succConVarBindingPathSetHash->getVariableBindingPathSet(opConcept,true);
if (propagateFreshVariableBindingsToSuccessor(processIndi,succIndi,conDes,succVarBindingPathSet,prevVarBindingPathSet,restLink, succConVarBindingPathSetHash,calcAlgContext)) {
setIndividualNodeConceptLabelSetModified(succIndi,calcAlgContext);
CConceptProcessingQueue* conProQueue = succIndi->getConceptProcessingQueue(true);;
cint64 bindingCount = succVarBindingPathSet->getVariableBindingPathMap()->count();
addConceptPreprocessedToProcessingQueue(bindingConDes,bindingDepTrackPoint,conProQueue,succIndi,true,calcAlgContext);
if (!reapplyQueue->isEmpty()) {
conSet = succIndi->getReapplyConceptLabelSet(true);
CCondensedReapplyQueueIterator reapplyQueueIt(conSet->getConceptReapplyIterator(bindingConDes));
applyReapplyQueueConcepts(succIndi,&reapplyQueueIt,calcAlgContext);
}
continuePropagation = true;
}
}
}
if (continuePropagation) {
addIndividualToProcessingQueue(succIndi,calcAlgContext);
}
}
bool CCalculationTableauCompletionTaskHandleAlgorithm::propagateInitialVariableBindingsToSuccessor(CIndividualProcessNode*& processIndi, CIndividualProcessNode* succIndi, CConceptDescriptor* conDes, CVariableBindingPathSet* newVarBindingPathSet, CVariableBindingPathSet* prevVarBindingPathSet, CIndividualLinkEdge* restLink, CConceptVariableBindingPathSetHash* conVarBindingSetHash, CCalculationAlgorithmContextBase* calcAlgContext) {
CMemoryAllocationManager* taskMemMan = calcAlgContext->getUsedProcessTaskMemoryAllocationManager();
bool propagations = false;
CVariableBindingPathDescriptor* newVarBindPathDesLinker = nullptr;
if (prevVarBindingPathSet) {
newVarBindingPathSet->copyVariableBindingPaths(prevVarBindingPathSet->getVariableBindingPathMap());
CVariableBindingPathMap* varBindPathMap = newVarBindingPathSet->getVariableBindingPathMap();
for (CVariableBindingPathMap::iterator it = varBindPathMap->begin(), itEnd = varBindPathMap->end(); it != itEnd; ++it) {
STATINC(VARBINDPROPAGATEDCOUNT,calcAlgContext);
STATINC(VARBINDPROPAGATEDINITIALCOUNT,calcAlgContext);
++mStatVarBindingPropagateSuccCount;
++mStatVarBindingPropagateSuccInitialCount;
CVariableBindingPathMapData& varBindPathMapData = it.value();
CVariableBindingPathDescriptor* prevVarBindPathDes = varBindPathMapData.getVariableBindingPathDescriptor();
CVariableBindingPathDescriptor* newVarBindPathDes = CObjectAllocator::allocateAndConstruct(taskMemMan);
CDependencyTrackPoint* newDepTrackPoint = nullptr;
CPROPAGATEVARIABLEBINDINGSSUCCESSORDependencyNode* bindDepNode = createPROPAGATEVARIABLEBINDINGSSUCCESSORDependency(newDepTrackPoint,processIndi,conDes,prevVarBindPathDes->getDependencyTrackPoint(),restLink->getDependencyTrackPoint(),calcAlgContext);
newVarBindPathDes->initVariableBindingPathDescriptor(prevVarBindPathDes->getVariableBindingPath(),newDepTrackPoint);
varBindPathMapData.setVariableBindingPathDescriptor(newVarBindPathDes);
newVarBindPathDesLinker = newVarBindPathDes->append(newVarBindPathDesLinker);
propagations = true;
}
if (newVarBindPathDesLinker) {
newVarBindingPathSet->addVariableBindingPathDescriptorLinker(newVarBindPathDesLinker);
conVarBindingSetHash->setLastVariableBindingDescriptionLinker(newVarBindPathDesLinker);
}
}
return propagations;
}
bool CCalculationTableauCompletionTaskHandleAlgorithm::propagateFreshVariableBindingsToSuccessor(CIndividualProcessNode*& processIndi, CIndividualProcessNode* succIndi, CConceptDescriptor* conDes, CVariableBindingPathSet* newVarBindingPathSet, CVariableBindingPathSet* prevVarBindingPathSet, CIndividualLinkEdge* restLink, CConceptVariableBindingPathSetHash* conVarBindingSetHash, CCalculationAlgorithmContextBase* calcAlgContext) {
CMemoryAllocationManager* taskMemMan = calcAlgContext->getUsedProcessTaskMemoryAllocationManager();
bool propagations = false;
if (prevVarBindingPathSet) {
CVariableBindingPathMap* prevVarBindPathMap = prevVarBindingPathSet->getVariableBindingPathMap();
CVariableBindingPathMap* newVarBindPathMap = newVarBindingPathSet->getVariableBindingPathMap();
CVariableBindingPathMap::iterator itNew = newVarBindPathMap->begin();
CVariableBindingPathMap::const_iterator itPrev = prevVarBindPathMap->constBegin(), itPrevEnd = prevVarBindPathMap->constEnd();
CVariableBindingPathDescriptor* newVarBindPathDesLinker = nullptr;
while (itPrev != itPrevEnd) {
cint64 prevPropID = itPrev.key();
bool doPropagation = false;
if (itNew == newVarBindPathMap->end()) {
doPropagation = true;
} else {
cint64 newPropID = itNew.key();
if (newPropID < prevPropID) {
++itNew;
} else if (newPropID == prevPropID) {
++itNew;
++itPrev;
} else {
doPropagation = true;
}
}
if (doPropagation) {
STATINC(VARBINDPROPAGATEDCOUNT,calcAlgContext);
STATINC(VARBINDPROPAGATEDFRESHCOUNT,calcAlgContext);
++mStatVarBindingPropagateSuccCount;
++mStatVarBindingPropagateSuccFreshCount;
const CVariableBindingPathMapData& prevVarBindPathMapData = itPrev.value();
CVariableBindingPathDescriptor* prevVarBindPathDes = prevVarBindPathMapData.getVariableBindingPathDescriptor();
CVariableBindingPathDescriptor* newVarBindPathDes = CObjectAllocator::allocateAndConstruct(taskMemMan);
CDependencyTrackPoint* newDepTrackPoint = nullptr;
CPROPAGATEVARIABLEBINDINGSSUCCESSORDependencyNode* bindDepNode = createPROPAGATEVARIABLEBINDINGSSUCCESSORDependency(newDepTrackPoint,processIndi,conDes,prevVarBindPathDes->getDependencyTrackPoint(),restLink->getDependencyTrackPoint(),calcAlgContext);
CVariableBindingPath* varBindingPath = prevVarBindPathDes->getVariableBindingPath();
newVarBindPathDes->initVariableBindingPathDescriptor(varBindingPath,newDepTrackPoint);
itNew = newVarBindPathMap->insert(varBindingPath->getPropagationID(),CVariableBindingPathMapData(newVarBindPathDes));
newVarBindPathDesLinker = newVarBindPathDes->append(newVarBindPathDesLinker);
propagations = true;
}
}
if (newVarBindPathDesLinker) {
newVarBindingPathSet->addVariableBindingPathDescriptorLinker(newVarBindPathDesLinker);
conVarBindingSetHash->setLastVariableBindingDescriptionLinker(newVarBindPathDesLinker);
}
}
return propagations;
}
void CCalculationTableauCompletionTaskHandleAlgorithm::applyVARBINDPROPAGATEALLRule(CIndividualProcessNode*& processIndi, CConceptProcessDescriptor*& conProDes, bool negate, CCalculationAlgorithmContextBase* calcAlgContext) {
CConceptDescriptor* conDes = conProDes->getConceptDescriptor();
CConcept* concept = conDes->getConcept();
CRole* role = concept->getRole();
CDependencyTrackPoint* depTrackPoint = conProDes->getDependencyTrackPoint();
cint64 opCount = concept->getOperandCount();
CSortedNegLinker* opLinker = concept->getOperandList();
CMemoryAllocationManager* taskMemMan = calcAlgContext->getUsedProcessTaskMemoryAllocationManager();
CSortedNegLinker* conceptOpLinker = concept->getOperandList();
STATINC(VARBINDRULEALLAPPLICATIONCOUNT,calcAlgContext);
CIndividualLinkEdge* restLink = getLinkProcessingRestriction(conProDes);
if (restLink) {
CIndividualProcessNode* succIndi = getSuccessorIndividual(processIndi,restLink,calcAlgContext);
propagateVariableBindingsToSuccessor(processIndi,succIndi,opLinker,negate,conDes,restLink,calcAlgContext);
} else {
CReapplyRoleSuccessorHash* roleSuccHash = processIndi->getReapplyRoleSuccessorHash(false);
if (roleSuccHash) {
CRoleSuccessorLinkIterator roleSuccIt = roleSuccHash->getRoleSuccessorLinkIterator(role);
while (roleSuccIt.hasNext()) {
CIndividualLinkEdge* link = roleSuccIt.next(true);
CIndividualProcessNode* succIndi = getSuccessorIndividual(processIndi,link,calcAlgContext);
propagateVariableBindingsToSuccessor(processIndi,succIndi,opLinker,negate,conDes,link,calcAlgContext);
}
}
}
if (!conProDes->isConceptReapplied()) {
if (!isConceptInReapplyQueue(conDes,role,processIndi,calcAlgContext)) {
addConceptToReapplyQueue(conDes,role,processIndi,true,depTrackPoint,calcAlgContext);
}
}
}
void CCalculationTableauCompletionTaskHandleAlgorithm::applyVARBINDVARIABLERule(CIndividualProcessNode*& processIndi, CConceptProcessDescriptor*& conProDes, bool negate, CCalculationAlgorithmContextBase* calcAlgContext) {
CConceptDescriptor* conDes = conProDes->getConceptDescriptor();
CConcept* concept = conDes->getConcept();
CVariable* variable = concept->getVariable();
bool conceptNegation = negate;
CDependencyTrackPoint* depTrackPoint = conProDes->getDependencyTrackPoint();
CSortedNegLinker* opConLinker = concept->getOperandList();
CConcept* bindingTriggerConcept = opConLinker->getData();
bool bindingTriggerConceptNegation = opConLinker->isNegated();
CProcessContext* processContext = calcAlgContext->getUsedProcessContext();
CProcessingDataBox* procDataBox = calcAlgContext->getUsedProcessingDataBox();
CMemoryAllocationManager* taskMemMan = calcAlgContext->getUsedProcessTaskMemoryAllocationManager();
CReapplyConceptLabelSet* conSet = processIndi->getReapplyConceptLabelSet(false);
CConceptDescriptor* bindingConDes = nullptr;
CDependencyTrackPoint* bindingDepTrackPoint = nullptr;
CCondensedReapplyQueue* reapplyQueue = nullptr;
STATINC(VARBINDRULEBINDAPPLICATIONCOUNT,calcAlgContext);
bool updateExt = false;
CConceptPropagationBindingSetHash* conPropBindingSetHash = processIndi->getConceptPropagationBindingSetHash(false);
if (conPropBindingSetHash) {
CPropagationBindingSet* propBindingSet = conPropBindingSetHash->getPropagationBindingSet(concept,false);
if (propBindingSet) {
CPropagationVariableBindingTransitionExtension* propVarBindTransExt = propBindingSet->getPropagationVariableBindingTransitionExtension(false);
if (!propVarBindTransExt || !propVarBindTransExt->isProcessingCompleted()) {
if (!propVarBindTransExt || propBindingSet->hasPropagateAllFlag()) {
updateExt = true;
} else {
CPropagationBindingDescriptor* lastAnalyPropBindDes = propVarBindTransExt->getLastAnalysedPropagationBindingDescriptor();
CPropagationBindingDescriptor* propBindDes = propBindingSet->getPropagationBindingDescriptorLinker();
if (lastAnalyPropBindDes != propBindDes) {
updateExt = true;
}
}
}
}
}
if (updateExt) {
if (!mFirstBindingCreationDebugWritten) {
mFirstBindingCreationDebugWritten = true;
if (mConfDebuggingWriteData) {
QString writingFolder = "./Debugging/CompletionTasks/";
QFile file(QString("%1%2-task.txt").arg(writingFolder, "first-binding-creation"));
mEndTaskDebugIndiModelString = generateExtendedDebugIndiModelStringList(calcAlgContext);
if (file.open(QIODevice::WriteOnly)) {
file.write(mEndTaskDebugIndiModelString.replace("
", "\r\n").toLocal8Bit());
file.close();
}
}
}
CConceptPropagationBindingSetHash* conPropBindingSetHash = processIndi->getConceptPropagationBindingSetHash(true);
CPropagationBindingSet* propBindingSet = conPropBindingSetHash->getPropagationBindingSet(concept,true);
CPropagationVariableBindingTransitionExtension* propVarBindTransExt = propBindingSet->getPropagationVariableBindingTransitionExtension(true);
CPropagationBindingDescriptor* lastAnalyPropBindDes = propVarBindTransExt->getLastAnalysedPropagationBindingDescriptor();
CPropagationBindingDescriptor* propBindDes = propBindingSet->getPropagationBindingDescriptorLinker();
propVarBindTransExt->setTriggeredVariableIndividualPair(variable,processIndi);
bool createVarBinding = false;
createVarBinding = propBindingSet->hasPropagateAllFlag();
for (CPropagationBindingDescriptor* propBindDesIt = propBindDes; propBindDesIt != lastAnalyPropBindDes; propBindDesIt = propBindDesIt->getNext()) {
if (propVarBindTransExt->addAnalysedPropagationBindingDescriptorReturnMatched(propBindDesIt)) {
createVarBinding = true;
}
}
propVarBindTransExt->setLastAnalysedPropagationBindingDescriptor(propBindDes);
propVarBindTransExt->setLastAnalysedPropagateAllFlag(propBindingSet->hasPropagateAllFlag());
if (createVarBinding) {
++mStatVarBindingCreatedCount;
STATINC(VARBINDVARIABLEBINDCOUNT,calcAlgContext);
propVarBindTransExt->setProcessingCompleted(true);
CConceptVariableBindingPathSetHash* conVarBindingPathSetHash = processIndi->getConceptVariableBindingPathSetHash(true);
CVariableBindingPathSet* varBindPathSet = conVarBindingPathSetHash->getVariableBindingPathSet(bindingTriggerConcept,true);
CProcessingDataBox* processingDataBox = calcAlgContext->getUsedProcessingDataBox();
cint64 nextPathPropID = processingDataBox->getNextVariableBindingPathID(true);
CDependencyTrackPoint* nextDepTrackPoint = nullptr;
CVARBINDVARIABLEDependencyNode* bindDepNode = createVARBINDVARIABLEDependency(nextDepTrackPoint,processIndi,conDes, depTrackPoint,calcAlgContext);
if (!conSet->getConceptDescriptorAndReapplyQueue(bindingTriggerConcept,bindingConDes,bindingDepTrackPoint,reapplyQueue)) {
bindingConDes = addConceptToIndividualReturnConceptDescriptor(bindingTriggerConcept,bindingTriggerConceptNegation,processIndi,nextDepTrackPoint,false,false,calcAlgContext);
} else {
setIndividualNodeConceptLabelSetModified(processIndi,calcAlgContext);
CConceptProcessingQueue* conProQueue = processIndi->getConceptProcessingQueue(true);
addConceptPreprocessedToProcessingQueue(bindingConDes,bindingDepTrackPoint,conProQueue,processIndi,true,calcAlgContext);
if (!reapplyQueue->isEmpty()) {
conSet = processIndi->getReapplyConceptLabelSet(true);
CCondensedReapplyQueueIterator reapplyQueueIt(conSet->getConceptReapplyIterator(bindingConDes));
applyReapplyQueueConcepts(processIndi,&reapplyQueueIt,calcAlgContext);
}
}
varBindPathSet->setConceptDescriptor(bindingConDes);
CVariableBinding* varBinding = CObjectAllocator::allocateAndConstruct(taskMemMan);
varBinding->initVariableBinding(nextDepTrackPoint,processIndi,variable);
CVariableBindingDescriptor* varBindingDes = CObjectAllocator::allocateAndConstruct(taskMemMan);
varBindingDes->initVariableBindingDescriptor(varBinding);
CVariableBindingPath* varBindingPath = CObjectAllocator::allocateAndConstruct(taskMemMan);
varBindingPath->initVariableBindingPath(nextPathPropID,varBindingDes);
CVariableBindingPathDescriptor* varBindingPathDes = CObjectAllocator::allocateAndConstruct(taskMemMan);
varBindingPathDes->initVariableBindingPathDescriptor(varBindingPath,nextDepTrackPoint);
varBindPathSet->addVariableBindingPath(varBindingPathDes);
conVarBindingPathSetHash->setLastVariableBindingDescriptionLinker(varBindingPathDes);
}
}
}
void CCalculationTableauCompletionTaskHandleAlgorithm::applyVARBINDPROPAGATEJOINRule(CIndividualProcessNode*& processIndi, CConceptProcessDescriptor*& conProDes, bool negate, CCalculationAlgorithmContextBase* calcAlgContext) {
CConceptDescriptor* conDes = conProDes->getConceptDescriptor();
CConcept* concept = conDes->getConcept();
CDependencyTrackPoint* depTrackPoint = conProDes->getDependencyTrackPoint();
cint64 opCount = concept->getOperandCount();
CSortedNegLinker* opLinker = concept->getOperandList();
CMemoryAllocationManager* taskMemMan = calcAlgContext->getUsedProcessTaskMemoryAllocationManager();
CReapplyConceptLabelSet* conSet = processIndi->getReapplyConceptLabelSet(false);
CConceptDescriptor* joinConDes = nullptr;
CDependencyTrackPoint* joinDepTrackPoint = nullptr;
CCondensedReapplyQueue* reapplyQueue = nullptr;
CConcept* joinConcept = opLinker->getData();
bool joinConceptNegation = opLinker->isNegated();
CSortedNegLinker* triggerLinker = opLinker->getNext();
CSortedLinker* varLinker = concept->getVariableLinker();
STATINC(VARBINDRULEJOINAPPLICATIONCOUNT,calcAlgContext);
bool propagateJoins = false;
bool createJoinConcept = false;
if (!conSet->getConceptDescriptorAndReapplyQueue(joinConcept,joinConDes,joinDepTrackPoint,reapplyQueue)) {
// search next not existing trigger
bool allTriggersAvailable = true;
conSet = processIndi->getReapplyConceptLabelSet(true);
CSortedNegLinker* triggerLinkerIt = nullptr;
for (triggerLinkerIt = triggerLinker; triggerLinkerIt && allTriggersAvailable; triggerLinkerIt = triggerLinkerIt->getNext()) {
CSortedNegLinker* nextTrigger = triggerLinkerIt;
CConcept* triggerConcept = nextTrigger->getData();
CConceptDescriptor* triggerConDes = nullptr;
CDependencyTrackPoint* triggerDepTrackPoint = nullptr;
if (conSet->getConceptDescriptor(triggerConcept,triggerConDes,triggerDepTrackPoint)) {
if (triggerConDes->isNegated() == nextTrigger->isNegated()) {
return;
}
} else {
allTriggersAvailable = false;
break;
}
}
if (!allTriggersAvailable) {
// install to trigger
CSortedNegLinker* nextTrigger = triggerLinkerIt;
CConcept* triggerConcept = nextTrigger->getData();
bool triggerNegation = !nextTrigger->isNegated();
if (!isConceptInReapplyQueue(conDes,triggerConcept,triggerNegation,processIndi,calcAlgContext)) {
addConceptToReapplyQueue(conDes,triggerConcept,triggerNegation,processIndi,(CProcessingRestrictionSpecification*)nullptr,depTrackPoint,calcAlgContext);
}
} else {
propagateJoins = true;
createJoinConcept = true;
}
} else {
propagateJoins = true;
}
//mEndTaskDebugIndiModelString = generateExtendedDebugIndiModelStringList(calcAlgContext);
bool propagationsDone = false;
if (propagateJoins) {
for (CSortedNegLinker* triggerLinkerIt = triggerLinker; triggerLinkerIt; triggerLinkerIt = triggerLinkerIt->getNext()) {
CSortedNegLinker* nextTrigger = triggerLinkerIt;
CConcept* triggerConcept = nextTrigger->getData();
if (!isConceptInReapplyQueue(conDes,triggerConcept,false,processIndi,calcAlgContext)) {
addConceptToReapplyQueue(conDes,triggerConcept,false,processIndi,(CProcessingRestrictionSpecification*)nullptr,depTrackPoint,calcAlgContext);
}
}
CConceptPropagationBindingSetHash* conPropBindingSetHash = processIndi->getConceptPropagationBindingSetHash(false);
CConceptVariableBindingPathSetHash* varBindingPathSetHash = processIndi->getConceptVariableBindingPathSetHash(false);
CPropagationBindingSet* propBindingSet = nullptr;
if (conPropBindingSetHash && varBindingPathSetHash) {
propBindingSet = conPropBindingSetHash->getPropagationBindingSet(concept,false);
if (propBindingSet) {
CPropagationVariableBindingTransitionExtension* propVarBindTransExt = propBindingSet->getPropagationVariableBindingTransitionExtension(false);
CSortedNegLinker