Debian Codegraph @

Source/Reasoner/Kernel/Process/Dependency/CNonDeterministicDependencyNode.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 "CNonDeterministicDependencyNode.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 CNonDeterministicDependencyNode::CNonDeterministicDependencyNode(CProcessContext* processContext) : CDependencyNode(processContext),mClashTrackPoint(this) {
36 }
37
38 CNonDeterministicDependencyNode* CNonDeterministicDependencyNode::initNonDeterministicDependencyNode(DEPENDENCNODEYTYPE depType, CBranchTreeNode* branchNode, CConceptDescriptor* conceptDescriptor) {
39 initDependencyNode(depType,conceptDescriptor);
40 mClashTrackPoint.setClashedOrIrelevantBranch(true);
41 mBranchTrackPoints = &mClashTrackPoint;
42 mDependencyClashes = nullptr;
43 mBranchNode = branchNode;
44 mBranchTag = 0;
45 mClosedTrackPoint = nullptr;
46 mClosingTrackPoint = nullptr;
47 return this;
48 }
49
50 CNonDeterministicDependencyNode* CNonDeterministicDependencyNode::initNonDeterministicDependencyNode(DEPENDENCNODEYTYPE depType, CBranchTreeNode* branchNode, CIndividualProcessNode* individualNode, CConceptDescriptor* conceptDescriptor) {
51 initDependencyNode(depType,individualNode,conceptDescriptor);
52 mClashTrackPoint.setClashedOrIrelevantBranch(true);
53 mBranchTrackPoints = &mClashTrackPoint;
54 mDependencyClashes = nullptr;
55 mBranchNode = branchNode;
56 mBranchTag = 0;
57 mClosedTrackPoint = nullptr;
58 mClosingTrackPoint = nullptr;
59 return this;
60 }
61
62 bool CNonDeterministicDependencyNode::isDeterministiDependencyNode() {
63 return false;
64 }
65
66
67 CDependencyTrackPoint* CNonDeterministicDependencyNode::getContinueDependencyTrackPoint() {
68 return &mClashTrackPoint;
69 }
70
71
72 CNonDeterministicDependencyTrackPoint* CNonDeterministicDependencyNode::getDependencyTrackPointBranch() {
73 CNonDeterministicDependencyTrackPoint* nonDetTrackPoint = CObjectParameterizingAllocator< CNonDeterministicDependencyTrackPoint,CNonDeterministicDependencyNode* >::allocateAndConstructAndParameterize(mProcessContext->getUsedMemoryAllocationManager(),this);
74 mBranchTrackPoints = nonDetTrackPoint->append(mBranchTrackPoints);
75 updateDependencyTrackPointBranchingTag(nonDetTrackPoint,mBranchTag);
76 return nonDetTrackPoint;
77 }
78
79
80 CNonDeterministicDependencyTrackPoint* CNonDeterministicDependencyNode::getBranchTrackPoints() {
81 return mBranchTrackPoints;
82 }
83
84
85 CNonDeterministicDependencyTrackPoint* CNonDeterministicDependencyNode::getClashTrackPoint() {
86 return &mClashTrackPoint;
87 }
88
89
90
91 CClashedDependencyDescriptor* CNonDeterministicDependencyNode::getDependencyClashes() {
92 return mDependencyClashes;
93 }
94
95 bool CNonDeterministicDependencyNode::hasDependencyClashes() {
96 return mDependencyClashes != nullptr;
97 }
98
99 CNonDeterministicDependencyNode* CNonDeterministicDependencyNode::setDependencyClash(CClashedDependencyDescriptor* clash) {
100 mDependencyClashes = clash;
101 return this;
102 }
103
104
105 CNonDeterministicDependencyTrackPoint* CNonDeterministicDependencyNode::addBranchClashes(CClashedDependencyDescriptor* clash) {
106 mClashTrackPoint.addClashes(clash);
107 return &mClashTrackPoint;
108 }
109
110
111 bool CNonDeterministicDependencyNode::updateBranchingTags() {
112 mBranchTag = getDependedBranchingLevel();
113 bool changed = false;
114 CNonDeterministicDependencyTrackPoint* branchTrackPointsIt = mBranchTrackPoints;
115 while (branchTrackPointsIt) {
116 changed |= updateDependencyTrackPointBranchingTag(branchTrackPointsIt,mBranchTag);
117 branchTrackPointsIt = branchTrackPointsIt->getNext();
118 }
119 return changed;
120 }
121
122
123
124 CNonDeterministicDependencyTrackPoint* CNonDeterministicDependencyNode::getClosingDependencyTrackPoint() {
125 return mClosingTrackPoint;
126 }
127
128 CNonDeterministicDependencyTrackPoint* CNonDeterministicDependencyNode::getClosedDependencyTrackPoint() {
129 return mClosedTrackPoint;
130 }
131
132
133 CNonDeterministicDependencyNode* CNonDeterministicDependencyNode::setClosingDependencyTrackPoint(CNonDeterministicDependencyTrackPoint* depTrackPoint) {
134 mClosingTrackPoint = depTrackPoint;
135 return this;
136 }
137
138 CNonDeterministicDependencyNode* CNonDeterministicDependencyNode::setClosedDependencyTrackPoint(CNonDeterministicDependencyTrackPoint* depTrackPoint) {
139 mClosedTrackPoint = depTrackPoint;
140 return this;
141 }
142
143 bool CNonDeterministicDependencyNode::hasClosingDependencyTrackPoint(CNonDeterministicDependencyTrackPoint* depTrackPoint) {
144 return mClosingTrackPoint == depTrackPoint;
145 }
146
147 bool CNonDeterministicDependencyNode::hasClosedDependencyTrackPoint(CNonDeterministicDependencyTrackPoint* depTrackPoint) {
148 return mClosedTrackPoint == depTrackPoint;
149 }
150
151 bool CNonDeterministicDependencyNode::hasClosingDependencyTrackPoint() {
152 return mClosingTrackPoint != nullptr;
153 }
154
155 bool CNonDeterministicDependencyNode::hasClosedDependencyTrackPoint() {
156 return mClosedTrackPoint != nullptr;
157 }
158
159 cint64 CNonDeterministicDependencyNode::getOpenedDependencyTrackingPointsCount() {
160 cint64 opDepTrackPointCount = 0;
161 CNonDeterministicDependencyTrackPoint* branchTrackPointsIt = mBranchTrackPoints;
162 while (branchTrackPointsIt) {
163 if (!branchTrackPointsIt->isClashedOrIrelevantBranch()) {
164 ++opDepTrackPointCount;
165 }
166 branchTrackPointsIt = branchTrackPointsIt->getNext();
167 }
168 return opDepTrackPointCount;
169 }
170
171 bool CNonDeterministicDependencyNode::hasMultipleOpenedDependencyTrackingPoints() {
172 cint64 opDepTrackPointCount = 0;
173 CNonDeterministicDependencyTrackPoint* branchTrackPointsIt = mBranchTrackPoints;
174 while (branchTrackPointsIt) {
175 if (!branchTrackPointsIt->isClashedOrIrelevantBranch()) {
176 ++opDepTrackPointCount;
177 if (opDepTrackPointCount >= 2) {
178 return true;
179 }
180 }
181 branchTrackPointsIt = branchTrackPointsIt->getNext();
182 }
183 return false;
184 }
185
186
187 bool CNonDeterministicDependencyNode::hasOtherOpenedDependencyTrackingPoints(CNonDeterministicDependencyTrackPoint* depTrackPoint) {
188 CNonDeterministicDependencyTrackPoint* branchTrackPointsIt = mBranchTrackPoints;
189 while (branchTrackPointsIt) {
190 if (branchTrackPointsIt != depTrackPoint && !branchTrackPointsIt->isClashedOrIrelevantBranch()) {
191 return true;
192 }
193 branchTrackPointsIt = branchTrackPointsIt->getNext();
194 }
195 return false;
196 }
197
198
199 CBranchTreeNode* CNonDeterministicDependencyNode::getBranchNode() {
200 return mBranchNode;
201 }
202
203
204
205 }; // end namespace Dependency
206
207 }; // end namespace Process
208
209 }; // end namespace Kernel
210
211 }; // end namespace Reasoner
212
213 }; // end namespace Konclude