Debian Codegraph @

Source/Reasoner/Kernel/Process/CSuccessorRoleHash.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 "CSuccessorRoleHash.h"
22
23
24 namespace Konclude {
25
26 namespace Reasoner {
27
28 namespace Kernel {
29
30 namespace Process {
31
32
33 CSuccessorRoleHash::CSuccessorRoleHash(CProcessContext* context) : mContext(context) {
34 mSuccessorLinkHash = CObjectParameterizingAllocator< CPROCESSHASH<cint64, CIndividualLinkEdge*>, CProcessContext* >::allocateAndConstructAndParameterize(mContext->getMemoryAllocationManager(), mContext);
35 mPrevSuccessorLinkHash = nullptr;
36 mPrevValidatingRequired = false;
37 }
38
39
40 CSuccessorRoleHash* CSuccessorRoleHash::initSuccessorRoleHash(CSuccessorRoleHash* prevRoleSuccHash) {
41 if (prevRoleSuccHash) {
42
43 if (!prevRoleSuccHash->mPrevSuccessorLinkHash && prevRoleSuccHash->mSuccessorLinkHash->size() <= 100) {
44 *mSuccessorLinkHash = *prevRoleSuccHash->mSuccessorLinkHash;
45 mPrevSuccessorLinkHash = nullptr;
46 mPrevValidatingRequired = false;
47 } else if (!prevRoleSuccHash->mPrevSuccessorLinkHash && prevRoleSuccHash->mSuccessorLinkHash->size() > 100) {
48 mSuccessorLinkHash->clear();
49 mPrevSuccessorLinkHash = prevRoleSuccHash->mSuccessorLinkHash;
50 mPrevValidatingRequired = false;
51 } else {
52
53 if (prevRoleSuccHash->mSuccessorLinkHash->size() * 10 > prevRoleSuccHash->mPrevSuccessorLinkHash->size()) {
54 *mSuccessorLinkHash = *prevRoleSuccHash->mSuccessorLinkHash;
55
56 for (CPROCESSHASH<cint64, CIndividualLinkEdge*>::const_iterator it = prevRoleSuccHash->mPrevSuccessorLinkHash->constBegin(), itEnd = prevRoleSuccHash->mPrevSuccessorLinkHash->constEnd(); it != itEnd; ++it) {
57 cint64 neighbourId = it.key();
58 if (!mPrevValidatingRequired || !prevRoleSuccHash->mSuccessorLinkHash->contains(neighbourId)) {
59 CIndividualLinkEdge* link = it.value();
60 mSuccessorLinkHash->insertMulti(neighbourId, link);
61 }
62 }
63 mPrevSuccessorLinkHash = nullptr;
64 mPrevValidatingRequired = false;
65 } else {
66 *mSuccessorLinkHash = *prevRoleSuccHash->mSuccessorLinkHash;
67 mPrevSuccessorLinkHash = prevRoleSuccHash->mPrevSuccessorLinkHash;
68 mPrevValidatingRequired = false;
69 }
70
71 }
72
73 } else {
74 mPrevValidatingRequired = false;
75 mSuccessorLinkHash->clear();
76 mPrevSuccessorLinkHash = nullptr;
77 }
78 return this;
79 }
80
81 CSuccessorRoleHash* CSuccessorRoleHash::insertSuccessorRoleLink(cint64 indi, CIndividualLinkEdge* link) {
82
83 if (mPrevSuccessorLinkHash && mPrevSuccessorLinkHash->contains(indi) && !mSuccessorLinkHash->contains(indi)) {
84 for (CPROCESSHASH<cint64, CIndividualLinkEdge*>::const_iterator it = mPrevSuccessorLinkHash->find(indi), itEnd = mPrevSuccessorLinkHash->constEnd(); it != itEnd; ++it) {
85 cint64 indiId = it.key();
86 if (indiId != indi) {
87 break;
88 }
89 CIndividualLinkEdge* link = it.value();
90 mSuccessorLinkHash->insertMulti(indiId, link);
91 mPrevValidatingRequired = true;
92 }
93 }
94
95 mSuccessorLinkHash->insertMulti(indi,link);
96 return this;
97 }
98
99 CSuccessorRoleIterator CSuccessorRoleHash::getSuccessorRoleIterator(cint64 indi) {
100 if (!mPrevSuccessorLinkHash || mSuccessorLinkHash->contains(indi)) {
101 return CSuccessorRoleIterator(indi, mSuccessorLinkHash->find(indi), mSuccessorLinkHash->end());
102 } else if (mPrevSuccessorLinkHash && mPrevSuccessorLinkHash->contains(indi)) {
103 return CSuccessorRoleIterator(indi, mPrevSuccessorLinkHash->find(indi), mPrevSuccessorLinkHash->end());
104 } else {
105 return CSuccessorRoleIterator(indi, mSuccessorLinkHash->end(), mSuccessorLinkHash->end());
106 }
107 }
108
109 bool CSuccessorRoleHash::hasSuccessorIndividualNode(cint64 indi) {
110 if (mSuccessorLinkHash->contains(indi)) {
111 return true;
112 }
113 if (mPrevSuccessorLinkHash && mPrevSuccessorLinkHash->contains(indi)) {
114 return true;
115 }
116 return false;
117 }
118
119 CSuccessorRoleHash* CSuccessorRoleHash::removeSuccessor(cint64 indi) {
120
121 if (mPrevSuccessorLinkHash && mPrevSuccessorLinkHash->contains(indi)) {
122 for (CPROCESSHASH<cint64, CIndividualLinkEdge*>::const_iterator it = mPrevSuccessorLinkHash->constBegin(), itEnd = mPrevSuccessorLinkHash->constEnd(); it != itEnd; ) {
123 cint64 indiId = it.key();
124 if (!mPrevValidatingRequired || !mSuccessorLinkHash->contains(indiId)) {
125 do {
126 CIndividualLinkEdge* link = it.value();
127 mSuccessorLinkHash->insertMulti(indiId, link);
128 ++it;
129 } while (it != itEnd && it.key() == indiId);
130 } else {
131 ++it;
132 }
133 }
134 mPrevSuccessorLinkHash = nullptr;
135 }
136
137 mSuccessorLinkHash->remove(indi);
138 return this;
139 }
140
141 CSuccessorIterator CSuccessorRoleHash::getSuccessorIterator() {
142 if (mPrevSuccessorLinkHash) {
143 if (mPrevValidatingRequired) {
144 return CSuccessorIterator(mSuccessorLinkHash->begin(), mSuccessorLinkHash->end(), mPrevSuccessorLinkHash->begin(), mPrevSuccessorLinkHash->end(), mSuccessorLinkHash);
145 } else {
146 return CSuccessorIterator(mSuccessorLinkHash->begin(), mSuccessorLinkHash->end(), mPrevSuccessorLinkHash->begin(), mPrevSuccessorLinkHash->end());
147 }
148 } else {
149 return CSuccessorIterator(mSuccessorLinkHash->begin(), mSuccessorLinkHash->end());
150 }
151 }
152
153
154
155 }; // end namespace Process
156
157 }; // end namespace Kernel
158
159 }; // end namespace Reasoner
160
161 }; // end namespace Konclude