roman_version
8 * This code is distributed in the hope that it will be useful, but WITHOUT
9 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
10 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
11 * version 2 for more details (a copy is included in the LICENSE file that
12 * accompanied this code).
13 *
14 * You should have received a copy of the GNU General Public License version
15 * 2 along with this work; if not, write to the Free Software Foundation,
16 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
17 *
18 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
19 * or visit www.oracle.com if you need additional information or have any
20 * questions.
21 *
22 */
23
24 #ifndef SHARE_VM_UTILITIES_GROWABLEARRAY_HPP
25 #define SHARE_VM_UTILITIES_GROWABLEARRAY_HPP
26
27 #include "memory/allocation.hpp"
28 #include "utilities/debug.hpp"
29 #include "utilities/globalDefinitions.hpp"
30 #include "utilities/ostream.hpp"
31
32 // A growable array.
33
34 /*************************************************************************/
35 /* */
36 /* WARNING WARNING WARNING WARNING WARNING WARNING WARNING WARNING */
37 /* */
38 /* Should you use GrowableArrays to contain handles you must be certain */
39 /* the the GrowableArray does not outlive the HandleMark that contains */
40 /* the handles. Since GrowableArrays are typically resource allocated */
41 /* the following is an example of INCORRECT CODE, */
42 /* */
43 /* ResourceMark rm; */
44 /* GrowableArray<Handle>* arr = new GrowableArray<Handle>(size); */
45 /* if (blah) { */
46 /* while (...) { */
|
8 * This code is distributed in the hope that it will be useful, but WITHOUT
9 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
10 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
11 * version 2 for more details (a copy is included in the LICENSE file that
12 * accompanied this code).
13 *
14 * You should have received a copy of the GNU General Public License version
15 * 2 along with this work; if not, write to the Free Software Foundation,
16 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
17 *
18 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
19 * or visit www.oracle.com if you need additional information or have any
20 * questions.
21 *
22 */
23
24 #ifndef SHARE_VM_UTILITIES_GROWABLEARRAY_HPP
25 #define SHARE_VM_UTILITIES_GROWABLEARRAY_HPP
26
27 #include "memory/allocation.hpp"
28 #include "oops/oop.hpp"
29 #include "utilities/debug.hpp"
30 #include "utilities/globalDefinitions.hpp"
31 #include "utilities/ostream.hpp"
32
33 // A growable array.
34
35 /*************************************************************************/
36 /* */
37 /* WARNING WARNING WARNING WARNING WARNING WARNING WARNING WARNING */
38 /* */
39 /* Should you use GrowableArrays to contain handles you must be certain */
40 /* the the GrowableArray does not outlive the HandleMark that contains */
41 /* the handles. Since GrowableArrays are typically resource allocated */
42 /* the following is an example of INCORRECT CODE, */
43 /* */
44 /* ResourceMark rm; */
45 /* GrowableArray<Handle>* arr = new GrowableArray<Handle>(size); */
46 /* if (blah) { */
47 /* while (...) { */
|
193 GrowableArray() : GenericGrowableArray(2, 0, false) { 194 _data = (E*)raw_allocate(sizeof(E)); 195 ::new ((void*)&_data[0]) E(); 196 ::new ((void*)&_data[1]) E(); 197 } 198 199 // Does nothing for resource and arena objects 200 ~GrowableArray() { if (on_C_heap()) clear_and_deallocate(); } 201 202 void clear() { _len = 0; } 203 int length() const { return _len; } 204 int max_length() const { return _max; } 205 void trunc_to(int l) { assert(l <= _len,"cannot increase length"); _len = l; } 206 bool is_empty() const { return _len == 0; } 207 bool is_nonempty() const { return _len != 0; } 208 bool is_full() const { return _len == _max; } 209 DEBUG_ONLY(E* data_addr() const { return _data; }) 210 211 void print(); 212 213 int append(const E& elem) { 214 check_nesting(); 215 if (_len == _max) grow(_len); 216 int idx = _len++; 217 _data[idx] = elem; 218 return idx; 219 } 220 221 bool append_if_missing(const E& elem) { 222 // Returns TRUE if elem is added. 223 bool missed = !contains(elem); 224 if (missed) append(elem); 225 return missed; 226 } 227 228 E& at(int i) { 229 assert(0 <= i && i < _len, "illegal index"); 230 return _data[i]; 231 } |
194 GrowableArray() : GenericGrowableArray(2, 0, false) { 195 _data = (E*)raw_allocate(sizeof(E)); 196 ::new ((void*)&_data[0]) E(); 197 ::new ((void*)&_data[1]) E(); 198 } 199 200 // Does nothing for resource and arena objects 201 ~GrowableArray() { if (on_C_heap()) clear_and_deallocate(); } 202 203 void clear() { _len = 0; } 204 int length() const { return _len; } 205 int max_length() const { return _max; } 206 void trunc_to(int l) { assert(l <= _len,"cannot increase length"); _len = l; } 207 bool is_empty() const { return _len == 0; } 208 bool is_nonempty() const { return _len != 0; } 209 bool is_full() const { return _len == _max; } 210 DEBUG_ONLY(E* data_addr() const { return _data; }) 211 212 void print(); 213 214 inline static bool safe_equals(oop obj1, oop obj2) { 215 return oopDesc::equals(obj1, obj2); 216 } 217 218 template <class X> 219 inline static bool safe_equals(X i1, X i2) { 220 return i1 == i2; 221 } 222 223 int append(const E& elem) { 224 check_nesting(); 225 if (_len == _max) grow(_len); 226 int idx = _len++; 227 _data[idx] = elem; 228 return idx; 229 } 230 231 bool append_if_missing(const E& elem) { 232 // Returns TRUE if elem is added. 233 bool missed = !contains(elem); 234 if (missed) append(elem); 235 return missed; 236 } 237 238 E& at(int i) { 239 assert(0 <= i && i < _len, "illegal index"); 240 return _data[i]; 241 } |
277 E at_grow(int i, const E& fill = E()) {
278 assert(0 <= i, "negative index");
279 check_nesting();
280 if (i >= _len) {
281 if (i >= _max) grow(i);
282 for (int j = _len; j <= i; j++)
283 _data[j] = fill;
284 _len = i+1;
285 }
286 return _data[i];
287 }
288
289 void at_put_grow(int i, const E& elem, const E& fill = E()) {
290 assert(0 <= i, "negative index");
291 check_nesting();
292 raw_at_put_grow(i, elem, fill);
293 }
294
295 bool contains(const E& elem) const {
296 for (int i = 0; i < _len; i++) {
297 if (_data[i] == elem) return true;
298 }
299 return false;
300 }
301
302 int find(const E& elem) const {
303 for (int i = 0; i < _len; i++) {
304 if (_data[i] == elem) return i;
305 }
306 return -1;
307 }
308
309 int find_from_end(const E& elem) const {
310 for (int i = _len-1; i >= 0; i--) {
311 if (_data[i] == elem) return i;
312 }
313 return -1;
314 }
315
316 int find(void* token, bool f(void*, E)) const {
|
287 E at_grow(int i, const E& fill = E()) {
288 assert(0 <= i, "negative index");
289 check_nesting();
290 if (i >= _len) {
291 if (i >= _max) grow(i);
292 for (int j = _len; j <= i; j++)
293 _data[j] = fill;
294 _len = i+1;
295 }
296 return _data[i];
297 }
298
299 void at_put_grow(int i, const E& elem, const E& fill = E()) {
300 assert(0 <= i, "negative index");
301 check_nesting();
302 raw_at_put_grow(i, elem, fill);
303 }
304
305 bool contains(const E& elem) const {
306 for (int i = 0; i < _len; i++) {
307 if (safe_equals(_data[i], elem)) return true;
308 }
309 return false;
310 }
311
312 int find(const E& elem) const {
313 for (int i = 0; i < _len; i++) {
314 if (_data[i] == elem) return i;
315 }
316 return -1;
317 }
318
319 int find_from_end(const E& elem) const {
320 for (int i = _len-1; i >= 0; i--) {
321 if (_data[i] == elem) return i;
322 }
323 return -1;
324 }
325
326 int find(void* token, bool f(void*, E)) const {
|