< prev index next >

src/hotspot/share/utilities/growableArray.hpp

Print this page
@@ -24,10 +24,12 @@
  
  #ifndef SHARE_UTILITIES_GROWABLEARRAY_HPP
  #define SHARE_UTILITIES_GROWABLEARRAY_HPP
  
  #include "memory/allocation.hpp"
+ #include "oops/array.hpp"
+ #include "oops/oop.hpp"
  #include "memory/iterator.hpp"
  #include "utilities/debug.hpp"
  #include "utilities/globalDefinitions.hpp"
  #include "utilities/ostream.hpp"
  #include "utilities/powerOfTwo.hpp"

@@ -443,10 +445,16 @@
      for (int i = 0; i < l->length(); i++) {
        this->at_put_grow(this->_len, l->at(i), E());
      }
    }
  
+   void appendAll(const Array<E>* l) {
+     for (int i = 0; i < l->length(); i++) {
+       this->at_put_grow(this->_len, l->at(i), E());
+     }
+   }
+ 
    // Binary search and insertion utility.  Search array for element
    // matching key according to the static compare function.  Insert
    // that element if not already in the list.  Assumes the list is
    // already sorted according to compare function.
    template <int compare(const E&, const E&)> E insert_sorted(const E& key) {

@@ -789,23 +797,23 @@
    const GrowableArrayView<E>* _array; // GrowableArray we iterate over
    int _position;                      // Current position in the GrowableArray
    UnaryPredicate _predicate;          // Unary predicate the elements of the GrowableArray should satisfy
  
   public:
-   GrowableArrayFilterIterator(const GrowableArrayIterator<E>& begin, UnaryPredicate filter_predicate) :
-       _array(begin._array), _position(begin._position), _predicate(filter_predicate) {
+   GrowableArrayFilterIterator(const GrowableArray<E>* array, UnaryPredicate filter_predicate) :
+       _array(array), _position(0), _predicate(filter_predicate) {
      // Advance to first element satisfying the predicate
-     while(_position != _array->length() && !_predicate(_array->at(_position))) {
+     while(!at_end() && !_predicate(_array->at(_position))) {
        ++_position;
      }
    }
  
    GrowableArrayFilterIterator<E, UnaryPredicate>& operator++() {
      do {
        // Advance to next element satisfying the predicate
        ++_position;
-     } while(_position != _array->length() && !_predicate(_array->at(_position)));
+     } while(!at_end() && !_predicate(_array->at(_position)));
      return *this;
    }
  
    E operator*() { return _array->at(_position); }
  

@@ -826,10 +834,14 @@
  
    bool operator!=(const GrowableArrayFilterIterator<E, UnaryPredicate>& rhs)  {
      assert(_array == rhs._array, "iterator belongs to different array");
      return _position != rhs._position;
    }
+ 
+   bool at_end() const {
+     return _array == NULL || _position == _array->end()._position;
+   }
  };
  
  // Arrays for basic types
  typedef GrowableArray<int> intArray;
  typedef GrowableArray<int> intStack;
< prev index next >