20 template <
typename TYPE>
21 tlp::MutableContainer<TYPE>::MutableContainer()
22 : vData(new
std::deque<typename StoredType<TYPE>::Value>()), hData(nullptr), minIndex(UINT_MAX),
23 maxIndex(UINT_MAX), defaultValue(StoredType<TYPE>::defaultValue()), state(VECT),
25 ratio(double(sizeof(typename
tlp::StoredType<TYPE>::Value)) /
26 (3.0 * double(sizeof(void *)) + double(sizeof(typename
tlp::StoredType<TYPE>::Value)))),
29 template <
typename TYPE>
30 tlp::MutableContainer<TYPE>::~MutableContainer() {
34 if (StoredType<TYPE>::isPointer) {
36 typename std::deque<typename StoredType<TYPE>::Value>::const_iterator it = vData->begin();
38 while (it != vData->end()) {
39 if ((*it) != defaultValue)
40 StoredType<TYPE>::destroy(*it);
52 if (StoredType<TYPE>::isPointer) {
54 typename TLP_HASH_MAP<unsigned int, typename StoredType<TYPE>::Value>::const_iterator it =
57 while (it != hData->end()) {
58 StoredType<TYPE>::destroy((*it).second);
69 tlp::error() << __PRETTY_FUNCTION__ <<
"unexpected state value (serious bug)" << std::endl;
73 StoredType<TYPE>::destroy(defaultValue);
76 template <
typename TYPE>
77 void tlp::MutableContainer<TYPE>::setDefault(
typename StoredType<TYPE>::ReturnedConstValue value) {
78 StoredType<TYPE>::destroy(defaultValue);
79 defaultValue = StoredType<TYPE>::clone(value);
82 template <
typename TYPE>
83 void tlp::MutableContainer<TYPE>::setAll(
typename StoredType<TYPE>::ReturnedConstValue value) {
87 if (StoredType<TYPE>::isPointer) {
89 typename std::deque<typename StoredType<TYPE>::Value>::const_iterator it = vData->begin();
91 while (it != vData->end()) {
92 if ((*it) != defaultValue)
93 StoredType<TYPE>::destroy(*it);
104 if (StoredType<TYPE>::isPointer) {
106 typename TLP_HASH_MAP<unsigned int, typename StoredType<TYPE>::Value>::const_iterator it =
109 while (it != hData->end()) {
110 StoredType<TYPE>::destroy((*it).second);
117 vData =
new std::deque<typename StoredType<TYPE>::Value>();
122 tlp::error() << __PRETTY_FUNCTION__ <<
"unexpected state value (serious bug)" << std::endl;
126 StoredType<TYPE>::destroy(defaultValue);
127 defaultValue = StoredType<TYPE>::clone(value);
136 template <
typename TYPE>
138 tlp::MutableContainer<TYPE>::findAllValues(
typename StoredType<TYPE>::ReturnedConstValue value,
140 if (equal && StoredType<TYPE>::equal(defaultValue, value))
146 return new IteratorVect<TYPE>(value, equal, vData, minIndex);
150 return new IteratorHash<TYPE>(value, equal, hData);
155 tlp::error() << __PRETTY_FUNCTION__ <<
"unexpected state value (serious bug)" << std::endl;
162 template <
typename TYPE>
164 tlp::MutableContainer<TYPE>::findAll(
typename StoredType<TYPE>::ReturnedConstValue value,
166 return findAllValues(value, equal);
169 template <
typename TYPE>
170 void tlp::MutableContainer<TYPE>::vectset(
const unsigned int i,
171 typename StoredType<TYPE>::Value value) {
172 if (minIndex == UINT_MAX) {
175 (*vData).push_back(value);
190 while (i > maxIndex) {
191 (*vData).push_back(defaultValue);
195 while (i < minIndex) {
196 (*vData).push_front(defaultValue);
200 typename StoredType<TYPE>::Value val = (*vData)[i - minIndex];
201 (*vData)[i - minIndex] = value;
203 if (val != defaultValue)
204 StoredType<TYPE>::destroy(val);
210 template <
typename TYPE>
211 void tlp::MutableContainer<TYPE>::set(
const unsigned int i,
212 typename StoredType<TYPE>::ReturnedConstValue value,
213 bool forceDefaultValueRemoval) {
215 if (!compressing && !StoredType<TYPE>::equal(defaultValue, value)) {
217 compress(std::min(i, minIndex), std::max(i, maxIndex), elementInserted);
221 if (StoredType<TYPE>::equal(defaultValue, value)) {
226 if (i <= maxIndex && i >= minIndex) {
227 typename StoredType<TYPE>::Value val = (*vData)[i - minIndex];
229 if (val != defaultValue) {
230 (*vData)[i - minIndex] = defaultValue;
231 StoredType<TYPE>::destroy(val);
233 }
else if (forceDefaultValueRemoval)
240 typename TLP_HASH_MAP<unsigned int, typename StoredType<TYPE>::Value>::iterator it =
243 if (it != hData->end()) {
244 StoredType<TYPE>::destroy((*it).second);
254 tlp::error() << __PRETTY_FUNCTION__ <<
"unexpected state value (serious bug)" << std::endl;
258 typename StoredType<TYPE>::Value newVal = StoredType<TYPE>::clone(value);
268 typename TLP_HASH_MAP<unsigned int, typename StoredType<TYPE>::Value>::iterator it =
271 if (it != hData->end())
272 StoredType<TYPE>::destroy((*it).second);
276 (*hData)[i] = newVal;
282 tlp::error() << __PRETTY_FUNCTION__ <<
"unexpected state value (serious bug)" << std::endl;
286 maxIndex = std::max(maxIndex, i);
287 minIndex = std::min(minIndex, i);
291 template <
typename TYPE>
292 void tlp::MutableContainer<TYPE>::add(
const unsigned int i, TYPE val) {
293 if (tlp::StoredType<TYPE>::isPointer ==
false) {
294 if (maxIndex == UINT_MAX) {
295 assert(state == VECT);
298 (*vData).push_back(defaultValue + val);
305 if (i > maxIndex || i < minIndex) {
306 set(i, defaultValue + val);
310 TYPE &oldVal = (*vData)[i - minIndex];
312 if (oldVal == defaultValue) {
313 set(i, defaultValue + val);
323 typename TLP_HASH_MAP<unsigned int, typename StoredType<TYPE>::Value>::iterator it =
326 if (it != hData->end()) {
328 if ((it->second + val) == defaultValue) {
329 StoredType<TYPE>::destroy((*it).second);
335 set(i, defaultValue + val);
343 std::cerr << __PRETTY_FUNCTION__ <<
"unexpected state value (serious bug)" << std::endl;
348 std::cerr << __PRETTY_FUNCTION__ <<
"not implemented" << std::endl;
351 template <
typename TYPE>
352 typename tlp::StoredType<TYPE>::ReturnedConstValue
353 tlp::MutableContainer<TYPE>::get(
const unsigned int i)
const {
355 if (maxIndex == UINT_MAX)
356 return StoredType<TYPE>::get(defaultValue);
361 if (i > maxIndex || i < minIndex)
362 return StoredType<TYPE>::get(defaultValue);
364 return StoredType<TYPE>::get((*vData)[i - minIndex]);
367 typename TLP_HASH_MAP<unsigned int, typename StoredType<TYPE>::Value>::iterator it =
370 if (it != hData->end())
371 return StoredType<TYPE>::get((*it).second);
373 return StoredType<TYPE>::get(defaultValue);
378 tlp::error() << __PRETTY_FUNCTION__ <<
"unexpected state value (serious bug)" << std::endl;
379 return StoredType<TYPE>::get(defaultValue);
384 template <
typename TYPE>
385 typename tlp::StoredType<TYPE>::ReturnedValue tlp::MutableContainer<TYPE>::getDefault()
const {
386 return StoredType<TYPE>::get(defaultValue);
389 template <
typename TYPE>
390 bool tlp::MutableContainer<TYPE>::hasNonDefaultValue(
const unsigned int i)
const {
391 if (maxIndex == UINT_MAX)
396 return (i <= maxIndex && i >= minIndex && (((*vData)[i - minIndex]) != defaultValue));
399 return ((hData->find(i)) != hData->end());
403 tlp::error() << __PRETTY_FUNCTION__ <<
"unexpected state value (serious bug)" << std::endl;
408 template <
typename TYPE>
409 typename tlp::StoredType<TYPE>::ReturnedValue
410 tlp::MutableContainer<TYPE>::get(
const unsigned int i,
bool ¬Default)
const {
411 if (maxIndex == UINT_MAX) {
413 return StoredType<TYPE>::get(defaultValue);
419 if (i > maxIndex || i < minIndex) {
421 return StoredType<TYPE>::get(defaultValue);
423 typename StoredType<TYPE>::Value val = (*vData)[i - minIndex];
424 notDefault = val != defaultValue;
425 return StoredType<TYPE>::get(val);
429 typename TLP_HASH_MAP<unsigned int, typename StoredType<TYPE>::Value>::iterator it =
432 if (it != hData->end()) {
434 return StoredType<TYPE>::get((*it).second);
437 return StoredType<TYPE>::get(defaultValue);
444 tlp::error() << __PRETTY_FUNCTION__ <<
"unexpected state value (serious bug)" << std::endl;
445 return StoredType<TYPE>::get(defaultValue);
449 template <
typename TYPE>
450 unsigned int tlp::MutableContainer<TYPE>::numberOfNonDefaultValues()
const {
451 return elementInserted;
454 template <
typename TYPE>
455 void tlp::MutableContainer<TYPE>::vecttohash() {
456 hData =
new TLP_HASH_MAP<unsigned int, typename StoredType<TYPE>::Value>(elementInserted);
458 unsigned int newMaxIndex = 0;
459 unsigned int newMinIndex = UINT_MAX;
462 for (
unsigned int i = minIndex; i <= maxIndex; ++i) {
463 if ((*vData)[i - minIndex] != defaultValue) {
464 (*hData)[i] = (*vData)[i - minIndex];
465 newMaxIndex = std::max(newMaxIndex, i);
466 newMinIndex = std::min(newMinIndex, i);
471 maxIndex = newMaxIndex;
472 minIndex = newMinIndex;
478 template <
typename TYPE>
479 void tlp::MutableContainer<TYPE>::hashtovect() {
480 vData =
new std::deque<typename StoredType<TYPE>::Value>();
485 typename TLP_HASH_MAP<unsigned int, typename StoredType<TYPE>::Value>::const_iterator it;
487 for (it = hData->begin(); it != hData->end(); ++it) {
488 if (it->second != defaultValue)
489 vectset(it->first, it->second);
496 template <
typename TYPE>
497 void tlp::MutableContainer<TYPE>::compress(
unsigned int min,
unsigned int max,
498 unsigned int nbElements) {
499 if (max == UINT_MAX || (max - min) < 10)
502 double limitValue = ratio * (double(max - min + 1.0));
507 if (
double(nbElements) < limitValue) {
515 if (
double(nbElements) > limitValue * 1.5) {
523 tlp::error() << __PRETTY_FUNCTION__ <<
"unexpected state value (serious bug)" << std::endl;
528 template <
typename TYPE>
529 typename tlp::StoredType<TYPE>::ReturnedConstValue tlp::MutableContainer<TYPE>::
530 operator[](
const unsigned int i)
const {