Debian Codegraph @

Source/Reasoner/Kernel/Algorithm/CTrackedClashedDependencyLine.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 "CTrackedClashedDependencyLine.h"
22
23
24 namespace Konclude {
25
26 namespace Reasoner {
27
28 namespace Kernel {
29
30 namespace Algorithm {
31
32 CTrackedClashedDependencyLine::CTrackedClashedDependencyLine(CPROCESSINGSET<CTrackedClashedDescriptorHasher>* clashedSet) {
33 mFreeTrackedClashedDescriptors = nullptr;
34 mClashedSet = clashedSet;
35 mInvolvedIndividualSet = nullptr;
36 }
37
38
39 CTrackedClashedDependencyLine* CTrackedClashedDependencyLine::initTrackedClashedDependencyLine(bool exactIndiNodeTracking, cint64 individualNodeTrackLevel, cint64 branchingLevel) {
40 mExactIndividualTracking = exactIndiNodeTracking;
41 mIndividualTrackLevel = individualNodeTrackLevel;
42 mBranchingLevel = branchingLevel;
43
44 mLevelTrackedClashes = nullptr;
45 mLevelTrackedBranchingClashes = nullptr;
46 mPrevLevelsTrackedClashes = nullptr;
47 mPrevLevelsTrackedNonDetClashes = nullptr;
48 mPrevLevelsTrackedNonDetBranchingClashes = nullptr;
49 mIndependentTrackedClashes = nullptr;
50 return this;
51 }
52
53
54 CTrackedClashedDependencyLine* CTrackedClashedDependencyLine::analyseInvolvedIndividuals(CTrackedClashedDescriptor* clashedDes) {
55 if (mInvolvedIndividualSet) {
56 for (CTrackedClashedDescriptor* clashedDesIt = clashedDes; clashedDes; clashedDes = clashedDes->getNextDescriptor()) {
57 CIndividualProcessNode* indiNode = clashedDesIt->getAppropriatedIndividual();
58 if (indiNode && indiNode->getNominalIndividual()) {
59 mInvolvedIndividualSet->insert(indiNode->getNominalIndividual()->getIndividualID());
60 }
61 }
62 }
63 return this;
64 }
65
66 CTrackedClashedDependencyLine* CTrackedClashedDependencyLine::addInvolvedIndividual(CIndividualProcessNode* indiNode) {
67 if (mInvolvedIndividualSet && indiNode && indiNode->getNominalIndividual()) {
68 mInvolvedIndividualSet->insert(indiNode->getNominalIndividual()->getIndividualID());
69 }
70 return this;
71 }
72
73 CTrackedClashedDependencyLine* CTrackedClashedDependencyLine::addInvolvedIndividual(cint64 indiId) {
74 if (mInvolvedIndividualSet) {
75 mInvolvedIndividualSet->insert(indiId);
76 }
77 return this;
78 }
79
80 CTrackedClashedDependencyLine* CTrackedClashedDependencyLine::sortInTrackedClashedDescriptors(CTrackedClashedDescriptor* clashedDes, bool forceInsertion) {
81 CTrackedClashedDescriptor* clashedDesIt = clashedDes;
82 while (clashedDesIt) {
83 CTrackedClashedDescriptor* clashedDesTmp = clashedDesIt;
84 clashedDesIt = clashedDesIt->getNextDescriptor();
85 clashedDesTmp->clearNext();
86 CTrackedClashedDescriptorHasher desHasher(clashedDesTmp);
87 bool clashDesInsertion = forceInsertion;
88 if (!mClashedSet->contains(desHasher)) {
89 mClashedSet->insert(desHasher);
90 clashDesInsertion = true;
91 }
92 if (clashDesInsertion) {
93 if (clashedDesTmp->isPointingToIndependentDependencyNode()) {
94 mIndependentTrackedClashes = clashedDesTmp->append(mIndependentTrackedClashes);
95 } else {
96 if (clashedDesTmp->getAppropriatedIndividualLevel() > mIndividualTrackLevel) {
97 // previous individual node level
98 if (clashedDesTmp->isPointingToNonDeterministicDependencyNode()) {
99 if (clashedDesTmp->getBranchingLevelTag() == mBranchingLevel) {
100 mPrevLevelsTrackedNonDetBranchingClashes = clashedDesTmp->append(mPrevLevelsTrackedNonDetBranchingClashes);
101 } else {
102 mPrevLevelsTrackedNonDetClashes = clashedDesTmp->append(mPrevLevelsTrackedNonDetClashes);
103 }
104 } else {
105 // deterministic, branching level does not matter
106 mPrevLevelsTrackedClashes = clashedDesTmp->append(mPrevLevelsTrackedClashes);
107 }
108 } else {
109 // current individual node level
110 if (clashedDesTmp->getBranchingLevelTag() == mBranchingLevel) {
111 mLevelTrackedBranchingClashes = clashedDesTmp->append(mLevelTrackedBranchingClashes);
112 } else {
113 mLevelTrackedClashes = clashedDesTmp->append(mLevelTrackedClashes);
114 }
115 }
116 }
117 } else {
118 addFreeTrackedClashedDescriptor(clashedDesTmp);
119 }
120 }
121 return this;
122 }
123
124
125
126 CTrackedClashedDependencyLine* CTrackedClashedDependencyLine::moveToNextIndividualNodeLevel(cint64 newLevel) {
127 mIndividualTrackLevel = newLevel;
128 //if (mLevelTrackedClashes) {
129 // mPrevLevelsTrackedClashes = mLevelTrackedClashes->append(mPrevLevelsTrackedClashes);
130 //}
131 CTrackedClashedDescriptor* levelTrackedClashes = mLevelTrackedClashes;
132 mLevelTrackedClashes = nullptr;
133 sortInTrackedClashedDescriptors(levelTrackedClashes,true);
134
135 CTrackedClashedDescriptor* levelTrackedBranchingClashes = mLevelTrackedBranchingClashes;
136 mLevelTrackedBranchingClashes = nullptr;
137 sortInTrackedClashedDescriptors(levelTrackedBranchingClashes,true);
138 return this;
139 }
140
141
142
143 bool CTrackedClashedDependencyLine::hasIndependentTrackedClashedDescriptors() {
144 return mIndependentTrackedClashes != nullptr;
145 }
146
147 CTrackedClashedDescriptor* CTrackedClashedDependencyLine::takeNextIndependentTrackedClashedDescriptor() {
148 CTrackedClashedDescriptor* clashedDesTmp = mIndependentTrackedClashes;
149 if (mIndependentTrackedClashes) {
150 mIndependentTrackedClashes = mIndependentTrackedClashes->getNextDescriptor();
151 clashedDesTmp->clearNext();
152 }
153 return clashedDesTmp;
154 }
155
156 CTrackedClashedDescriptor* CTrackedClashedDependencyLine::getIndependentTrackedClashedDescriptors() {
157 return mIndependentTrackedClashes;
158 }
159
160 bool CTrackedClashedDependencyLine::hasLevelTrackedClashedDescriptors() {
161 return mLevelTrackedClashes != nullptr;
162 }
163
164 CTrackedClashedDescriptor* CTrackedClashedDependencyLine::takeNextLevelTrackedClashedDescriptor() {
165 CTrackedClashedDescriptor* clashedDesTmp = mLevelTrackedClashes;
166 if (mLevelTrackedClashes) {
167 mLevelTrackedClashes = mLevelTrackedClashes->getNextDescriptor();
168 clashedDesTmp->clearNext();
169 }
170 return clashedDesTmp;
171 }
172
173 CTrackedClashedDescriptor* CTrackedClashedDependencyLine::getLevelTrackedClashedDescriptors() {
174 return mLevelTrackedClashes;
175 }
176
177
178 bool CTrackedClashedDependencyLine::hasLevelTrackedBranchingClashedDescriptors() {
179 return mLevelTrackedBranchingClashes != nullptr;
180 }
181
182 CTrackedClashedDescriptor* CTrackedClashedDependencyLine::takeNextLevelTrackedBranchingClashedDescriptor() {
183 CTrackedClashedDescriptor* clashedDesTmp = mLevelTrackedBranchingClashes;
184 if (mLevelTrackedBranchingClashes) {
185 mLevelTrackedBranchingClashes = mLevelTrackedBranchingClashes->getNextDescriptor();
186 clashedDesTmp->clearNext();
187 }
188 return clashedDesTmp;
189 }
190
191 CTrackedClashedDescriptor* CTrackedClashedDependencyLine::getLevelTrackedBranchingClashedDescriptors() {
192 return mLevelTrackedBranchingClashes;
193 }
194
195
196 bool CTrackedClashedDependencyLine::hasPerviousLevelTrackedClashedDescriptors() {
197 return mPrevLevelsTrackedClashes != nullptr;
198 }
199
200 CTrackedClashedDescriptor* CTrackedClashedDependencyLine::takeNextPerviousLevelTrackedClashedDescriptor() {
201 CTrackedClashedDescriptor* clashedDesTmp = mPrevLevelsTrackedClashes;
202 if (mPrevLevelsTrackedClashes) {
203 mPrevLevelsTrackedClashes = mPrevLevelsTrackedClashes->getNextDescriptor();
204 clashedDesTmp->clearNext();
205 }
206 return clashedDesTmp;
207 }
208
209 CTrackedClashedDescriptor* CTrackedClashedDependencyLine::getPerviousLevelTrackedClashedDescriptors() {
210 return mPrevLevelsTrackedClashes;
211 }
212
213
214 bool CTrackedClashedDependencyLine::hasPerviousLevelTrackedNonDeterministicClashedDescriptors() {
215 return mPrevLevelsTrackedNonDetClashes != nullptr;
216 }
217
218 CTrackedClashedDescriptor* CTrackedClashedDependencyLine::takeNextPerviousLevelTrackedNonDeterministicClashedDescriptor() {
219 CTrackedClashedDescriptor* clashedDesTmp = mPrevLevelsTrackedNonDetClashes;
220 if (mPrevLevelsTrackedNonDetClashes) {
221 mPrevLevelsTrackedNonDetClashes = mPrevLevelsTrackedNonDetClashes->getNextDescriptor();
222 clashedDesTmp->clearNext();
223 }
224 return clashedDesTmp;
225 }
226
227 CTrackedClashedDescriptor* CTrackedClashedDependencyLine::getPerviousLevelTrackedNonDeterministicClashedDescriptors() {
228 return mPrevLevelsTrackedNonDetClashes;
229 }
230
231
232
233 bool CTrackedClashedDependencyLine::hasPerviousLevelTrackedNonDeterministicBranchingClashedDescriptors() {
234 return mPrevLevelsTrackedNonDetBranchingClashes != nullptr;
235 }
236
237 CTrackedClashedDescriptor* CTrackedClashedDependencyLine::takeNextPerviousLevelTrackedNonDeterministicBranchingClashedDescriptor() {
238 CTrackedClashedDescriptor* clashedDesTmp = mPrevLevelsTrackedNonDetBranchingClashes;
239 if (mPrevLevelsTrackedNonDetBranchingClashes) {
240 mPrevLevelsTrackedNonDetBranchingClashes = mPrevLevelsTrackedNonDetBranchingClashes->getNextDescriptor();
241 clashedDesTmp->clearNext();
242 }
243 return clashedDesTmp;
244 }
245
246 CTrackedClashedDescriptor* CTrackedClashedDependencyLine::getPerviousLevelTrackedNonDeterministicBranchingClashedDescriptors() {
247 return mPrevLevelsTrackedNonDetBranchingClashes;
248 }
249
250
251
252 bool CTrackedClashedDependencyLine::hasMoreTrackedClashedList() {
253 return mLevelTrackedClashes || mLevelTrackedBranchingClashes || mPrevLevelsTrackedClashes || mPrevLevelsTrackedNonDetClashes || mPrevLevelsTrackedNonDetBranchingClashes || mIndependentTrackedClashes;
254 }
255
256
257 CTrackedClashedDescriptor* CTrackedClashedDependencyLine::takeNextTrackedClashedList() {
258 CTrackedClashedDescriptor* clashes = nullptr;
259 if (mLevelTrackedClashes) {
260 clashes = mLevelTrackedClashes;
261 mLevelTrackedClashes = nullptr;
262 } else if (mLevelTrackedBranchingClashes) {
263 clashes = mLevelTrackedBranchingClashes;
264 mLevelTrackedBranchingClashes = nullptr;
265 } else if (mPrevLevelsTrackedClashes) {
266 clashes = mPrevLevelsTrackedClashes;
267 mPrevLevelsTrackedClashes = nullptr;
268 } else if (mPrevLevelsTrackedNonDetClashes) {
269 clashes = mPrevLevelsTrackedNonDetClashes;
270 mPrevLevelsTrackedNonDetClashes = nullptr;
271 } else if (mPrevLevelsTrackedNonDetBranchingClashes) {
272 clashes = mPrevLevelsTrackedNonDetBranchingClashes;
273 mPrevLevelsTrackedNonDetBranchingClashes = nullptr;
274 } else if (mIndependentTrackedClashes) {
275 clashes = mIndependentTrackedClashes;
276 mIndependentTrackedClashes = nullptr;
277 }
278 return clashes;
279 }
280
281
282 CTrackedClashedDescriptor* CTrackedClashedDependencyLine::takeNextFreeTrackedClashedDescriptor() {
283 CTrackedClashedDescriptor* clashedDesTmp = mFreeTrackedClashedDescriptors;
284 if (mFreeTrackedClashedDescriptors) {
285 mFreeTrackedClashedDescriptors = mFreeTrackedClashedDescriptors->getNextDescriptor();
286 clashedDesTmp->clearNext();
287 }
288 return clashedDesTmp;
289 }
290
291 CTrackedClashedDependencyLine* CTrackedClashedDependencyLine::addFreeTrackedClashedDescriptor(CTrackedClashedDescriptor* clashDes) {
292 if (clashDes) {
293 mFreeTrackedClashedDescriptors = clashDes->append(mFreeTrackedClashedDescriptors);
294 }
295 return this;
296 }
297
298
299 CPROCESSINGSET<CTrackedClashedDescriptorHasher>* CTrackedClashedDependencyLine::getTrackedClashedDescriptorSet() {
300 return mClashedSet;
301 }
302
303
304 cint64 CTrackedClashedDependencyLine::getBranchingLevel() {
305 return mBranchingLevel;
306 }
307
308 cint64 CTrackedClashedDependencyLine::getIndividualNodeLevel() {
309 return mIndividualTrackLevel;
310 }
311
312 bool CTrackedClashedDependencyLine::hasOnlyIndependentTrackedClashedDescriptorsRemaining() {
313 return mIndependentTrackedClashes && !mLevelTrackedClashes && !mLevelTrackedBranchingClashes && !mPrevLevelsTrackedClashes && !mPrevLevelsTrackedNonDetClashes && !mPrevLevelsTrackedNonDetBranchingClashes;
314 }
315
316
317 bool CTrackedClashedDependencyLine::hasOnlyCurrentIndividualNodeLevelClashesDescriptors() {
318 return !mPrevLevelsTrackedClashes && !mPrevLevelsTrackedNonDetClashes && !mPrevLevelsTrackedNonDetBranchingClashes;
319 }
320
321 CTrackedClashedDependencyLine* CTrackedClashedDependencyLine::setInvolvedIndividualTrackingSet(CPROCESSINGSET<cint64>* indiTrackingSet) {
322 mInvolvedIndividualSet = indiTrackingSet;
323 return this;
324 }
325
326 CPROCESSINGSET<cint64>* CTrackedClashedDependencyLine::getInvolvedIndividualTrackingSet() {
327 return mInvolvedIndividualSet;
328 }
329
330
331
332 }; // end namespace Algorithm
333
334 }; // end namespace Kernel
335
336 }; // end namespace Reasoner
337
338 }; // end namespace Konclude