152
153 template<class E> class GrowableArray : public GenericGrowableArray {
154 friend class VMStructs;
155
156 private:
157 E* _data; // data array
158
159 void grow(int j);
160 void raw_at_put_grow(int i, const E& p, const E& fill);
161 void clear_and_deallocate();
162 public:
163 GrowableArray(Thread* thread, int initial_size) : GenericGrowableArray(initial_size, 0, false) {
164 _data = (E*)raw_allocate(thread, sizeof(E));
165 for (int i = 0; i < _max; i++) ::new ((void*)&_data[i]) E();
166 }
167
168 GrowableArray(int initial_size, bool C_heap = false, MEMFLAGS F = mtInternal)
169 : GenericGrowableArray(initial_size, 0, C_heap, F) {
170 _data = (E*)raw_allocate(sizeof(E));
171 // Needed for Visual Studio 2012 and older
172 #pragma warning(suppress: 4345)
173 for (int i = 0; i < _max; i++) ::new ((void*)&_data[i]) E();
174 }
175
176 GrowableArray(int initial_size, int initial_len, const E& filler, bool C_heap = false, MEMFLAGS memflags = mtInternal)
177 : GenericGrowableArray(initial_size, initial_len, C_heap, memflags) {
178 _data = (E*)raw_allocate(sizeof(E));
179 int i = 0;
180 for (; i < _len; i++) ::new ((void*)&_data[i]) E(filler);
181 for (; i < _max; i++) ::new ((void*)&_data[i]) E();
182 }
183
184 GrowableArray(Arena* arena, int initial_size, int initial_len, const E& filler) : GenericGrowableArray(arena, initial_size, initial_len) {
185 _data = (E*)raw_allocate(sizeof(E));
186 int i = 0;
187 for (; i < _len; i++) ::new ((void*)&_data[i]) E(filler);
188 for (; i < _max; i++) ::new ((void*)&_data[i]) E();
189 }
190
191 GrowableArray() : GenericGrowableArray(2, 0, false) {
192 _data = (E*)raw_allocate(sizeof(E));
405 found = true;
406 return mid;
407 }
408 }
409 return min;
410 }
411 };
412
413 // Global GrowableArray methods (one instance in the library per each 'E' type).
414
415 template<class E> void GrowableArray<E>::grow(int j) {
416 // grow the array by doubling its size (amortized growth)
417 int old_max = _max;
418 if (_max == 0) _max = 1; // prevent endless loop
419 while (j >= _max) _max = _max*2;
420 // j < _max
421 E* newData = (E*)raw_allocate(sizeof(E));
422 int i = 0;
423 for ( ; i < _len; i++) ::new ((void*)&newData[i]) E(_data[i]);
424 // Needed for Visual Studio 2012 and older
425 #pragma warning(suppress: 4345)
426 for ( ; i < _max; i++) ::new ((void*)&newData[i]) E();
427 for (i = 0; i < old_max; i++) _data[i].~E();
428 if (on_C_heap() && _data != NULL) {
429 FreeHeap(_data);
430 }
431 _data = newData;
432 }
433
434 template<class E> void GrowableArray<E>::raw_at_put_grow(int i, const E& p, const E& fill) {
435 if (i >= _len) {
436 if (i >= _max) grow(i);
437 for (int j = _len; j < i; j++)
438 _data[j] = fill;
439 _len = i+1;
440 }
441 _data[i] = p;
442 }
443
444 // This function clears and deallocate the data in the growable array that
445 // has been allocated on the C heap. It's not public - called by the
|
152
153 template<class E> class GrowableArray : public GenericGrowableArray {
154 friend class VMStructs;
155
156 private:
157 E* _data; // data array
158
159 void grow(int j);
160 void raw_at_put_grow(int i, const E& p, const E& fill);
161 void clear_and_deallocate();
162 public:
163 GrowableArray(Thread* thread, int initial_size) : GenericGrowableArray(initial_size, 0, false) {
164 _data = (E*)raw_allocate(thread, sizeof(E));
165 for (int i = 0; i < _max; i++) ::new ((void*)&_data[i]) E();
166 }
167
168 GrowableArray(int initial_size, bool C_heap = false, MEMFLAGS F = mtInternal)
169 : GenericGrowableArray(initial_size, 0, C_heap, F) {
170 _data = (E*)raw_allocate(sizeof(E));
171 // Needed for Visual Studio 2012 and older
172 #ifdef _MSC_VER
173 #pragma warning(suppress: 4345)
174 #endif
175 for (int i = 0; i < _max; i++) ::new ((void*)&_data[i]) E();
176 }
177
178 GrowableArray(int initial_size, int initial_len, const E& filler, bool C_heap = false, MEMFLAGS memflags = mtInternal)
179 : GenericGrowableArray(initial_size, initial_len, C_heap, memflags) {
180 _data = (E*)raw_allocate(sizeof(E));
181 int i = 0;
182 for (; i < _len; i++) ::new ((void*)&_data[i]) E(filler);
183 for (; i < _max; i++) ::new ((void*)&_data[i]) E();
184 }
185
186 GrowableArray(Arena* arena, int initial_size, int initial_len, const E& filler) : GenericGrowableArray(arena, initial_size, initial_len) {
187 _data = (E*)raw_allocate(sizeof(E));
188 int i = 0;
189 for (; i < _len; i++) ::new ((void*)&_data[i]) E(filler);
190 for (; i < _max; i++) ::new ((void*)&_data[i]) E();
191 }
192
193 GrowableArray() : GenericGrowableArray(2, 0, false) {
194 _data = (E*)raw_allocate(sizeof(E));
407 found = true;
408 return mid;
409 }
410 }
411 return min;
412 }
413 };
414
415 // Global GrowableArray methods (one instance in the library per each 'E' type).
416
417 template<class E> void GrowableArray<E>::grow(int j) {
418 // grow the array by doubling its size (amortized growth)
419 int old_max = _max;
420 if (_max == 0) _max = 1; // prevent endless loop
421 while (j >= _max) _max = _max*2;
422 // j < _max
423 E* newData = (E*)raw_allocate(sizeof(E));
424 int i = 0;
425 for ( ; i < _len; i++) ::new ((void*)&newData[i]) E(_data[i]);
426 // Needed for Visual Studio 2012 and older
427 #ifdef _MSC_VER
428 #pragma warning(suppress: 4345)
429 #endif
430 for ( ; i < _max; i++) ::new ((void*)&newData[i]) E();
431 for (i = 0; i < old_max; i++) _data[i].~E();
432 if (on_C_heap() && _data != NULL) {
433 FreeHeap(_data);
434 }
435 _data = newData;
436 }
437
438 template<class E> void GrowableArray<E>::raw_at_put_grow(int i, const E& p, const E& fill) {
439 if (i >= _len) {
440 if (i >= _max) grow(i);
441 for (int j = _len; j < i; j++)
442 _data[j] = fill;
443 _len = i+1;
444 }
445 _data[i] = p;
446 }
447
448 // This function clears and deallocate the data in the growable array that
449 // has been allocated on the C heap. It's not public - called by the
|