Debian Codegraph @

Source/Utilities/CDynRefBucket.hpp

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 #ifndef KONCLUDE_UTILITIES_CDYNREFBUCKET_H
22 #define KONCLUDE_UTILITIES_CDYNREFBUCKET_H
23
24 // Libraries includes
25 #include <QSet>
26
27
28 // Namespace includes
29
30
31 // Other includes
32
33
34 // Logger includes
35 #include "Logger/CLogger.h"
36
37 using namespace Konclude::Logger;
38
39
40 namespace Konclude {
41
42 namespace Utilities {
43
44
45 /*!
46 *
47 * \class CDynRefBucket
48 * \author Andreas Steigmiller
49 * \version 0.1
50 * \brief TODO
51 *
52 */
53 template<class T>
54 class CDynRefBucket {
55 // public methods
56 public:
57 //! Constructor
58 CDynRefBucket(qint64 setBucketSize = 32, qint64 setItemSize = 1);
59
60 //! Destructor
61 virtual ~CDynRefBucket();
62
63 bool isLocal(qint64 index);
64 bool isReference(qint64 index);
65
66 void reference(CDynRefBucket<T> *ref);
67
68 void clear();
69
70 T *getData(qint64 index);
71 T *getLocalData(qint64 index);
72 T *getReferenceData(qint64 index);
73
74 void setLocalData(qint64 index, T *data);
75 void setData(qint64 index, T *data);
76
77 // protected methods
78 protected:
79
80 // private methods
81 private:
82
83 // private variables
84 private:
85 CDynRefBucket<T> *refBucket;
86
87 QPair<bool, T *> *refDataVec;
88 qint64 itemSize;
89 qint64 bucketSize;
90
91 };
92
93
94 template<class T>
95 CDynRefBucket<T>::CDynRefBucket(qint64 setBucketSize, qint64 setItemSize) {
96 refBucket = 0;
97 refDataVec = 0;
98 itemSize = setItemSize;
99 bucketSize = setBucketSize;
100 }
101
102
103 template<class T>
104 CDynRefBucket<T>::~CDynRefBucket() {
105 clear();
106 }
107
108
109 template<class T>
110 void CDynRefBucket<T>::clear() {
111 refBucket = 0;
112 if (refDataVec) {
113 delete[] refDataVec;
114 refDataVec = 0;
115 }
116 }
117
118
119 template<class T>
120 void CDynRefBucket<T>::setData(qint64 index, T *data) {
121 // writing is allways local
122 setLocalData(index,data);
123 }
124
125
126 template<class T>
127 void CDynRefBucket<T>::setLocalData(qint64 index, T *data) {
128 if (!refDataVec) {
129 refDataVec = new QPair<bool, T *>[bucketSize];
130
131 if (refBucket) {
132 // init whole vector as referenced
133 for (qint64 i = 0; i < bucketSize; ++i) {
134 refDataVec[i].first = false;
135 refDataVec[i].second = refBucket->refDataVec[i].second;
136 }
137 } else {
138 // init whole vector as not referenced
139 for (qint64 i = 0; i < bucketSize; ++i) {
140 refDataVec[i].first = true;
141 refDataVec[i].second = 0;
142 }
143 }
144 }
145
146 qint64 itemIndex = index / itemSize;
147 if (itemIndex < bucketSize) {
148 refDataVec[itemIndex].first = true;
149 refDataVec[itemIndex].second = data;
150 }
151 }
152
153
154 template<class T>
155 T *CDynRefBucket<T>::getData(qint64 index) {
156 T *val = 0;
157
158 QPair<bool, T *> *lookupRefDataVec = refDataVec;
159
160 if (!lookupRefDataVec) {
161 // there is no local data
162 if (refBucket) {
163 // use the referenced data, if there is one
164 lookupRefDataVec = refBucket->refDataVec;
165 }
166 }
167 if (lookupRefDataVec) {
168 qint64 itemIndex = index / itemSize;
169 if (itemIndex < bucketSize) {
170 // index must be in vector size
171 QPair<bool, T *> *refDataPair = lookupRefDataVec + itemIndex;
172 // data is local available or is referenced, in both case it has to be returned
173 val = refDataPair->second;
174 }
175 }
176 return val;
177 }
178
179
180 template<class T>
181 T *CDynRefBucket<T>::getLocalData(qint64 index) {
182 T *val = 0;
183
184 QPair<bool, T *> *lookupRefDataVec = refDataVec;
185
186 if (lookupRefDataVec) {
187 qint64 itemIndex = index / itemSize;
188 if (itemIndex < bucketSize) {
189 // index must be in vector size
190 QPair<bool, T *> *refDataPair = lookupRefDataVec + itemIndex;
191 if (refDataPair->first == true) {
192 // data is local available and has to be returned
193 val = refDataPair->second;
194 }
195 }
196 }
197 return val;
198 }
199
200
201 template<class T>
202 T *CDynRefBucket<T>::getReferenceData(qint64 index) {
203 T *val = 0;
204
205 QPair<bool, T *> *lookupRefDataVec = refDataVec;
206 bool referenced = false;
207
208 if (!lookupRefDataVec) {
209 // there is no local data
210 if (refBucket) {
211 // use the referenced data, if there is one
212 lookupRefDataVec = refBucket->refDataVec;
213 referenced = true;
214 }
215 }
216 if (lookupRefDataVec) {
217 qint64 itemIndex = index / itemSize;
218 if (itemIndex < bucketSize) {
219 // index must be in vector size
220 QPair<bool, T *> *refDataPair = lookupRefDataVec + itemIndex;
221 if (refDataPair->first == false || referenced) {
222 // data is referenced available and has to be returned
223 val = refDataPair->second;
224 }
225 }
226 }
227 return val;
228 }
229
230
231
232 template<class T>
233 bool CDynRefBucket<T>::isLocal(qint64 index) {
234
235 QPair<bool, T *> *lookupRefDataVec = refDataVec;
236
237 if (lookupRefDataVec) {
238 qint64 itemIndex = index / itemSize;
239 if (itemIndex < bucketSize) {
240 // index must be in vector size
241 QPair<bool, T *> *refDataPair = lookupRefDataVec + itemIndex;
242 if (refDataPair->first == true) {
243 // test whether data is local available
244 return refDataPair->second != 0;
245 }
246 }
247 }
248 return false;
249 }
250
251
252 template<class T>
253 bool CDynRefBucket<T>::isReference(qint64 index) {
254 QPair<bool, T *> *lookupRefDataVec = refDataVec;
255 bool referenced = false;
256
257 if (!lookupRefDataVec) {
258 // there is no local data
259 if (refBucket) {
260 // use the referenced data, if there is one
261 lookupRefDataVec = refBucket->refDataVec;
262 referenced = true;
263 }
264 }
265 if (lookupRefDataVec) {
266 qint64 itemIndex = index / itemSize;
267 if (itemIndex < bucketSize) {
268 // index must be in vector size
269 QPair<bool, T *> *refDataPair = lookupRefDataVec + itemIndex;
270 if (refDataPair->first == false || referenced) {
271 // test whether data is referenced available
272 return refDataPair->second != 0;
273 }
274 }
275 }
276 return false;
277 }
278
279 template<class T>
280 void CDynRefBucket<T>::reference(CDynRefBucket<T> *ref) {
281 clear();
282 refBucket = ref;
283 while (refBucket != 0 && refBucket->refDataVec == 0) {
284 refBucket = refBucket->refBucket;
285 }
286
287 if (refBucket) {
288 itemSize = refBucket->itemSize;
289 bucketSize = refBucket->bucketSize;
290 }
291 }
292
293
294
295 }; // end namespace Utilities
296
297 }; // end namespace Konclude
298
299 #endif // KONCLUDE_UTILITIES_CDYNREFBUCKET_H