Debian Codegraph @

Source/Reasoner/Kernel/Process/CLinkedRoleSaturationSuccessorHash.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 "CLinkedRoleSaturationSuccessorHash.h"
22 #include "CIndividualSaturationProcessNode.h"
23
24
25 namespace Konclude {
26
27 namespace Reasoner {
28
29 namespace Kernel {
30
31 namespace Process {
32
33
34 CLinkedRoleSaturationSuccessorHash::CLinkedRoleSaturationSuccessorHash(CProcessContext* context) : mContext(context),mRoleSuccDataHash(context) {
35 }
36
37
38 CLinkedRoleSaturationSuccessorHash* CLinkedRoleSaturationSuccessorHash::initRoleSuccessorHash() {
39 mLastExaminedConDes = nullptr;
40 mLastExaminedRoleAssLinker = nullptr;
41 mRoleSuccDataHash.clear();
42 return this;
43 }
44
45 CLinkedRoleSaturationSuccessorHash* CLinkedRoleSaturationSuccessorHash::copyRoleSuccessorHash(CLinkedRoleSaturationSuccessorHash* copyRoleSuccHash) {
46 mRoleSuccDataHash = copyRoleSuccHash->mRoleSuccDataHash;
47 return this;
48 }
49
50
51 bool CLinkedRoleSaturationSuccessorHash::hasActiveLinkedSuccessor(CRole* role, CIndividualSaturationProcessNode* linkedIndi, CRole* creationRole, cint64 linkCount) {
52 CLinkedRoleSaturationSuccessorData** roleSuccData = mRoleSuccDataHash.valuePointer(role);
53 if (roleSuccData && *roleSuccData) {
54 CSaturationSuccessorData** succData = nullptr;
55 if ((*roleSuccData)->mSuccNodeDataMap.tryGetValuePointer(linkedIndi->getIndividualID(),succData)) {
56 if (succData && (*succData)->mActiveCount >= 1 && (*succData)->mSuccCount >= linkCount) {
57 if (!creationRole) {
58 return true;
59 }
60 for (CXNegLinker<CRole*>* creationRoleIt = (*succData)->mCreationRoleLinker; creationRoleIt; creationRoleIt = creationRoleIt->getNext()) {
61 if (!creationRoleIt->isNegated() && creationRole == creationRoleIt->getData()) {
62 return true;
63 }
64 }
65 }
66 }
67 }
68 return false;
69 }
70
71 bool CLinkedRoleSaturationSuccessorHash::hasLinkedSuccessor(CRole* role, CIndividualSaturationProcessNode* linkedIndi, CRole* creationRole, cint64 linkCount) {
72 CLinkedRoleSaturationSuccessorData** roleSuccData = mRoleSuccDataHash.valuePointer(role);
73 if (roleSuccData && *roleSuccData) {
74 CSaturationSuccessorData** succData = nullptr;
75 if ((*roleSuccData)->mSuccNodeDataMap.tryGetValuePointer(linkedIndi->getIndividualID(),succData)) {
76 if (succData && (*succData)->mSuccCount >= linkCount) {
77 if (!creationRole) {
78 return true;
79 }
80 for (CXNegLinker<CRole*>* creationRoleIt = (*succData)->mCreationRoleLinker; creationRoleIt; creationRoleIt = creationRoleIt->getNext()) {
81 if (creationRole == creationRoleIt->getData()) {
82 return true;
83 }
84 }
85 }
86 }
87 }
88 return false;
89 }
90
91
92 CSaturationSuccessorData*& CLinkedRoleSaturationSuccessorHash::getLinkedRoleSuccessorData(CLinkedRoleSaturationSuccessorData*& roleSuccData, cint64 linkedIndiID, bool forceNewCreation) {
93 CSaturationSuccessorData*& succData = roleSuccData->mSuccNodeDataMap[linkedIndiID];
94 if (!succData || forceNewCreation) {
95 CSaturationSuccessorData* prevSuccData = succData;
96 succData = CObjectAllocator<CSaturationSuccessorData>::allocateAndConstruct(mContext->getUsedMemoryAllocationManager());
97 if (prevSuccData) {
98 succData->mSuccCount = prevSuccData->mSuccCount;
99 succData->mActiveCount = prevSuccData->mActiveCount;
100 succData->mExtension = prevSuccData->mExtension;
101 succData->mSuccIndiNode = prevSuccData->mSuccIndiNode;
102 succData->mCreationRoleLinker = prevSuccData->mCreationRoleLinker;
103 succData->mVALUENominalID = prevSuccData->mVALUENominalID;
104 succData->mVALUENominalConnection = prevSuccData->mVALUENominalConnection;
105 prevSuccData->mActiveCount = 0;
106 }
107 succData->mNextLink = roleSuccData->mLastLink;
108 roleSuccData->mLastLink = succData;
109
110 }
111 return succData;
112 }
113
114
115
116
117 bool CLinkedRoleSaturationSuccessorHash::hasActiveCreationRole(CSaturationSuccessorData* succData, CRole* creationRole) {
118 for (CXNegLinker<CRole*>* creationRoleLinkerIt = succData->mCreationRoleLinker; creationRoleLinkerIt; creationRoleLinkerIt = creationRoleLinkerIt->getNext()) {
119 if (!creationRoleLinkerIt->isNegated()) {
120 if (creationRoleLinkerIt->getData() == creationRole) {
121 return true;
122 }
123 }
124 }
125 return false;
126 }
127
128
129
130 CLinkedRoleSaturationSuccessorHash* CLinkedRoleSaturationSuccessorHash::addLinkedSuccessor(CRole* role, CIndividualSaturationProcessNode* linkedIndi, CRole* creationRole, cint64 linkCount, bool forceAddLink) {
131 CLinkedRoleSaturationSuccessorData*& roleSuccData = getLinkedRoleSuccessorData(role,true);
132 if (roleSuccData) {
133 CSaturationSuccessorData*& succData = getLinkedRoleSuccessorData(roleSuccData,linkedIndi->getIndividualID(),true);
134 bool creationRoleAlreadyExists = hasActiveCreationRole(succData,creationRole);
135 if (!creationRoleAlreadyExists) {
136 ++succData->mActiveCount;
137 }
138 succData->mExtension = false;
139 succData->mSuccIndiNode = linkedIndi;
140 if (!creationRoleAlreadyExists) {
141 succData->mCreationRoleLinker = CObjectAllocator< CXNegLinker<CRole*> >::allocateAndConstruct(mContext->getUsedMemoryAllocationManager())->initNegLinker(creationRole,false)->append(succData->mCreationRoleLinker);
142 }
143 cint64 linkCountDiff = 0;
144 if (forceAddLink) {
145 linkCountDiff += linkCount;
146 } else {
147 if (succData->mSuccCount < linkCount) {
148 linkCountDiff = linkCount-succData->mSuccCount;
149 }
150 }
151 succData->mSuccCount += linkCountDiff;
152 roleSuccData->mSuccCount += linkCountDiff;
153 }
154 return this;
155 }
156
157
158
159 CLinkedRoleSaturationSuccessorHash* CLinkedRoleSaturationSuccessorHash::addLinkedVALUESuccessor(CRole* role, cint64 nominalID, CRole* creationRole) {
160 CLinkedRoleSaturationSuccessorData*& roleSuccData = getLinkedRoleSuccessorData(role,true);
161 if (roleSuccData) {
162 CSaturationSuccessorData*& succData = getLinkedRoleSuccessorData(roleSuccData,-nominalID,true);
163 bool creationRoleAlreadyExists = hasActiveCreationRole(succData,creationRole);
164 if (!creationRoleAlreadyExists) {
165 ++succData->mActiveCount;
166 }
167 succData->mExtension = false;
168 succData->mVALUENominalConnection = true;
169 succData->mVALUENominalID = nominalID;
170 if (!creationRoleAlreadyExists) {
171 succData->mCreationRoleLinker = CObjectAllocator< CXNegLinker<CRole*> >::allocateAndConstruct(mContext->getUsedMemoryAllocationManager())->initNegLinker(creationRole,false)->append(succData->mCreationRoleLinker);
172 }
173 cint64 linkCountDiff = 0;
174 if (succData->mSuccCount < 1) {
175 linkCountDiff = 1;
176 }
177 succData->mSuccCount += linkCountDiff;
178 roleSuccData->mSuccCount += linkCountDiff;
179 }
180 return this;
181 }
182
183
184
185
186
187 CLinkedRoleSaturationSuccessorHash* CLinkedRoleSaturationSuccessorHash::addExtensionSuccessor(CRole* role, CIndividualSaturationProcessNode* linkedIndi, CRole* creationRole, cint64 linkCount) {
188 CLinkedRoleSaturationSuccessorData*& roleSuccData = getLinkedRoleSuccessorData(role,true);
189 if (roleSuccData) {
190 CSaturationSuccessorData*& succData = getLinkedRoleSuccessorData(roleSuccData,linkedIndi->getIndividualID(),true);
191 bool creationRoleAlreadyExists = hasActiveCreationRole(succData,creationRole);
192 if (!creationRoleAlreadyExists) {
193 ++succData->mActiveCount;
194 }
195 succData->mExtension = true;
196 succData->mSuccIndiNode = linkedIndi;
197 if (!creationRoleAlreadyExists) {
198 succData->mCreationRoleLinker = CObjectAllocator< CXNegLinker<CRole*> >::allocateAndConstruct(mContext->getUsedMemoryAllocationManager())->initNegLinker(creationRole,false)->append(succData->mCreationRoleLinker);
199 }
200 cint64 linkCountDiff = 0;
201 if (succData->mSuccCount < linkCount) {
202 linkCountDiff = linkCount-succData->mSuccCount;
203 }
204 succData->mSuccCount += linkCountDiff;
205 roleSuccData->mSuccCount += linkCountDiff;
206 }
207 return this;
208 }
209
210
211
212 CLinkedRoleSaturationSuccessorHash* CLinkedRoleSaturationSuccessorHash::setSuccessorMergedCreation(CRole* role, CIndividualSaturationProcessNode* linkedIndi) {
213 CLinkedRoleSaturationSuccessorData*& roleSuccData = getLinkedRoleSuccessorData(role,true);
214 if (roleSuccData) {
215 CSaturationSuccessorData*& succData = getLinkedRoleSuccessorData(roleSuccData,linkedIndi->getIndividualID());
216 //succData->mMergedCreation = true;
217 }
218 return this;
219 }
220
221
222
223 CLinkedRoleSaturationSuccessorHash* CLinkedRoleSaturationSuccessorHash::deactivateLinkedSuccessor(CRole* role, CIndividualSaturationProcessNode* linkedIndi, CRole* creationRole) {
224 CLinkedRoleSaturationSuccessorData*& roleSuccData = getLinkedRoleSuccessorData(role,true);
225 if (roleSuccData) {
226 CSaturationSuccessorData*& succData = getLinkedRoleSuccessorData(roleSuccData,linkedIndi->getIndividualID());
227 if (succData->mActiveCount > 0) {
228 --succData->mActiveCount;
229 for (CXNegLinker<CRole*>* creationRoleIt = succData->mCreationRoleLinker; creationRoleIt; creationRoleIt = creationRoleIt->getNext()) {
230 if (creationRoleIt->getData() == creationRole && !creationRoleIt->isNegated()) {
231 creationRoleIt->setNegation(true);
232 break;
233 }
234 }
235 if (succData->mActiveCount <= 0) {
236 roleSuccData->mSuccCount -= succData->mSuccCount;
237 succData->mSuccCount = 0;
238 }
239 }
240 }
241 return this;
242 }
243
244
245 CLinkedRoleSaturationSuccessorHash* CLinkedRoleSaturationSuccessorHash::reduceLinkedSuccessorCount(CRole* role, CIndividualSaturationProcessNode* linkedIndi, CRole* creationRole, cint64 expectedLinkCount, cint64 remainingLinkCount) {
246 CLinkedRoleSaturationSuccessorData*& roleSuccData = getLinkedRoleSuccessorData(role,true);
247 if (roleSuccData) {
248 CSaturationSuccessorData*& succData = getLinkedRoleSuccessorData(roleSuccData,linkedIndi->getIndividualID());
249 if (succData->mActiveCount > 0) {
250 if (expectedLinkCount == roleSuccData->mSuccCount) {
251 if (remainingLinkCount == 0) {
252 --succData->mActiveCount;
253 for (CXNegLinker<CRole*>* creationRoleIt = succData->mCreationRoleLinker; creationRoleIt; creationRoleIt = creationRoleIt->getNext()) {
254 if (creationRoleIt->getData() == creationRole && !creationRoleIt->isNegated()) {
255 creationRoleIt->setNegation(true);
256 break;
257 }
258 }
259 }
260 if (succData->mActiveCount <= 0) {
261 roleSuccData->mSuccCount -= succData->mSuccCount;
262 succData->mSuccCount = 0;
263 } else {
264 succData->mSuccCount = remainingLinkCount;
265 }
266 }
267
268 }
269 }
270 return this;
271 }
272
273
274
275 CLinkedRoleSaturationSuccessorHash* CLinkedRoleSaturationSuccessorHash::increaseLinkedSuccessorCount(CRole* role, CIndividualSaturationProcessNode* linkedIndi, CRole* creationRole, cint64 incLinkCount) {
276 CLinkedRoleSaturationSuccessorData*& roleSuccData = getLinkedRoleSuccessorData(role,true);
277 if (roleSuccData) {
278 CSaturationSuccessorData*& succData = getLinkedRoleSuccessorData(roleSuccData,linkedIndi->getIndividualID());
279 if (succData->mActiveCount > 0) {
280 succData->mSuccCount += incLinkCount;
281 roleSuccData->mSuccCount += incLinkCount;
282 }
283 }
284 return this;
285 }
286
287
288 CPROCESSHASH<CRole*,CLinkedRoleSaturationSuccessorData*>* CLinkedRoleSaturationSuccessorHash::getLinkedRoleSuccessorHash() {
289 return &mRoleSuccDataHash;
290 }
291
292 CLinkedRoleSaturationSuccessorData*& CLinkedRoleSaturationSuccessorHash::getLinkedRoleSuccessorData(CRole* role, bool create) {
293 CLinkedRoleSaturationSuccessorData*& roleSuccData = mRoleSuccDataHash[role];
294 if (!roleSuccData) {
295 roleSuccData = CObjectAllocator<CLinkedRoleSaturationSuccessorData>::allocateAndConstruct(mContext->getUsedMemoryAllocationManager());
296 }
297 return roleSuccData;
298 }
299
300 bool CLinkedRoleSaturationSuccessorHash::hasLinkedRoleSuccessorData(CRole* role) {
301 CLinkedRoleSaturationSuccessorData* roleSuccData = mRoleSuccDataHash.value(role);
302 if (roleSuccData && roleSuccData->mSuccCount > 0) {
303 return true;
304 }
305 return false;
306 }
307
308 CConceptSaturationDescriptor* CLinkedRoleSaturationSuccessorHash::getLastExaminedConceptDescriptor() {
309 return mLastExaminedConDes;
310 }
311
312 CLinkedRoleSaturationSuccessorHash* CLinkedRoleSaturationSuccessorHash::setLastExaminedConceptDescriptor(CConceptSaturationDescriptor* conDes) {
313 mLastExaminedConDes = conDes;
314 return this;
315 }
316
317 CSaturationSuccessorRoleAssertionLinker* CLinkedRoleSaturationSuccessorHash::getLastExaminedRoleAssertionLinker() {
318 return mLastExaminedRoleAssLinker;
319 }
320
321 CLinkedRoleSaturationSuccessorHash* CLinkedRoleSaturationSuccessorHash::setLastExaminedRoleAssertionLinker(CSaturationSuccessorRoleAssertionLinker* roleAssLinker) {
322 mLastExaminedRoleAssLinker = roleAssLinker;
323 return this;
324 }
325
326 }; // end namespace Process
327
328 }; // end namespace Kernel
329
330 }; // end namespace Reasoner
331
332 }; // end namespace Konclude