Debian Codegraph @

Source/Reasoner/Kernel/Process/Dependency/CDependencyNode.cpp

raw
1 /*
2 * Copyright (C) 2013-2015, 2019 by the Konclude Developer Team.
3 *
4 * This file is part of the reasoning system Konclude.
5 * For details and support, see <http://konclude.com/>.
6 *
7 * Konclude is free software: you can redistribute it and/or modify
8 * it under the terms of version 3 of the GNU Lesser General Public
9 * License (LGPLv3) as published by the Free Software Foundation.
10 *
11 * Konclude is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU (Lesser) General Public License for more details.
15 *
16 * You should have received a copy of the GNU (Lesser) General Public
17 * License along with Konclude. If not, see <http://www.gnu.org/licenses/>.
18 *
19 */
20
21 #include "CDependencyNode.h"
22
23
24 namespace Konclude {
25
26 namespace Reasoner {
27
28 namespace Kernel {
29
30 namespace Process {
31
32 namespace Dependency {
33
34
35 CDependencyNode::CDependencyNode(CProcessContext* processContext) : CProcessingTag(processContext->getUsedProcessTagger()->getCurrentProcessingTagAndInc()) {
36 mProcessContext = processContext;
37 mDepNodeType = DNTUNDEFINED;
38 //mAdditionalAheadDepLinker = nullptr;
39 mAdditionalAfterDepLinker = nullptr;
40 }
41
42
43
44 CDependencyNode* CDependencyNode::initDependencyNode(DEPENDENCNODEYTYPE depType, CConceptDescriptor* conceptDescriptor) {
45 mConceptDescriptor = conceptDescriptor;
46 mDepNodeType = depType;
47 //mMarker = nullptr;
48 mIndividualNode = nullptr;
49 return this;
50 }
51
52 CDependencyNode* CDependencyNode::initDependencyNode(DEPENDENCNODEYTYPE depType, CIndividualProcessNode* individualNode, CConceptDescriptor* conceptDescriptor) {
53 initDependencyNode(depType,conceptDescriptor);
54 mIndividualNode = individualNode;
55 return this;
56 }
57
58
59 //CMarker* CDependencyNode::getMarker() {
60 // return mMarker;
61 //}
62
63 //CDependencyNode* CDependencyNode::setMarker(CMarker* depMarker) {
64 // mMarker = depMarker;
65 // return this;
66 //}
67 //
68 //CDependencyNode* CDependencyNode::addMarker(CMarker* depMarker) {
69 // if (!mMarker) {
70 // mMarker = depMarker;
71 // } else {
72 // mMarker = depMarker->append(mMarker);
73 // }
74 // return this;
75 //}
76
77
78 bool CDependencyNode::isNonDeterministiDependencyNode() {
79 return !isDeterministiDependencyNode();
80 }
81
82
83
84 CConceptDescriptor* CDependencyNode::getConceptDescriptor() {
85 return mConceptDescriptor;
86 }
87
88 CDependencyNode* CDependencyNode::setConceptDescriptor(CConceptDescriptor* conceptDescriptor) {
89 mConceptDescriptor = conceptDescriptor;
90 return this;
91 }
92
93
94 CDependencyTrackPoint* CDependencyNode::getPreviousDependencyTrackPoint() {
95 return mDepTrackPoint;
96 }
97
98
99 CDependencyIterator CDependencyNode::getAdditionalDependencyIterator(bool aheadDependencies, bool afterDependencies) {
100 return CDependencyIterator(/*aheadDependencies?mAdditionalAheadDepLinker:*/nullptr, afterDependencies?mAdditionalAfterDepLinker:nullptr);
101 }
102
103
104 //CDependency* CDependencyNode::getAdditionalAheadDependencies() {
105 // return mAdditionalAheadDepLinker;
106 //}
107
108 CDependency* CDependencyNode::getAdditionalAfterDependencies() {
109 return mAdditionalAfterDepLinker;
110 }
111
112 cint64 CDependencyNode::getAdditionalDependencyCount() {
113 cint64 depCount = 0;
114 //if (mAdditionalAheadDepLinker) {
115 // depCount += mAdditionalAheadDepLinker->getCount();
116 //}
117 if (mAdditionalAfterDepLinker) {
118 depCount += mAdditionalAfterDepLinker->getCount();
119 }
120 return depCount;
121 }
122
123 bool CDependencyNode::hasAdditionalDependencies() {
124 return /*mAdditionalAheadDepLinker || */mAdditionalAfterDepLinker;
125 }
126
127
128 //CDependencyNode* CDependencyNode::addAheadDependency(CDependency* conceptDependency) {
129 // mAdditionalAheadDepLinker = conceptDependency->append(mAdditionalAheadDepLinker);
130 // return this;
131 //}
132
133 CDependencyNode* CDependencyNode::addAfterDependency(CDependency* linkDependency) {
134 mAdditionalAfterDepLinker = linkDependency->append(mAdditionalAfterDepLinker);
135 return this;
136 }
137
138
139 cint64 CDependencyNode::getDependedBranchingTag() {
140 cint64 branchLevelTag = 0;
141 if (mDepTrackPoint) {
142 branchLevelTag = qMax(branchLevelTag,mDepTrackPoint->getBranchingTag());
143 }
144 //CDependency* conDepLinkerIt = mAdditionalAheadDepLinker;
145 //while (conDepLinkerIt && branchLevelTag >= 0) {
146 // CDependencyTrackPoint* trackPoint = conDepLinkerIt->getPreviousDependencyTrackPoint();
147 // if (trackPoint) {
148 // branchLevelTag = qMax(branchLevelTag,trackPoint->getBranchingTag());
149 // } else {
150 // branchLevelTag = -1;
151 // }
152 // conDepLinkerIt = conDepLinkerIt->getNext();
153 //}
154 CDependency* linkDepLinkerIt = mAdditionalAfterDepLinker;
155 while (linkDepLinkerIt && branchLevelTag >= 0) {
156 CDependencyTrackPoint* trackPoint = linkDepLinkerIt->getPreviousDependencyTrackPoint();
157 if (trackPoint) {
158 branchLevelTag = qMax(branchLevelTag,trackPoint->getBranchingTag());
159 } else {
160 branchLevelTag = -1;
161 }
162 linkDepLinkerIt = linkDepLinkerIt->getNext();
163 }
164 return branchLevelTag;
165 }
166
167 cint64 CDependencyNode::getDependedBranchingLevel() {
168 return getDependedBranchingTag();
169 }
170
171
172 //bool CDependencyNode::hasAdditionalAheadDependencies() {
173 // return mAdditionalAheadDepLinker != nullptr;
174 //}
175
176 bool CDependencyNode::hasAdditionalAfterDependencies() {
177 return mAdditionalAfterDepLinker != nullptr;
178 }
179
180 bool CDependencyNode::hasDependencies() {
181 return /*mAdditionalAheadDepLinker || */mAdditionalAfterDepLinker || mDepTrackPoint;
182 }
183
184 cint64 CDependencyNode::getDependencyCount() {
185 cint64 depCount = 0;
186 if (mDepTrackPoint) {
187 depCount += 1;
188 }
189 depCount += getAdditionalDependencyCount();
190 return depCount;
191 }
192
193 CDependencyNode::DEPENDENCNODEYTYPE CDependencyNode::getDependencyType() {
194 return mDepNodeType;
195 }
196
197 bool CDependencyNode::isDependencyType(DEPENDENCNODEYTYPE depType) {
198 return mDepNodeType == depType;
199 }
200
201
202 bool CDependencyNode::isIndependentBaseDependencyType() {
203 return isDependencyType(DNTINDEPENDENTBASE);
204 }
205
206 bool CDependencyNode::isUndefinedDependencyType() {
207 return isDependencyType(DNTUNDEFINED);
208 }
209
210 CIndividualProcessNode* CDependencyNode::getAppropriateIndividualNode() {
211 return mIndividualNode;
212 }
213
214 bool CDependencyNode::hasAppropriateIndividualNode() {
215 return mIndividualNode != nullptr;
216 }
217
218 CDependencyNode* CDependencyNode::setAppropriateIndividualNode(CIndividualProcessNode* indiNode) {
219 mIndividualNode = indiNode;
220 return this;
221 }
222
223
224 bool CDependencyNode::updateDependencyTrackPointBranchingTag(CDependencyTrackPoint* depTrackPoint, cint64 branchinLevelTag) {
225 return depTrackPoint->addMaximumBranchingTagCandidate(branchinLevelTag);
226 }
227
228 bool CDependencyNode::isRepresentativeResolveDependencyNode() {
229 return false;
230 }
231
232 bool CDependencyNode::isRepresentativeSelectDependencyNode() {
233 return false;
234 }
235
236 }; // end namespace Dependency
237
238 }; // end namespace Process
239
240 }; // end namespace Kernel
241
242 }; // end namespace Reasoner
243
244 }; // end namespace Konclude