Debian Codegraph @

Source/Reasoner/Kernel/Algorithm/CTrackedClashedDescriptor.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 "CTrackedClashedDescriptor.h"
22
23
24 namespace Konclude {
25
26 namespace Reasoner {
27
28 namespace Kernel {
29
30 namespace Algorithm {
31
32 CTrackedClashedDescriptor::CTrackedClashedDescriptor() {
33 }
34
35
36 CTrackedClashedDescriptor* CTrackedClashedDescriptor::initTrackedClashedDescriptor(CIndividualProcessNode* indiNode, CConceptDescriptor* conDes, CVariableBindingPath* varBindPath, CDependencyTrackPoint* depTrackPoint) {
37 initClashedDependencyDescriptor(depTrackPoint);
38 mErrorFlag = false;
39 mIndiNodeID = -1;
40 mIndiNodeLevel = -1;
41 mNominalIndiFlag = false;
42 mConceptDescriptor = nullptr;
43 mVarBindPath = nullptr;
44 mDetermisticFlag = false;
45 mIndepenentFlag = false;
46 mBranchingLevelTag = -1;
47 mProcessingTag = -1;
48 mIndiNode = nullptr;
49 if (indiNode) {
50 mIndiNode = indiNode;
51 mIndiNodeID = indiNode->getIndividualNodeID();
52 mIndiNodeLevel = indiNode->getIndividualNominalLevelOrAncestorDepth();
53 mNominalIndiFlag = indiNode->isNominalIndividualNode();
54 } else {
55 mErrorFlag = true;
56 }
57 mConceptDescriptor = conDes;
58 mVarBindPath = varBindPath;
59 if (depTrackPoint) {
60 mDetermisticFlag = depTrackPoint->isPointingToDeterministicDependencyNode();
61 mIndepenentFlag = depTrackPoint->isPointingToIndependentDependencyNode();
62 mProcessingTag = depTrackPoint->getProcessingTag();
63 mBranchingLevelTag = depTrackPoint->getBranchingTag();
64 if (mBranchingLevelTag <= -1) {
65 mErrorFlag = true;
66 }
67 } else {
68 mErrorFlag = true;
69 }
70 return this;
71 }
72
73 CTrackedClashedDescriptor* CTrackedClashedDescriptor::initTrackedClashedDescriptor(CTrackedClashedDescriptor* trackedClashDes) {
74 mErrorFlag = trackedClashDes->mErrorFlag;
75 mIndiNodeID = trackedClashDes->mIndiNodeID;
76 mIndiNodeLevel = trackedClashDes->mIndiNodeLevel;
77 mNominalIndiFlag = trackedClashDes->mNominalIndiFlag;
78 mConceptDescriptor = trackedClashDes->mConceptDescriptor;
79 mDetermisticFlag = trackedClashDes->mDetermisticFlag;
80 mIndepenentFlag = trackedClashDes->mIndepenentFlag;
81 mBranchingLevelTag = trackedClashDes->mBranchingLevelTag;
82 mProcessingTag = trackedClashDes->mProcessingTag;
83 mVarBindPath = trackedClashDes->mVarBindPath;
84 mIndiNode = trackedClashDes->mIndiNode;
85 initClashedDependencyDescriptor(trackedClashDes->mDependencyTrackPoint);
86 return this;
87 }
88
89
90 CTrackedClashedDescriptor* CTrackedClashedDescriptor::initTrackedClashedDescriptor(CTrackedClashedDescriptor* trackedClashDesForIndiNode, CConceptDescriptor* conDes, CVariableBindingPath* varBindPath, CDependencyTrackPoint* depTrackPoint) {
91 mErrorFlag = trackedClashDesForIndiNode->mErrorFlag;
92 mIndiNodeID = trackedClashDesForIndiNode->mIndiNodeID;
93 mIndiNodeLevel = trackedClashDesForIndiNode->mIndiNodeLevel;
94 mNominalIndiFlag = trackedClashDesForIndiNode->mNominalIndiFlag;
95 mIndiNode = trackedClashDesForIndiNode->mIndiNode;
96 mVarBindPath = varBindPath;
97 initClashedDependencyDescriptor(depTrackPoint);
98 mConceptDescriptor = conDes;
99 if (depTrackPoint) {
100 mDetermisticFlag = depTrackPoint->isPointingToDeterministicDependencyNode();
101 mIndepenentFlag = depTrackPoint->isPointingToIndependentDependencyNode();
102 mProcessingTag = depTrackPoint->getProcessingTag();
103 mBranchingLevelTag = depTrackPoint->getBranchingTag();
104 if (mBranchingLevelTag <= -1) {
105 mErrorFlag = true;
106 }
107 } else {
108 mErrorFlag = true;
109 }
110 return this;
111 }
112
113
114
115
116
117 CTrackedClashedDescriptor* CTrackedClashedDescriptor::initTrackedClashedDescriptor(CTrackedClashedDescriptor* trackedClashDesForIndiNode, CConceptDescriptor* conDes, CDependencyTrackPoint* depTrackPoint) {
118 initTrackedClashedDescriptor(trackedClashDesForIndiNode,conDes,trackedClashDesForIndiNode->getVariableBindingPath(),depTrackPoint);
119 return this;
120 }
121
122
123 CIndividualProcessNode* CTrackedClashedDescriptor::getAppropriatedIndividual() {
124 return mIndiNode;
125 }
126
127
128 bool CTrackedClashedDescriptor::isAppropriatedIndividualNominal() {
129 return mNominalIndiFlag;
130 }
131
132 cint64 CTrackedClashedDescriptor::getAppropriatedIndividualID() {
133 return mIndiNodeID;
134 }
135
136 cint64 CTrackedClashedDescriptor::getAppropriatedIndividualLevel() {
137 return mIndiNodeLevel;
138 }
139
140
141 cint64 CTrackedClashedDescriptor::getBranchingLevelTag() {
142 return mBranchingLevelTag;
143 }
144
145 cint64 CTrackedClashedDescriptor::getProcessingTag() {
146 return mProcessingTag;
147 }
148
149
150 bool CTrackedClashedDescriptor::isPointingToDeterministicDependencyNode() {
151 return mDetermisticFlag;
152 }
153
154 bool CTrackedClashedDescriptor::isPointingToNonDeterministicDependencyNode() {
155 return !mDetermisticFlag;
156 }
157
158
159 bool CTrackedClashedDescriptor::isPointingToIndependentDependencyNode() {
160 return mIndepenentFlag;
161 }
162
163
164 bool CTrackedClashedDescriptor::isTrackingError() {
165 return mErrorFlag;
166 }
167
168
169 CConceptDescriptor* CTrackedClashedDescriptor::getConceptDescriptor() {
170 return mConceptDescriptor;
171 }
172
173 CTrackedClashedDescriptor* CTrackedClashedDescriptor::setConceptDescriptor(CConceptDescriptor* conDes) {
174 mConceptDescriptor = conDes;
175 return this;
176 }
177
178
179 CVariableBindingPath* CTrackedClashedDescriptor::getVariableBindingPath() {
180 return mVarBindPath;
181 }
182
183 bool CTrackedClashedDescriptor::candidateTracking(bool* trackingError, bool* nominalOccured, cint64* maxBranchLevel, cint64* minIndividualLevel) {
184 bool usingCandidate = false;
185 if (mErrorFlag) {
186 if (trackingError && !*trackingError) {
187 *trackingError = true;
188 usingCandidate = true;
189 }
190 } else {
191 if (maxBranchLevel && *maxBranchLevel < mBranchingLevelTag) {
192 *maxBranchLevel = mBranchingLevelTag;
193 usingCandidate = true;
194 }
195 if (minIndividualLevel && *minIndividualLevel > mIndiNodeLevel) {
196 *minIndividualLevel = mIndiNodeLevel;
197 usingCandidate = true;
198 }
199 if (nominalOccured && mNominalIndiFlag && !*nominalOccured) {
200 *nominalOccured = mNominalIndiFlag;
201 usingCandidate = true;
202 }
203 }
204 return usingCandidate;
205 }
206
207
208 bool CTrackedClashedDescriptor::isProcessedAfter(cint64 processingTag) {
209 return mProcessingTag > processingTag;
210 }
211
212 CTrackedClashedDescriptor* CTrackedClashedDescriptor::append(CTrackedClashedDescriptor* trackedClashedDescriptor) {
213 return (CTrackedClashedDescriptor*)CClashedDependencyDescriptor::append(trackedClashedDescriptor);
214 }
215
216 CTrackedClashedDescriptor* CTrackedClashedDescriptor::getNextDescriptor() {
217 return (CTrackedClashedDescriptor*)getNext();
218 }
219
220
221 }; // end namespace Algorithm
222
223 }; // end namespace Kernel
224
225 }; // end namespace Reasoner
226
227 }; // end namespace Konclude