< prev index next >

src/share/vm/utilities/growableArray.hpp

Print this page
rev 9696 : 8145740: Visual Studio pragmas should be guarded by ifdef _MSC_VER


 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


< prev index next >