/*
* 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 "CTrackedClashedDependencyLine.h"
namespace Konclude {
namespace Reasoner {
namespace Kernel {
namespace Algorithm {
CTrackedClashedDependencyLine::CTrackedClashedDependencyLine(CPROCESSINGSET* clashedSet) {
mFreeTrackedClashedDescriptors = nullptr;
mClashedSet = clashedSet;
mInvolvedIndividualSet = nullptr;
}
CTrackedClashedDependencyLine* CTrackedClashedDependencyLine::initTrackedClashedDependencyLine(bool exactIndiNodeTracking, cint64 individualNodeTrackLevel, cint64 branchingLevel) {
mExactIndividualTracking = exactIndiNodeTracking;
mIndividualTrackLevel = individualNodeTrackLevel;
mBranchingLevel = branchingLevel;
mLevelTrackedClashes = nullptr;
mLevelTrackedBranchingClashes = nullptr;
mPrevLevelsTrackedClashes = nullptr;
mPrevLevelsTrackedNonDetClashes = nullptr;
mPrevLevelsTrackedNonDetBranchingClashes = nullptr;
mIndependentTrackedClashes = nullptr;
return this;
}
CTrackedClashedDependencyLine* CTrackedClashedDependencyLine::analyseInvolvedIndividuals(CTrackedClashedDescriptor* clashedDes) {
if (mInvolvedIndividualSet) {
for (CTrackedClashedDescriptor* clashedDesIt = clashedDes; clashedDes; clashedDes = clashedDes->getNextDescriptor()) {
CIndividualProcessNode* indiNode = clashedDesIt->getAppropriatedIndividual();
if (indiNode && indiNode->getNominalIndividual()) {
mInvolvedIndividualSet->insert(indiNode->getNominalIndividual()->getIndividualID());
}
}
}
return this;
}
CTrackedClashedDependencyLine* CTrackedClashedDependencyLine::addInvolvedIndividual(CIndividualProcessNode* indiNode) {
if (mInvolvedIndividualSet && indiNode && indiNode->getNominalIndividual()) {
mInvolvedIndividualSet->insert(indiNode->getNominalIndividual()->getIndividualID());
}
return this;
}
CTrackedClashedDependencyLine* CTrackedClashedDependencyLine::addInvolvedIndividual(cint64 indiId) {
if (mInvolvedIndividualSet) {
mInvolvedIndividualSet->insert(indiId);
}
return this;
}
CTrackedClashedDependencyLine* CTrackedClashedDependencyLine::sortInTrackedClashedDescriptors(CTrackedClashedDescriptor* clashedDes, bool forceInsertion) {
CTrackedClashedDescriptor* clashedDesIt = clashedDes;
while (clashedDesIt) {
CTrackedClashedDescriptor* clashedDesTmp = clashedDesIt;
clashedDesIt = clashedDesIt->getNextDescriptor();
clashedDesTmp->clearNext();
CTrackedClashedDescriptorHasher desHasher(clashedDesTmp);
bool clashDesInsertion = forceInsertion;
if (!mClashedSet->contains(desHasher)) {
mClashedSet->insert(desHasher);
clashDesInsertion = true;
}
if (clashDesInsertion) {
if (clashedDesTmp->isPointingToIndependentDependencyNode()) {
mIndependentTrackedClashes = clashedDesTmp->append(mIndependentTrackedClashes);
} else {
if (clashedDesTmp->getAppropriatedIndividualLevel() > mIndividualTrackLevel) {
// previous individual node level
if (clashedDesTmp->isPointingToNonDeterministicDependencyNode()) {
if (clashedDesTmp->getBranchingLevelTag() == mBranchingLevel) {
mPrevLevelsTrackedNonDetBranchingClashes = clashedDesTmp->append(mPrevLevelsTrackedNonDetBranchingClashes);
} else {
mPrevLevelsTrackedNonDetClashes = clashedDesTmp->append(mPrevLevelsTrackedNonDetClashes);
}
} else {
// deterministic, branching level does not matter
mPrevLevelsTrackedClashes = clashedDesTmp->append(mPrevLevelsTrackedClashes);
}
} else {
// current individual node level
if (clashedDesTmp->getBranchingLevelTag() == mBranchingLevel) {
mLevelTrackedBranchingClashes = clashedDesTmp->append(mLevelTrackedBranchingClashes);
} else {
mLevelTrackedClashes = clashedDesTmp->append(mLevelTrackedClashes);
}
}
}
} else {
addFreeTrackedClashedDescriptor(clashedDesTmp);
}
}
return this;
}
CTrackedClashedDependencyLine* CTrackedClashedDependencyLine::moveToNextIndividualNodeLevel(cint64 newLevel) {
mIndividualTrackLevel = newLevel;
//if (mLevelTrackedClashes) {
// mPrevLevelsTrackedClashes = mLevelTrackedClashes->append(mPrevLevelsTrackedClashes);
//}
CTrackedClashedDescriptor* levelTrackedClashes = mLevelTrackedClashes;
mLevelTrackedClashes = nullptr;
sortInTrackedClashedDescriptors(levelTrackedClashes,true);
CTrackedClashedDescriptor* levelTrackedBranchingClashes = mLevelTrackedBranchingClashes;
mLevelTrackedBranchingClashes = nullptr;
sortInTrackedClashedDescriptors(levelTrackedBranchingClashes,true);
return this;
}
bool CTrackedClashedDependencyLine::hasIndependentTrackedClashedDescriptors() {
return mIndependentTrackedClashes != nullptr;
}
CTrackedClashedDescriptor* CTrackedClashedDependencyLine::takeNextIndependentTrackedClashedDescriptor() {
CTrackedClashedDescriptor* clashedDesTmp = mIndependentTrackedClashes;
if (mIndependentTrackedClashes) {
mIndependentTrackedClashes = mIndependentTrackedClashes->getNextDescriptor();
clashedDesTmp->clearNext();
}
return clashedDesTmp;
}
CTrackedClashedDescriptor* CTrackedClashedDependencyLine::getIndependentTrackedClashedDescriptors() {
return mIndependentTrackedClashes;
}
bool CTrackedClashedDependencyLine::hasLevelTrackedClashedDescriptors() {
return mLevelTrackedClashes != nullptr;
}
CTrackedClashedDescriptor* CTrackedClashedDependencyLine::takeNextLevelTrackedClashedDescriptor() {
CTrackedClashedDescriptor* clashedDesTmp = mLevelTrackedClashes;
if (mLevelTrackedClashes) {
mLevelTrackedClashes = mLevelTrackedClashes->getNextDescriptor();
clashedDesTmp->clearNext();
}
return clashedDesTmp;
}
CTrackedClashedDescriptor* CTrackedClashedDependencyLine::getLevelTrackedClashedDescriptors() {
return mLevelTrackedClashes;
}
bool CTrackedClashedDependencyLine::hasLevelTrackedBranchingClashedDescriptors() {
return mLevelTrackedBranchingClashes != nullptr;
}
CTrackedClashedDescriptor* CTrackedClashedDependencyLine::takeNextLevelTrackedBranchingClashedDescriptor() {
CTrackedClashedDescriptor* clashedDesTmp = mLevelTrackedBranchingClashes;
if (mLevelTrackedBranchingClashes) {
mLevelTrackedBranchingClashes = mLevelTrackedBranchingClashes->getNextDescriptor();
clashedDesTmp->clearNext();
}
return clashedDesTmp;
}
CTrackedClashedDescriptor* CTrackedClashedDependencyLine::getLevelTrackedBranchingClashedDescriptors() {
return mLevelTrackedBranchingClashes;
}
bool CTrackedClashedDependencyLine::hasPerviousLevelTrackedClashedDescriptors() {
return mPrevLevelsTrackedClashes != nullptr;
}
CTrackedClashedDescriptor* CTrackedClashedDependencyLine::takeNextPerviousLevelTrackedClashedDescriptor() {
CTrackedClashedDescriptor* clashedDesTmp = mPrevLevelsTrackedClashes;
if (mPrevLevelsTrackedClashes) {
mPrevLevelsTrackedClashes = mPrevLevelsTrackedClashes->getNextDescriptor();
clashedDesTmp->clearNext();
}
return clashedDesTmp;
}
CTrackedClashedDescriptor* CTrackedClashedDependencyLine::getPerviousLevelTrackedClashedDescriptors() {
return mPrevLevelsTrackedClashes;
}
bool CTrackedClashedDependencyLine::hasPerviousLevelTrackedNonDeterministicClashedDescriptors() {
return mPrevLevelsTrackedNonDetClashes != nullptr;
}
CTrackedClashedDescriptor* CTrackedClashedDependencyLine::takeNextPerviousLevelTrackedNonDeterministicClashedDescriptor() {
CTrackedClashedDescriptor* clashedDesTmp = mPrevLevelsTrackedNonDetClashes;
if (mPrevLevelsTrackedNonDetClashes) {
mPrevLevelsTrackedNonDetClashes = mPrevLevelsTrackedNonDetClashes->getNextDescriptor();
clashedDesTmp->clearNext();
}
return clashedDesTmp;
}
CTrackedClashedDescriptor* CTrackedClashedDependencyLine::getPerviousLevelTrackedNonDeterministicClashedDescriptors() {
return mPrevLevelsTrackedNonDetClashes;
}
bool CTrackedClashedDependencyLine::hasPerviousLevelTrackedNonDeterministicBranchingClashedDescriptors() {
return mPrevLevelsTrackedNonDetBranchingClashes != nullptr;
}
CTrackedClashedDescriptor* CTrackedClashedDependencyLine::takeNextPerviousLevelTrackedNonDeterministicBranchingClashedDescriptor() {
CTrackedClashedDescriptor* clashedDesTmp = mPrevLevelsTrackedNonDetBranchingClashes;
if (mPrevLevelsTrackedNonDetBranchingClashes) {
mPrevLevelsTrackedNonDetBranchingClashes = mPrevLevelsTrackedNonDetBranchingClashes->getNextDescriptor();
clashedDesTmp->clearNext();
}
return clashedDesTmp;
}
CTrackedClashedDescriptor* CTrackedClashedDependencyLine::getPerviousLevelTrackedNonDeterministicBranchingClashedDescriptors() {
return mPrevLevelsTrackedNonDetBranchingClashes;
}
bool CTrackedClashedDependencyLine::hasMoreTrackedClashedList() {
return mLevelTrackedClashes || mLevelTrackedBranchingClashes || mPrevLevelsTrackedClashes || mPrevLevelsTrackedNonDetClashes || mPrevLevelsTrackedNonDetBranchingClashes || mIndependentTrackedClashes;
}
CTrackedClashedDescriptor* CTrackedClashedDependencyLine::takeNextTrackedClashedList() {
CTrackedClashedDescriptor* clashes = nullptr;
if (mLevelTrackedClashes) {
clashes = mLevelTrackedClashes;
mLevelTrackedClashes = nullptr;
} else if (mLevelTrackedBranchingClashes) {
clashes = mLevelTrackedBranchingClashes;
mLevelTrackedBranchingClashes = nullptr;
} else if (mPrevLevelsTrackedClashes) {
clashes = mPrevLevelsTrackedClashes;
mPrevLevelsTrackedClashes = nullptr;
} else if (mPrevLevelsTrackedNonDetClashes) {
clashes = mPrevLevelsTrackedNonDetClashes;
mPrevLevelsTrackedNonDetClashes = nullptr;
} else if (mPrevLevelsTrackedNonDetBranchingClashes) {
clashes = mPrevLevelsTrackedNonDetBranchingClashes;
mPrevLevelsTrackedNonDetBranchingClashes = nullptr;
} else if (mIndependentTrackedClashes) {
clashes = mIndependentTrackedClashes;
mIndependentTrackedClashes = nullptr;
}
return clashes;
}
CTrackedClashedDescriptor* CTrackedClashedDependencyLine::takeNextFreeTrackedClashedDescriptor() {
CTrackedClashedDescriptor* clashedDesTmp = mFreeTrackedClashedDescriptors;
if (mFreeTrackedClashedDescriptors) {
mFreeTrackedClashedDescriptors = mFreeTrackedClashedDescriptors->getNextDescriptor();
clashedDesTmp->clearNext();
}
return clashedDesTmp;
}
CTrackedClashedDependencyLine* CTrackedClashedDependencyLine::addFreeTrackedClashedDescriptor(CTrackedClashedDescriptor* clashDes) {
if (clashDes) {
mFreeTrackedClashedDescriptors = clashDes->append(mFreeTrackedClashedDescriptors);
}
return this;
}
CPROCESSINGSET* CTrackedClashedDependencyLine::getTrackedClashedDescriptorSet() {
return mClashedSet;
}
cint64 CTrackedClashedDependencyLine::getBranchingLevel() {
return mBranchingLevel;
}
cint64 CTrackedClashedDependencyLine::getIndividualNodeLevel() {
return mIndividualTrackLevel;
}
bool CTrackedClashedDependencyLine::hasOnlyIndependentTrackedClashedDescriptorsRemaining() {
return mIndependentTrackedClashes && !mLevelTrackedClashes && !mLevelTrackedBranchingClashes && !mPrevLevelsTrackedClashes && !mPrevLevelsTrackedNonDetClashes && !mPrevLevelsTrackedNonDetBranchingClashes;
}
bool CTrackedClashedDependencyLine::hasOnlyCurrentIndividualNodeLevelClashesDescriptors() {
return !mPrevLevelsTrackedClashes && !mPrevLevelsTrackedNonDetClashes && !mPrevLevelsTrackedNonDetBranchingClashes;
}
CTrackedClashedDependencyLine* CTrackedClashedDependencyLine::setInvolvedIndividualTrackingSet(CPROCESSINGSET* indiTrackingSet) {
mInvolvedIndividualSet = indiTrackingSet;
return this;
}
CPROCESSINGSET* CTrackedClashedDependencyLine::getInvolvedIndividualTrackingSet() {
return mInvolvedIndividualSet;
}
}; // end namespace Algorithm
}; // end namespace Kernel
}; // end namespace Reasoner
}; // end namespace Konclude