/*
* 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 "CDependencyNode.h"
namespace Konclude {
namespace Reasoner {
namespace Kernel {
namespace Process {
namespace Dependency {
CDependencyNode::CDependencyNode(CProcessContext* processContext) : CProcessingTag(processContext->getUsedProcessTagger()->getCurrentProcessingTagAndInc()) {
mProcessContext = processContext;
mDepNodeType = DNTUNDEFINED;
//mAdditionalAheadDepLinker = nullptr;
mAdditionalAfterDepLinker = nullptr;
}
CDependencyNode* CDependencyNode::initDependencyNode(DEPENDENCNODEYTYPE depType, CConceptDescriptor* conceptDescriptor) {
mConceptDescriptor = conceptDescriptor;
mDepNodeType = depType;
//mMarker = nullptr;
mIndividualNode = nullptr;
return this;
}
CDependencyNode* CDependencyNode::initDependencyNode(DEPENDENCNODEYTYPE depType, CIndividualProcessNode* individualNode, CConceptDescriptor* conceptDescriptor) {
initDependencyNode(depType,conceptDescriptor);
mIndividualNode = individualNode;
return this;
}
//CMarker* CDependencyNode::getMarker() {
// return mMarker;
//}
//CDependencyNode* CDependencyNode::setMarker(CMarker* depMarker) {
// mMarker = depMarker;
// return this;
//}
//
//CDependencyNode* CDependencyNode::addMarker(CMarker* depMarker) {
// if (!mMarker) {
// mMarker = depMarker;
// } else {
// mMarker = depMarker->append(mMarker);
// }
// return this;
//}
bool CDependencyNode::isNonDeterministiDependencyNode() {
return !isDeterministiDependencyNode();
}
CConceptDescriptor* CDependencyNode::getConceptDescriptor() {
return mConceptDescriptor;
}
CDependencyNode* CDependencyNode::setConceptDescriptor(CConceptDescriptor* conceptDescriptor) {
mConceptDescriptor = conceptDescriptor;
return this;
}
CDependencyTrackPoint* CDependencyNode::getPreviousDependencyTrackPoint() {
return mDepTrackPoint;
}
CDependencyIterator CDependencyNode::getAdditionalDependencyIterator(bool aheadDependencies, bool afterDependencies) {
return CDependencyIterator(/*aheadDependencies?mAdditionalAheadDepLinker:*/nullptr, afterDependencies?mAdditionalAfterDepLinker:nullptr);
}
//CDependency* CDependencyNode::getAdditionalAheadDependencies() {
// return mAdditionalAheadDepLinker;
//}
CDependency* CDependencyNode::getAdditionalAfterDependencies() {
return mAdditionalAfterDepLinker;
}
cint64 CDependencyNode::getAdditionalDependencyCount() {
cint64 depCount = 0;
//if (mAdditionalAheadDepLinker) {
// depCount += mAdditionalAheadDepLinker->getCount();
//}
if (mAdditionalAfterDepLinker) {
depCount += mAdditionalAfterDepLinker->getCount();
}
return depCount;
}
bool CDependencyNode::hasAdditionalDependencies() {
return /*mAdditionalAheadDepLinker || */mAdditionalAfterDepLinker;
}
//CDependencyNode* CDependencyNode::addAheadDependency(CDependency* conceptDependency) {
// mAdditionalAheadDepLinker = conceptDependency->append(mAdditionalAheadDepLinker);
// return this;
//}
CDependencyNode* CDependencyNode::addAfterDependency(CDependency* linkDependency) {
mAdditionalAfterDepLinker = linkDependency->append(mAdditionalAfterDepLinker);
return this;
}
cint64 CDependencyNode::getDependedBranchingTag() {
cint64 branchLevelTag = 0;
if (mDepTrackPoint) {
branchLevelTag = qMax(branchLevelTag,mDepTrackPoint->getBranchingTag());
}
//CDependency* conDepLinkerIt = mAdditionalAheadDepLinker;
//while (conDepLinkerIt && branchLevelTag >= 0) {
// CDependencyTrackPoint* trackPoint = conDepLinkerIt->getPreviousDependencyTrackPoint();
// if (trackPoint) {
// branchLevelTag = qMax(branchLevelTag,trackPoint->getBranchingTag());
// } else {
// branchLevelTag = -1;
// }
// conDepLinkerIt = conDepLinkerIt->getNext();
//}
CDependency* linkDepLinkerIt = mAdditionalAfterDepLinker;
while (linkDepLinkerIt && branchLevelTag >= 0) {
CDependencyTrackPoint* trackPoint = linkDepLinkerIt->getPreviousDependencyTrackPoint();
if (trackPoint) {
branchLevelTag = qMax(branchLevelTag,trackPoint->getBranchingTag());
} else {
branchLevelTag = -1;
}
linkDepLinkerIt = linkDepLinkerIt->getNext();
}
return branchLevelTag;
}
cint64 CDependencyNode::getDependedBranchingLevel() {
return getDependedBranchingTag();
}
//bool CDependencyNode::hasAdditionalAheadDependencies() {
// return mAdditionalAheadDepLinker != nullptr;
//}
bool CDependencyNode::hasAdditionalAfterDependencies() {
return mAdditionalAfterDepLinker != nullptr;
}
bool CDependencyNode::hasDependencies() {
return /*mAdditionalAheadDepLinker || */mAdditionalAfterDepLinker || mDepTrackPoint;
}
cint64 CDependencyNode::getDependencyCount() {
cint64 depCount = 0;
if (mDepTrackPoint) {
depCount += 1;
}
depCount += getAdditionalDependencyCount();
return depCount;
}
CDependencyNode::DEPENDENCNODEYTYPE CDependencyNode::getDependencyType() {
return mDepNodeType;
}
bool CDependencyNode::isDependencyType(DEPENDENCNODEYTYPE depType) {
return mDepNodeType == depType;
}
bool CDependencyNode::isIndependentBaseDependencyType() {
return isDependencyType(DNTINDEPENDENTBASE);
}
bool CDependencyNode::isUndefinedDependencyType() {
return isDependencyType(DNTUNDEFINED);
}
CIndividualProcessNode* CDependencyNode::getAppropriateIndividualNode() {
return mIndividualNode;
}
bool CDependencyNode::hasAppropriateIndividualNode() {
return mIndividualNode != nullptr;
}
CDependencyNode* CDependencyNode::setAppropriateIndividualNode(CIndividualProcessNode* indiNode) {
mIndividualNode = indiNode;
return this;
}
bool CDependencyNode::updateDependencyTrackPointBranchingTag(CDependencyTrackPoint* depTrackPoint, cint64 branchinLevelTag) {
return depTrackPoint->addMaximumBranchingTagCandidate(branchinLevelTag);
}
bool CDependencyNode::isRepresentativeResolveDependencyNode() {
return false;
}
bool CDependencyNode::isRepresentativeSelectDependencyNode() {
return false;
}
}; // end namespace Dependency
}; // end namespace Process
}; // end namespace Kernel
}; // end namespace Reasoner
}; // end namespace Konclude