Debian Codegraph @

Source/Reasoner/Kernel/Process/CBranchingMergingProcessingRestrictionSpecification.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 "CBranchingMergingProcessingRestrictionSpecification.h"
22
23
24 namespace Konclude {
25
26 namespace Reasoner {
27
28 namespace Kernel {
29
30 namespace Process {
31
32
33 CBranchingMergingProcessingRestrictionSpecification::CBranchingMergingProcessingRestrictionSpecification(CProcessContext* processContext) {
34 mProcessContext = processContext;
35 mDistinctMergedNodesSet = nullptr;
36 mMergingNodesLinker = nullptr;
37 mNominalMergingNodesLinker = nullptr;
38 mMergingInitNodesLinker = nullptr;
39 mOnlyPosQualifyNodesLinker = nullptr;
40 mOnlyNegQualifyNodesLinker = nullptr;
41 mBothQualifyNodesLinker = nullptr;
42 mLastDistinctMergedNodesSet = nullptr;
43 mIndiLink = nullptr;
44 mRemainingLinkerMergingCandidateIndiNodeCount = 0;
45 mRemainingValidMergingCandidateIndiNodeCount = 0;
46 mDistinctSetFixed = false;
47 mHasMergingInitCandidates = false;
48 mRemainingNominalCreationCount = 0;
49 mAddedBlockablePredMergingNodeCandidate = false;
50 mAddedBlockablePredDepTrackPoint = nullptr;
51 mDependencyTrackPoint = nullptr;
52 mMergingDependencyNode = nullptr;
53 mInitMergingNodesClashes = nullptr;
54 mMultipleInitMergingNodesClashes = nullptr;
55
56 mDistinctSetNodeRelocated = false;
57 mSuccChoiceTriggeringInstalled = false;
58 mSuccChoiceTriggeringInstalledCount = 0;
59 mLastCheckedSuccChoiceTriggerLinker = nullptr;
60
61 //mList.clear();
62 //mList.append(QString(""));
63 //mList.append(QString(""));
64 //mList.append(QString(""));
65 }
66
67
68
69 CBranchingMergingProcessingRestrictionSpecification* CBranchingMergingProcessingRestrictionSpecification::initBranchingMergingProcessingRestriction(CBranchingMergingProcessingRestrictionSpecification* prevRest) {
70 CProcessingRestrictionSpecification::initProcessingRestriction(prevRest);
71 if (prevRest) {
72 mDistinctMergedNodesSet = nullptr;
73 mLastDistinctMergedNodesSet = nullptr;
74 if (prevRest->mLastDistinctMergedNodesSet) {
75 mLastDistinctMergedNodesSet = prevRest->mLastDistinctMergedNodesSet;
76 }
77 mNominalMergingNodesLinker = prevRest->mNominalMergingNodesLinker;
78 mMergingNodesLinker = prevRest->mMergingNodesLinker;
79 mMergingInitNodesLinker = prevRest->mMergingInitNodesLinker;
80 mOnlyPosQualifyNodesLinker = prevRest->mOnlyPosQualifyNodesLinker;
81 mOnlyNegQualifyNodesLinker = prevRest->mOnlyNegQualifyNodesLinker;
82 mBothQualifyNodesLinker = prevRest->mBothQualifyNodesLinker;
83 mIndiLink = prevRest->mIndiLink;
84 mRemainingLinkerMergingCandidateIndiNodeCount = prevRest->mRemainingLinkerMergingCandidateIndiNodeCount;
85 mRemainingValidMergingCandidateIndiNodeCount = prevRest->mRemainingValidMergingCandidateIndiNodeCount;
86 mDistinctSetFixed = prevRest->mDistinctSetFixed;
87 mHasMergingInitCandidates = prevRest->mHasMergingInitCandidates;
88 mRemainingNominalCreationCount = prevRest->mRemainingNominalCreationCount;
89 mAddedBlockablePredMergingNodeCandidate = prevRest->mAddedBlockablePredMergingNodeCandidate;
90 mAddedBlockablePredDepTrackPoint = prevRest->mAddedBlockablePredDepTrackPoint;
91 mDependencyTrackPoint = prevRest->mDependencyTrackPoint;
92 mMergingDependencyNode = prevRest->mMergingDependencyNode;
93 mInitMergingNodesClashes = prevRest->mInitMergingNodesClashes;
94 mMultipleInitMergingNodesClashes = prevRest->mMultipleInitMergingNodesClashes;
95 mDistinctSetNodeRelocated = prevRest->mDistinctSetNodeRelocated;
96 mSuccChoiceTriggeringInstalled = prevRest->mSuccChoiceTriggeringInstalled;
97 mSuccChoiceTriggeringInstalledCount = prevRest->mSuccChoiceTriggeringInstalledCount;
98 mLastCheckedSuccChoiceTriggerLinker = prevRest->mLastCheckedSuccChoiceTriggerLinker;
99
100 //mList = prevRest->mList;
101 } else {
102 mLastCheckedSuccChoiceTriggerLinker = nullptr;
103 mSuccChoiceTriggeringInstalledCount = 0;
104 mSuccChoiceTriggeringInstalled = false;
105 mDistinctSetNodeRelocated = false;
106 mDistinctMergedNodesSet = nullptr;
107 mMergingNodesLinker = nullptr;
108 mNominalMergingNodesLinker = nullptr;
109 mMergingInitNodesLinker = nullptr;
110 mOnlyPosQualifyNodesLinker = nullptr;
111 mOnlyNegQualifyNodesLinker = nullptr;
112 mBothQualifyNodesLinker = nullptr;
113 mIndiLink = nullptr;
114 mRemainingLinkerMergingCandidateIndiNodeCount = 0;
115 mRemainingValidMergingCandidateIndiNodeCount = 0;
116 mDistinctSetFixed = false;
117 mHasMergingInitCandidates = false;
118 mRemainingNominalCreationCount = 0;
119 mAddedBlockablePredMergingNodeCandidate = false;
120 mAddedBlockablePredDepTrackPoint = nullptr;
121 mDependencyTrackPoint = nullptr;
122 mMergingDependencyNode = nullptr;
123 mInitMergingNodesClashes = nullptr;
124 mMultipleInitMergingNodesClashes = nullptr;
125
126 }
127 return this;
128 }
129
130
131
132 CPROCESSSET<cint64>* CBranchingMergingProcessingRestrictionSpecification::getDistinctMergedNodesSet(bool create) {
133 if (!mDistinctMergedNodesSet && create) {
134 createLocalizedDistinctMergedNodeSet();
135 }
136 return mLastDistinctMergedNodesSet;
137 }
138
139
140 CPROCESSSET<cint64>* CBranchingMergingProcessingRestrictionSpecification::createLocalizedDistinctMergedNodeSet() {
141 if (!mDistinctMergedNodesSet) {
142 mDistinctMergedNodesSet = CObjectParameterizingAllocator< CPROCESSSET<cint64>,CContext* >::allocateAndConstructAndParameterize(mProcessContext->getUsedMemoryAllocationManager(),mProcessContext);
143 if (mLastDistinctMergedNodesSet) {
144 *mDistinctMergedNodesSet = *mLastDistinctMergedNodesSet;
145 }
146 mLastDistinctMergedNodesSet = mDistinctMergedNodesSet;
147 }
148 return mLastDistinctMergedNodesSet;
149 }
150
151
152
153 CBranchingMergingProcessingRestrictionSpecification* CBranchingMergingProcessingRestrictionSpecification::addDistinctMergedNode(cint64 mergedIndiNode) {
154 createLocalizedDistinctMergedNodeSet()->insert(mergedIndiNode);
155 return this;
156 }
157
158 CBranchingMergingProcessingRestrictionSpecification* CBranchingMergingProcessingRestrictionSpecification::removeDistinctMergedNode(cint64 mergedIndiNode) {
159 createLocalizedDistinctMergedNodeSet()->remove(mergedIndiNode);
160 return this;
161 }
162
163 CBranchingMergingIndividualNodeCandidateLinker* CBranchingMergingProcessingRestrictionSpecification::getMergingCandidateNodeLinker() {
164 return mMergingNodesLinker;
165 }
166
167 CBranchingMergingIndividualNodeCandidateLinker* CBranchingMergingProcessingRestrictionSpecification::takeNextMergingCandidateNodeLinker() {
168 CBranchingMergingIndividualNodeCandidateLinker* tmpMergingNodeLinker = nullptr;
169 tmpMergingNodeLinker = takeNextMergingInitializationCandidateNodeLinker();
170 if (!tmpMergingNodeLinker) {
171 tmpMergingNodeLinker = mNominalMergingNodesLinker;
172 if (mNominalMergingNodesLinker) {
173 --mRemainingLinkerMergingCandidateIndiNodeCount;
174 --mRemainingValidMergingCandidateIndiNodeCount;
175 mNominalMergingNodesLinker = mNominalMergingNodesLinker->getNext();
176 }
177 if (!tmpMergingNodeLinker) {
178 tmpMergingNodeLinker = mMergingNodesLinker;
179 if (mMergingNodesLinker) {
180 --mRemainingLinkerMergingCandidateIndiNodeCount;
181 --mRemainingValidMergingCandidateIndiNodeCount;
182 mMergingNodesLinker = mMergingNodesLinker->getNext();
183 }
184 }
185 }
186 return tmpMergingNodeLinker;
187 }
188
189 CBranchingMergingProcessingRestrictionSpecification* CBranchingMergingProcessingRestrictionSpecification::addMergingCandidateNodeLinker(CBranchingMergingIndividualNodeCandidateLinker* linker) {
190 while (linker) {
191 CBranchingMergingIndividualNodeCandidateLinker* linkerIt = linker;
192 linker = linker->getNext();
193 linkerIt->clearNext();
194 if (!mAddedBlockablePredMergingNodeCandidate && linkerIt->isCandidateBlockableAndCreator()) {
195 mAddedBlockablePredDepTrackPoint = linkerIt->getMergingIndividualLink()->getDependencyTrackPoint();
196 mAddedBlockablePredMergingNodeCandidate = true;
197 }
198 ++mRemainingLinkerMergingCandidateIndiNodeCount;
199 ++mRemainingValidMergingCandidateIndiNodeCount;
200 if (linkerIt->getMergingIndividualNodeCandidate()->isNominalIndividualNode()) {
201 mNominalMergingNodesLinker = linkerIt->append(mNominalMergingNodesLinker);
202 } else {
203 mMergingNodesLinker = linkerIt->append(mMergingNodesLinker);
204 }
205 }
206 return this;
207 }
208
209
210 CBranchingMergingIndividualNodeCandidateLinker* CBranchingMergingProcessingRestrictionSpecification::getMergingInitializationCandidateNodeLinker() {
211 return mMergingInitNodesLinker;
212 }
213
214 CBranchingMergingIndividualNodeCandidateLinker* CBranchingMergingProcessingRestrictionSpecification::takeNextMergingInitializationCandidateNodeLinker() {
215 CBranchingMergingIndividualNodeCandidateLinker* tmpMergingNodeLinker = nullptr;
216 tmpMergingNodeLinker = mMergingInitNodesLinker;
217 if (mMergingInitNodesLinker) {
218 --mRemainingLinkerMergingCandidateIndiNodeCount;
219 --mRemainingValidMergingCandidateIndiNodeCount;
220 mMergingInitNodesLinker = mMergingInitNodesLinker->getNext();
221 }
222 return tmpMergingNodeLinker;
223 }
224
225 CBranchingMergingProcessingRestrictionSpecification* CBranchingMergingProcessingRestrictionSpecification::addMergingInitializationCandidateNodeLinker(CBranchingMergingIndividualNodeCandidateLinker* linker) {
226 if (linker) {
227 mHasMergingInitCandidates = true;
228 CBranchingMergingIndividualNodeCandidateLinker* linkerIt = linker;
229 while (linkerIt) {
230 if (!mAddedBlockablePredMergingNodeCandidate && linkerIt->isCandidateBlockableAndCreator()) {
231 mAddedBlockablePredDepTrackPoint = linkerIt->getMergingIndividualLink()->getDependencyTrackPoint();
232 mAddedBlockablePredMergingNodeCandidate = true;
233 }
234 ++mRemainingLinkerMergingCandidateIndiNodeCount;
235 ++mRemainingValidMergingCandidateIndiNodeCount;
236 linkerIt = linkerIt->getNext();
237 }
238 mMergingInitNodesLinker = linker->append(mMergingInitNodesLinker);
239 }
240 return this;
241 }
242
243
244
245 CBranchingMergingIndividualNodeCandidateLinker* CBranchingMergingProcessingRestrictionSpecification::getOnlyPosQualifyCandidateNodeLinker() {
246 return mOnlyPosQualifyNodesLinker;
247 }
248
249 CBranchingMergingProcessingRestrictionSpecification* CBranchingMergingProcessingRestrictionSpecification::addOnlyPosQualifyCandidateNodeLinker(CBranchingMergingIndividualNodeCandidateLinker* linker) {
250 if (linker) {
251 mOnlyPosQualifyNodesLinker = linker->append(mOnlyPosQualifyNodesLinker);
252 }
253 return this;
254 }
255
256
257 CBranchingMergingProcessingRestrictionSpecification* CBranchingMergingProcessingRestrictionSpecification::clearOnlyPosQualifyCandidateNodeLinker() {
258 mOnlyPosQualifyNodesLinker = nullptr;
259 return this;
260 }
261
262 CBranchingMergingIndividualNodeCandidateLinker* CBranchingMergingProcessingRestrictionSpecification::getOnlyNegQualifyCandidateNodeLinker() {
263 return mOnlyNegQualifyNodesLinker;
264 }
265
266 CBranchingMergingProcessingRestrictionSpecification* CBranchingMergingProcessingRestrictionSpecification::addOnlyNegQualifyCandidateNodeLinker(CBranchingMergingIndividualNodeCandidateLinker* linker) {
267 if (linker) {
268 mOnlyNegQualifyNodesLinker = linker->append(mOnlyNegQualifyNodesLinker);
269 }
270 return this;
271 }
272
273 CBranchingMergingProcessingRestrictionSpecification* CBranchingMergingProcessingRestrictionSpecification::clearOnlyNegQualifyCandidateNodeLinker() {
274 mOnlyNegQualifyNodesLinker = nullptr;
275 return this;
276 }
277
278 CBranchingMergingIndividualNodeCandidateLinker* CBranchingMergingProcessingRestrictionSpecification::getBothQualifyCandidateNodeLinker() {
279 return mBothQualifyNodesLinker;
280 }
281
282
283 CBranchingMergingProcessingRestrictionSpecification* CBranchingMergingProcessingRestrictionSpecification::addBothQualifyCandidateNodeLinker(CBranchingMergingIndividualNodeCandidateLinker* linker) {
284 if (linker) {
285 mBothQualifyNodesLinker = linker->append(mBothQualifyNodesLinker);
286 }
287 return this;
288 }
289
290 CBranchingMergingProcessingRestrictionSpecification* CBranchingMergingProcessingRestrictionSpecification::setBothQualifyCandidateNodeLinker(CBranchingMergingIndividualNodeCandidateLinker* linker) {
291 mBothQualifyNodesLinker = linker;
292 return this;
293 }
294
295 cint64 CBranchingMergingProcessingRestrictionSpecification::getRemainingLinkerMergingCandidateIndividualNodeCount() {
296 return mRemainingLinkerMergingCandidateIndiNodeCount;
297 }
298
299 CBranchingMergingProcessingRestrictionSpecification* CBranchingMergingProcessingRestrictionSpecification::setRemainingLinkerMergingCandidateIndividualNodeCount(cint64 remainingCanidateCount) {
300 mRemainingLinkerMergingCandidateIndiNodeCount = remainingCanidateCount;
301 return this;
302 }
303
304 CIndividualLinkEdge* CBranchingMergingProcessingRestrictionSpecification::getLastIndividualLink() {
305 return mIndiLink;
306 }
307
308 CBranchingMergingProcessingRestrictionSpecification* CBranchingMergingProcessingRestrictionSpecification::setLastIndividualLink(CIndividualLinkEdge* indiLink) {
309 mIndiLink = indiLink;
310 return this;
311 }
312
313
314 cint64 CBranchingMergingProcessingRestrictionSpecification::getRemainingValidMergingCandidateIndividualNodeCount() {
315 return mRemainingValidMergingCandidateIndiNodeCount;
316 }
317
318 CBranchingMergingProcessingRestrictionSpecification* CBranchingMergingProcessingRestrictionSpecification::setRemainingValidMergingCandidateIndividualNodeCount(cint64 remainingCanidateCount) {
319 mRemainingValidMergingCandidateIndiNodeCount = remainingCanidateCount;
320 return this;
321 }
322
323 CBranchingMergingProcessingRestrictionSpecification* CBranchingMergingProcessingRestrictionSpecification::incRemainingValidMergingCandidateIndividualNodeCount() {
324 ++mRemainingValidMergingCandidateIndiNodeCount;
325 return this;
326 }
327
328
329 bool CBranchingMergingProcessingRestrictionSpecification::hasValidRemainingMergingCandidates() {
330 return mRemainingValidMergingCandidateIndiNodeCount == mRemainingLinkerMergingCandidateIndiNodeCount;
331 }
332
333
334 bool CBranchingMergingProcessingRestrictionSpecification::hasRemainingMergingCandidates() {
335 return mNominalMergingNodesLinker != nullptr || mMergingNodesLinker != nullptr || mMergingInitNodesLinker != nullptr;
336 }
337
338 bool CBranchingMergingProcessingRestrictionSpecification::hasMergingInitializationCandidates() {
339 return mHasMergingInitCandidates;
340 }
341
342 bool CBranchingMergingProcessingRestrictionSpecification::hasRemainingMergingInitializationCandidates() {
343 return mMergingInitNodesLinker != nullptr;
344 }
345
346 CBranchingMergingProcessingRestrictionSpecification* CBranchingMergingProcessingRestrictionSpecification::setDistinctSetFixed(bool fixed) {
347 mDistinctSetFixed = fixed;
348 return this;
349 }
350
351 bool CBranchingMergingProcessingRestrictionSpecification::isDistinctSetFixed() {
352 return mDistinctSetFixed;
353 }
354
355
356 CBranchingMergingProcessingRestrictionSpecification* CBranchingMergingProcessingRestrictionSpecification::setRemainingNominalCreationCount(cint64 nomCount) {
357 mRemainingNominalCreationCount = nomCount;
358 return this;
359 }
360
361 CBranchingMergingProcessingRestrictionSpecification* CBranchingMergingProcessingRestrictionSpecification::decRemainingNominalCreationCount(cint64 decCount) {
362 mRemainingNominalCreationCount -= decCount;
363 return this;
364 }
365
366
367 cint64 CBranchingMergingProcessingRestrictionSpecification::getRemainingNominalCreationCount() {
368 return mRemainingNominalCreationCount;
369 }
370
371 bool CBranchingMergingProcessingRestrictionSpecification::hasAddedBlockablePredecessorMergingNodeCandidate() {
372 return mAddedBlockablePredMergingNodeCandidate;
373 }
374
375 CDependencyTrackPoint* CBranchingMergingProcessingRestrictionSpecification::getAddedBlockablePredecessorDependencyTrackPoint() {
376 return mAddedBlockablePredDepTrackPoint;
377 }
378
379 CBranchingMergingProcessingRestrictionSpecification* CBranchingMergingProcessingRestrictionSpecification::initMergingDependencyNode(CNonDeterministicDependencyNode* depNode) {
380 mMergingDependencyNode = depNode;
381 return this;
382 }
383
384 CNonDeterministicDependencyNode* CBranchingMergingProcessingRestrictionSpecification::getMergingDependencyNode() {
385 return mMergingDependencyNode;
386 }
387
388 CBranchingMergingProcessingRestrictionSpecification* CBranchingMergingProcessingRestrictionSpecification::setMergingNodesInitializationClashesDescriptors(CClashedDependencyDescriptor* clashes) {
389 mInitMergingNodesClashes = clashes;
390 return this;
391 }
392
393 CClashedDependencyDescriptor* CBranchingMergingProcessingRestrictionSpecification::getMergingNodesInitializationClashesDescriptors() {
394 return mInitMergingNodesClashes;
395 }
396
397 CBranchingMergingProcessingRestrictionSpecification* CBranchingMergingProcessingRestrictionSpecification::setMultipleMergingNodesInitializationClashesDescriptors(CClashedDependencyDescriptor* clashes) {
398 mMultipleInitMergingNodesClashes = clashes;
399 return this;
400 }
401
402 CClashedDependencyDescriptor* CBranchingMergingProcessingRestrictionSpecification::getMultipleMergingNodesInitializationClashesDescriptors() {
403 return mMultipleInitMergingNodesClashes;
404 }
405
406
407 bool CBranchingMergingProcessingRestrictionSpecification::isDistinctSetNodeRelocated() {
408 return mDistinctSetNodeRelocated;
409 }
410
411 CBranchingMergingProcessingRestrictionSpecification* CBranchingMergingProcessingRestrictionSpecification::setDistinctSetNodeRelocated(bool distinctSetNodeRelocated) {
412 mDistinctSetNodeRelocated = distinctSetNodeRelocated;
413 return this;
414 }
415
416
417 bool CBranchingMergingProcessingRestrictionSpecification::hasSuccessorChoiceTriggeringInstalled() {
418 return mSuccChoiceTriggeringInstalled;
419 }
420
421 CBranchingMergingProcessingRestrictionSpecification* CBranchingMergingProcessingRestrictionSpecification::setSuccessorChoiceTriggeringInstalled(bool succChoiceTriggeringInstalled) {
422 mSuccChoiceTriggeringInstalled = succChoiceTriggeringInstalled;
423 return this;
424 }
425
426 cint64 CBranchingMergingProcessingRestrictionSpecification::getSuccessorChoiceTriggeringInstalledCount() {
427 return mSuccChoiceTriggeringInstalledCount;
428 }
429
430 CBranchingMergingProcessingRestrictionSpecification* CBranchingMergingProcessingRestrictionSpecification::incSuccessorChoiceTriggeringInstalledCount(cint64 count) {
431 mSuccChoiceTriggeringInstalledCount += count;
432 return this;
433 }
434
435 CBranchingMergingProcessingRestrictionSpecification* CBranchingMergingProcessingRestrictionSpecification::decSuccessorChoiceTriggeringInstalledCount(cint64 count) {
436 mSuccChoiceTriggeringInstalledCount -= count;
437 return this;
438 }
439
440
441 CXLinker<CIndividualLinkEdge*>* CBranchingMergingProcessingRestrictionSpecification::getLastCheckedSuccessorChoiceTriggerLinker() {
442 return mLastCheckedSuccChoiceTriggerLinker;
443 }
444
445 CBranchingMergingProcessingRestrictionSpecification* CBranchingMergingProcessingRestrictionSpecification::setLastCheckedSuccessorChoiceTriggerLinker(CXLinker<CIndividualLinkEdge*>* indiLinker) {
446 mLastCheckedSuccChoiceTriggerLinker = indiLinker;
447 return this;
448 }
449
450
451
452 //bool CBranchingMergingProcessingRestrictionSpecification::addIndividualToContainer(cint64 container, cint64 individual) {
453 // QString insertString;
454 // --container;
455 // if (mList.size() > container) {
456 // insertString = mList.value(container);
457 // insertString += QString(" %1").arg(individual);
458 // mList.replace(container,insertString);
459 // } else {
460 // insertString += QString("%1").arg(individual);
461 // mList.insert(container,insertString);
462 // }
463 // return true;
464 //}
465
466 //void CBranchingMergingProcessingRestrictionSpecification::printIndividualContainer() {
467 // cout<<"\n"<<mList.join("\n").toLocal8Bit().data()<<endl;
468 //}
469
470
471
472 }; // end namespace Kernel
473
474 }; // end namespace Process
475
476 }; // end namespace Reasoner
477
478 }; // end namespace Konclude