/*
* Copyright (C) 2013-2015, 2019 by the Konclude Developer Team.
*
* This file is part of the reasoning system Konclude.
* For details and support, see .
*
* Konclude is free software: you can redistribute it and/or modify
* it under the terms of version 3 of the GNU Lesser General Public
* License (LGPLv3) as published by the Free Software Foundation.
*
* Konclude is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU (Lesser) General Public License for more details.
*
* You should have received a copy of the GNU (Lesser) General Public
* License along with Konclude. If not, see .
*
*/
#include "CBranchingMergingProcessingRestrictionSpecification.h"
namespace Konclude {
namespace Reasoner {
namespace Kernel {
namespace Process {
CBranchingMergingProcessingRestrictionSpecification::CBranchingMergingProcessingRestrictionSpecification(CProcessContext* processContext) {
mProcessContext = processContext;
mDistinctMergedNodesSet = nullptr;
mMergingNodesLinker = nullptr;
mNominalMergingNodesLinker = nullptr;
mMergingInitNodesLinker = nullptr;
mOnlyPosQualifyNodesLinker = nullptr;
mOnlyNegQualifyNodesLinker = nullptr;
mBothQualifyNodesLinker = nullptr;
mLastDistinctMergedNodesSet = nullptr;
mIndiLink = nullptr;
mRemainingLinkerMergingCandidateIndiNodeCount = 0;
mRemainingValidMergingCandidateIndiNodeCount = 0;
mDistinctSetFixed = false;
mHasMergingInitCandidates = false;
mRemainingNominalCreationCount = 0;
mAddedBlockablePredMergingNodeCandidate = false;
mAddedBlockablePredDepTrackPoint = nullptr;
mDependencyTrackPoint = nullptr;
mMergingDependencyNode = nullptr;
mInitMergingNodesClashes = nullptr;
mMultipleInitMergingNodesClashes = nullptr;
mDistinctSetNodeRelocated = false;
mSuccChoiceTriggeringInstalled = false;
mSuccChoiceTriggeringInstalledCount = 0;
mLastCheckedSuccChoiceTriggerLinker = nullptr;
//mList.clear();
//mList.append(QString(""));
//mList.append(QString(""));
//mList.append(QString(""));
}
CBranchingMergingProcessingRestrictionSpecification* CBranchingMergingProcessingRestrictionSpecification::initBranchingMergingProcessingRestriction(CBranchingMergingProcessingRestrictionSpecification* prevRest) {
CProcessingRestrictionSpecification::initProcessingRestriction(prevRest);
if (prevRest) {
mDistinctMergedNodesSet = nullptr;
mLastDistinctMergedNodesSet = nullptr;
if (prevRest->mLastDistinctMergedNodesSet) {
mLastDistinctMergedNodesSet = prevRest->mLastDistinctMergedNodesSet;
}
mNominalMergingNodesLinker = prevRest->mNominalMergingNodesLinker;
mMergingNodesLinker = prevRest->mMergingNodesLinker;
mMergingInitNodesLinker = prevRest->mMergingInitNodesLinker;
mOnlyPosQualifyNodesLinker = prevRest->mOnlyPosQualifyNodesLinker;
mOnlyNegQualifyNodesLinker = prevRest->mOnlyNegQualifyNodesLinker;
mBothQualifyNodesLinker = prevRest->mBothQualifyNodesLinker;
mIndiLink = prevRest->mIndiLink;
mRemainingLinkerMergingCandidateIndiNodeCount = prevRest->mRemainingLinkerMergingCandidateIndiNodeCount;
mRemainingValidMergingCandidateIndiNodeCount = prevRest->mRemainingValidMergingCandidateIndiNodeCount;
mDistinctSetFixed = prevRest->mDistinctSetFixed;
mHasMergingInitCandidates = prevRest->mHasMergingInitCandidates;
mRemainingNominalCreationCount = prevRest->mRemainingNominalCreationCount;
mAddedBlockablePredMergingNodeCandidate = prevRest->mAddedBlockablePredMergingNodeCandidate;
mAddedBlockablePredDepTrackPoint = prevRest->mAddedBlockablePredDepTrackPoint;
mDependencyTrackPoint = prevRest->mDependencyTrackPoint;
mMergingDependencyNode = prevRest->mMergingDependencyNode;
mInitMergingNodesClashes = prevRest->mInitMergingNodesClashes;
mMultipleInitMergingNodesClashes = prevRest->mMultipleInitMergingNodesClashes;
mDistinctSetNodeRelocated = prevRest->mDistinctSetNodeRelocated;
mSuccChoiceTriggeringInstalled = prevRest->mSuccChoiceTriggeringInstalled;
mSuccChoiceTriggeringInstalledCount = prevRest->mSuccChoiceTriggeringInstalledCount;
mLastCheckedSuccChoiceTriggerLinker = prevRest->mLastCheckedSuccChoiceTriggerLinker;
//mList = prevRest->mList;
} else {
mLastCheckedSuccChoiceTriggerLinker = nullptr;
mSuccChoiceTriggeringInstalledCount = 0;
mSuccChoiceTriggeringInstalled = false;
mDistinctSetNodeRelocated = false;
mDistinctMergedNodesSet = nullptr;
mMergingNodesLinker = nullptr;
mNominalMergingNodesLinker = nullptr;
mMergingInitNodesLinker = nullptr;
mOnlyPosQualifyNodesLinker = nullptr;
mOnlyNegQualifyNodesLinker = nullptr;
mBothQualifyNodesLinker = nullptr;
mIndiLink = nullptr;
mRemainingLinkerMergingCandidateIndiNodeCount = 0;
mRemainingValidMergingCandidateIndiNodeCount = 0;
mDistinctSetFixed = false;
mHasMergingInitCandidates = false;
mRemainingNominalCreationCount = 0;
mAddedBlockablePredMergingNodeCandidate = false;
mAddedBlockablePredDepTrackPoint = nullptr;
mDependencyTrackPoint = nullptr;
mMergingDependencyNode = nullptr;
mInitMergingNodesClashes = nullptr;
mMultipleInitMergingNodesClashes = nullptr;
}
return this;
}
CPROCESSSET* CBranchingMergingProcessingRestrictionSpecification::getDistinctMergedNodesSet(bool create) {
if (!mDistinctMergedNodesSet && create) {
createLocalizedDistinctMergedNodeSet();
}
return mLastDistinctMergedNodesSet;
}
CPROCESSSET* CBranchingMergingProcessingRestrictionSpecification::createLocalizedDistinctMergedNodeSet() {
if (!mDistinctMergedNodesSet) {
mDistinctMergedNodesSet = CObjectParameterizingAllocator< CPROCESSSET,CContext* >::allocateAndConstructAndParameterize(mProcessContext->getUsedMemoryAllocationManager(),mProcessContext);
if (mLastDistinctMergedNodesSet) {
*mDistinctMergedNodesSet = *mLastDistinctMergedNodesSet;
}
mLastDistinctMergedNodesSet = mDistinctMergedNodesSet;
}
return mLastDistinctMergedNodesSet;
}
CBranchingMergingProcessingRestrictionSpecification* CBranchingMergingProcessingRestrictionSpecification::addDistinctMergedNode(cint64 mergedIndiNode) {
createLocalizedDistinctMergedNodeSet()->insert(mergedIndiNode);
return this;
}
CBranchingMergingProcessingRestrictionSpecification* CBranchingMergingProcessingRestrictionSpecification::removeDistinctMergedNode(cint64 mergedIndiNode) {
createLocalizedDistinctMergedNodeSet()->remove(mergedIndiNode);
return this;
}
CBranchingMergingIndividualNodeCandidateLinker* CBranchingMergingProcessingRestrictionSpecification::getMergingCandidateNodeLinker() {
return mMergingNodesLinker;
}
CBranchingMergingIndividualNodeCandidateLinker* CBranchingMergingProcessingRestrictionSpecification::takeNextMergingCandidateNodeLinker() {
CBranchingMergingIndividualNodeCandidateLinker* tmpMergingNodeLinker = nullptr;
tmpMergingNodeLinker = takeNextMergingInitializationCandidateNodeLinker();
if (!tmpMergingNodeLinker) {
tmpMergingNodeLinker = mNominalMergingNodesLinker;
if (mNominalMergingNodesLinker) {
--mRemainingLinkerMergingCandidateIndiNodeCount;
--mRemainingValidMergingCandidateIndiNodeCount;
mNominalMergingNodesLinker = mNominalMergingNodesLinker->getNext();
}
if (!tmpMergingNodeLinker) {
tmpMergingNodeLinker = mMergingNodesLinker;
if (mMergingNodesLinker) {
--mRemainingLinkerMergingCandidateIndiNodeCount;
--mRemainingValidMergingCandidateIndiNodeCount;
mMergingNodesLinker = mMergingNodesLinker->getNext();
}
}
}
return tmpMergingNodeLinker;
}
CBranchingMergingProcessingRestrictionSpecification* CBranchingMergingProcessingRestrictionSpecification::addMergingCandidateNodeLinker(CBranchingMergingIndividualNodeCandidateLinker* linker) {
while (linker) {
CBranchingMergingIndividualNodeCandidateLinker* linkerIt = linker;
linker = linker->getNext();
linkerIt->clearNext();
if (!mAddedBlockablePredMergingNodeCandidate && linkerIt->isCandidateBlockableAndCreator()) {
mAddedBlockablePredDepTrackPoint = linkerIt->getMergingIndividualLink()->getDependencyTrackPoint();
mAddedBlockablePredMergingNodeCandidate = true;
}
++mRemainingLinkerMergingCandidateIndiNodeCount;
++mRemainingValidMergingCandidateIndiNodeCount;
if (linkerIt->getMergingIndividualNodeCandidate()->isNominalIndividualNode()) {
mNominalMergingNodesLinker = linkerIt->append(mNominalMergingNodesLinker);
} else {
mMergingNodesLinker = linkerIt->append(mMergingNodesLinker);
}
}
return this;
}
CBranchingMergingIndividualNodeCandidateLinker* CBranchingMergingProcessingRestrictionSpecification::getMergingInitializationCandidateNodeLinker() {
return mMergingInitNodesLinker;
}
CBranchingMergingIndividualNodeCandidateLinker* CBranchingMergingProcessingRestrictionSpecification::takeNextMergingInitializationCandidateNodeLinker() {
CBranchingMergingIndividualNodeCandidateLinker* tmpMergingNodeLinker = nullptr;
tmpMergingNodeLinker = mMergingInitNodesLinker;
if (mMergingInitNodesLinker) {
--mRemainingLinkerMergingCandidateIndiNodeCount;
--mRemainingValidMergingCandidateIndiNodeCount;
mMergingInitNodesLinker = mMergingInitNodesLinker->getNext();
}
return tmpMergingNodeLinker;
}
CBranchingMergingProcessingRestrictionSpecification* CBranchingMergingProcessingRestrictionSpecification::addMergingInitializationCandidateNodeLinker(CBranchingMergingIndividualNodeCandidateLinker* linker) {
if (linker) {
mHasMergingInitCandidates = true;
CBranchingMergingIndividualNodeCandidateLinker* linkerIt = linker;
while (linkerIt) {
if (!mAddedBlockablePredMergingNodeCandidate && linkerIt->isCandidateBlockableAndCreator()) {
mAddedBlockablePredDepTrackPoint = linkerIt->getMergingIndividualLink()->getDependencyTrackPoint();
mAddedBlockablePredMergingNodeCandidate = true;
}
++mRemainingLinkerMergingCandidateIndiNodeCount;
++mRemainingValidMergingCandidateIndiNodeCount;
linkerIt = linkerIt->getNext();
}
mMergingInitNodesLinker = linker->append(mMergingInitNodesLinker);
}
return this;
}
CBranchingMergingIndividualNodeCandidateLinker* CBranchingMergingProcessingRestrictionSpecification::getOnlyPosQualifyCandidateNodeLinker() {
return mOnlyPosQualifyNodesLinker;
}
CBranchingMergingProcessingRestrictionSpecification* CBranchingMergingProcessingRestrictionSpecification::addOnlyPosQualifyCandidateNodeLinker(CBranchingMergingIndividualNodeCandidateLinker* linker) {
if (linker) {
mOnlyPosQualifyNodesLinker = linker->append(mOnlyPosQualifyNodesLinker);
}
return this;
}
CBranchingMergingProcessingRestrictionSpecification* CBranchingMergingProcessingRestrictionSpecification::clearOnlyPosQualifyCandidateNodeLinker() {
mOnlyPosQualifyNodesLinker = nullptr;
return this;
}
CBranchingMergingIndividualNodeCandidateLinker* CBranchingMergingProcessingRestrictionSpecification::getOnlyNegQualifyCandidateNodeLinker() {
return mOnlyNegQualifyNodesLinker;
}
CBranchingMergingProcessingRestrictionSpecification* CBranchingMergingProcessingRestrictionSpecification::addOnlyNegQualifyCandidateNodeLinker(CBranchingMergingIndividualNodeCandidateLinker* linker) {
if (linker) {
mOnlyNegQualifyNodesLinker = linker->append(mOnlyNegQualifyNodesLinker);
}
return this;
}
CBranchingMergingProcessingRestrictionSpecification* CBranchingMergingProcessingRestrictionSpecification::clearOnlyNegQualifyCandidateNodeLinker() {
mOnlyNegQualifyNodesLinker = nullptr;
return this;
}
CBranchingMergingIndividualNodeCandidateLinker* CBranchingMergingProcessingRestrictionSpecification::getBothQualifyCandidateNodeLinker() {
return mBothQualifyNodesLinker;
}
CBranchingMergingProcessingRestrictionSpecification* CBranchingMergingProcessingRestrictionSpecification::addBothQualifyCandidateNodeLinker(CBranchingMergingIndividualNodeCandidateLinker* linker) {
if (linker) {
mBothQualifyNodesLinker = linker->append(mBothQualifyNodesLinker);
}
return this;
}
CBranchingMergingProcessingRestrictionSpecification* CBranchingMergingProcessingRestrictionSpecification::setBothQualifyCandidateNodeLinker(CBranchingMergingIndividualNodeCandidateLinker* linker) {
mBothQualifyNodesLinker = linker;
return this;
}
cint64 CBranchingMergingProcessingRestrictionSpecification::getRemainingLinkerMergingCandidateIndividualNodeCount() {
return mRemainingLinkerMergingCandidateIndiNodeCount;
}
CBranchingMergingProcessingRestrictionSpecification* CBranchingMergingProcessingRestrictionSpecification::setRemainingLinkerMergingCandidateIndividualNodeCount(cint64 remainingCanidateCount) {
mRemainingLinkerMergingCandidateIndiNodeCount = remainingCanidateCount;
return this;
}
CIndividualLinkEdge* CBranchingMergingProcessingRestrictionSpecification::getLastIndividualLink() {
return mIndiLink;
}
CBranchingMergingProcessingRestrictionSpecification* CBranchingMergingProcessingRestrictionSpecification::setLastIndividualLink(CIndividualLinkEdge* indiLink) {
mIndiLink = indiLink;
return this;
}
cint64 CBranchingMergingProcessingRestrictionSpecification::getRemainingValidMergingCandidateIndividualNodeCount() {
return mRemainingValidMergingCandidateIndiNodeCount;
}
CBranchingMergingProcessingRestrictionSpecification* CBranchingMergingProcessingRestrictionSpecification::setRemainingValidMergingCandidateIndividualNodeCount(cint64 remainingCanidateCount) {
mRemainingValidMergingCandidateIndiNodeCount = remainingCanidateCount;
return this;
}
CBranchingMergingProcessingRestrictionSpecification* CBranchingMergingProcessingRestrictionSpecification::incRemainingValidMergingCandidateIndividualNodeCount() {
++mRemainingValidMergingCandidateIndiNodeCount;
return this;
}
bool CBranchingMergingProcessingRestrictionSpecification::hasValidRemainingMergingCandidates() {
return mRemainingValidMergingCandidateIndiNodeCount == mRemainingLinkerMergingCandidateIndiNodeCount;
}
bool CBranchingMergingProcessingRestrictionSpecification::hasRemainingMergingCandidates() {
return mNominalMergingNodesLinker != nullptr || mMergingNodesLinker != nullptr || mMergingInitNodesLinker != nullptr;
}
bool CBranchingMergingProcessingRestrictionSpecification::hasMergingInitializationCandidates() {
return mHasMergingInitCandidates;
}
bool CBranchingMergingProcessingRestrictionSpecification::hasRemainingMergingInitializationCandidates() {
return mMergingInitNodesLinker != nullptr;
}
CBranchingMergingProcessingRestrictionSpecification* CBranchingMergingProcessingRestrictionSpecification::setDistinctSetFixed(bool fixed) {
mDistinctSetFixed = fixed;
return this;
}
bool CBranchingMergingProcessingRestrictionSpecification::isDistinctSetFixed() {
return mDistinctSetFixed;
}
CBranchingMergingProcessingRestrictionSpecification* CBranchingMergingProcessingRestrictionSpecification::setRemainingNominalCreationCount(cint64 nomCount) {
mRemainingNominalCreationCount = nomCount;
return this;
}
CBranchingMergingProcessingRestrictionSpecification* CBranchingMergingProcessingRestrictionSpecification::decRemainingNominalCreationCount(cint64 decCount) {
mRemainingNominalCreationCount -= decCount;
return this;
}
cint64 CBranchingMergingProcessingRestrictionSpecification::getRemainingNominalCreationCount() {
return mRemainingNominalCreationCount;
}
bool CBranchingMergingProcessingRestrictionSpecification::hasAddedBlockablePredecessorMergingNodeCandidate() {
return mAddedBlockablePredMergingNodeCandidate;
}
CDependencyTrackPoint* CBranchingMergingProcessingRestrictionSpecification::getAddedBlockablePredecessorDependencyTrackPoint() {
return mAddedBlockablePredDepTrackPoint;
}
CBranchingMergingProcessingRestrictionSpecification* CBranchingMergingProcessingRestrictionSpecification::initMergingDependencyNode(CNonDeterministicDependencyNode* depNode) {
mMergingDependencyNode = depNode;
return this;
}
CNonDeterministicDependencyNode* CBranchingMergingProcessingRestrictionSpecification::getMergingDependencyNode() {
return mMergingDependencyNode;
}
CBranchingMergingProcessingRestrictionSpecification* CBranchingMergingProcessingRestrictionSpecification::setMergingNodesInitializationClashesDescriptors(CClashedDependencyDescriptor* clashes) {
mInitMergingNodesClashes = clashes;
return this;
}
CClashedDependencyDescriptor* CBranchingMergingProcessingRestrictionSpecification::getMergingNodesInitializationClashesDescriptors() {
return mInitMergingNodesClashes;
}
CBranchingMergingProcessingRestrictionSpecification* CBranchingMergingProcessingRestrictionSpecification::setMultipleMergingNodesInitializationClashesDescriptors(CClashedDependencyDescriptor* clashes) {
mMultipleInitMergingNodesClashes = clashes;
return this;
}
CClashedDependencyDescriptor* CBranchingMergingProcessingRestrictionSpecification::getMultipleMergingNodesInitializationClashesDescriptors() {
return mMultipleInitMergingNodesClashes;
}
bool CBranchingMergingProcessingRestrictionSpecification::isDistinctSetNodeRelocated() {
return mDistinctSetNodeRelocated;
}
CBranchingMergingProcessingRestrictionSpecification* CBranchingMergingProcessingRestrictionSpecification::setDistinctSetNodeRelocated(bool distinctSetNodeRelocated) {
mDistinctSetNodeRelocated = distinctSetNodeRelocated;
return this;
}
bool CBranchingMergingProcessingRestrictionSpecification::hasSuccessorChoiceTriggeringInstalled() {
return mSuccChoiceTriggeringInstalled;
}
CBranchingMergingProcessingRestrictionSpecification* CBranchingMergingProcessingRestrictionSpecification::setSuccessorChoiceTriggeringInstalled(bool succChoiceTriggeringInstalled) {
mSuccChoiceTriggeringInstalled = succChoiceTriggeringInstalled;
return this;
}
cint64 CBranchingMergingProcessingRestrictionSpecification::getSuccessorChoiceTriggeringInstalledCount() {
return mSuccChoiceTriggeringInstalledCount;
}
CBranchingMergingProcessingRestrictionSpecification* CBranchingMergingProcessingRestrictionSpecification::incSuccessorChoiceTriggeringInstalledCount(cint64 count) {
mSuccChoiceTriggeringInstalledCount += count;
return this;
}
CBranchingMergingProcessingRestrictionSpecification* CBranchingMergingProcessingRestrictionSpecification::decSuccessorChoiceTriggeringInstalledCount(cint64 count) {
mSuccChoiceTriggeringInstalledCount -= count;
return this;
}
CXLinker* CBranchingMergingProcessingRestrictionSpecification::getLastCheckedSuccessorChoiceTriggerLinker() {
return mLastCheckedSuccChoiceTriggerLinker;
}
CBranchingMergingProcessingRestrictionSpecification* CBranchingMergingProcessingRestrictionSpecification::setLastCheckedSuccessorChoiceTriggerLinker(CXLinker* indiLinker) {
mLastCheckedSuccChoiceTriggerLinker = indiLinker;
return this;
}
//bool CBranchingMergingProcessingRestrictionSpecification::addIndividualToContainer(cint64 container, cint64 individual) {
// QString insertString;
// --container;
// if (mList.size() > container) {
// insertString = mList.value(container);
// insertString += QString(" %1").arg(individual);
// mList.replace(container,insertString);
// } else {
// insertString += QString("%1").arg(individual);
// mList.insert(container,insertString);
// }
// return true;
//}
//void CBranchingMergingProcessingRestrictionSpecification::printIndividualContainer() {
// cout<<"\n"<