Wire GrowableArray to use the internal VM object.

lib/growable_array.dart

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 class GrowableObjectArray<T> implements List<T> {
-  ObjectArray<T> backingArray;
-
   factory GrowableObjectArray._uninstantiable() {
     throw const UnsupportedOperationException(
         "GrowableObjectArray can only be allocated by the VM");
   }
 
   void copyFrom(List<Object> src, int srcStart, int dstStart, int count) {
     Arrays.copy(src, srcStart, this, dstStart, count);
   }
 
   void setRange(int start, int length, List<T> from, [int startFrom = 0]) {
     if (length < 0) {
       throw new IllegalArgumentException("negative length $length");
     }
     Arrays.copy(from, startFrom, this, start, length);
   }
 
   void removeRange(int start, int length) {
     if (length == 0) {
       return;
     }
     if (length < 0) {
       throw new IllegalArgumentException("negative length $length");
     }
     if (start < 0 || start >= this.length) {
       throw new IndexOutOfRangeException(start);
     }
     if (start + length > this.length) {
       throw new IndexOutOfRangeException(start + length);
     }
-    Arrays.copy(backingArray,
+    Arrays.copy(this,
                 start + length,
-                backingArray,
+                this,
                 start,
                 this.length - length - start);
     this.length = this.length - length;
   }
 
   void insertRange(int start, int length, [T initialValue = null]) {
     if (length == 0) {
       return;
     }
-    if (length < 0) {
-      throw new IllegalArgumentException("negative length $length");
+    if ((length < 0) || (length is! int)) {
+      throw new IllegalArgumentException("invalid length specified");

[srdjan, 2012/04/06 21:19:51]

Add $length to message?

[siva, 2012/04/09 20:57:24]

Done.

     }
     if (start < 0 || start > this.length) {
       throw new IndexOutOfRangeException(start);
     }
-    if (this.length + length > backingArray.length) {
-      grow(backingArray.length + length);
-    }
-    Arrays.copy(backingArray,
+    var old_length = this.length;
+    this.length = old_length + length;  // Will expand if needed.
+    Arrays.copy(this,
                 start,
-                backingArray,
+                this,
                 start + length,
-                this.length - start);
+                old_length - start);
     if (initialValue !== null) {
       for (int i = start; i < start + length; i++) {
-        backingArray[i] = initialValue;
+        this[i] = initialValue;
       }
     }
-    this.length = this.length + length;
   }
 
   List<T> getRange(int start, int length) {
     if (length == 0) return [];
     Arrays.rangeCheck(this, start, length);
     List list = new List<T>();
     list.length = length;
     Arrays.copy(this, start, list, 0, length);
     return list;
   }
 
-  // The length of this growable array. It is always less than or equal to the
-  // length of the backing array, which itself is always greater than 0, so that
-  // grow() does not have to check for a zero length backing array before
-  // doubling its size.
-  int _length;
+  factory GrowableObjectArray() {
+    var data = new ObjectArray<T>(4);
+    return new GrowableObjectArray<T>.fromObjectArray(data);
+  }
 
-  GrowableObjectArray()
-      : _length = 0, backingArray = new ObjectArray<T>(4) {}
-
-  GrowableObjectArray.withCapacity(int capacity) {
-    _length = 0;
-    if (capacity <= 0) {
-      capacity = 4;
-    }
-    backingArray = new ObjectArray<T>(capacity);
+  factory GrowableObjectArray.withCapacity(int capacity) {
+    var data = new ObjectArray<T>(capacity);
+    return new GrowableObjectArray<T>.fromObjectArray(data);
   }
 
   factory GrowableObjectArray.from(Collection<T> other) {
     List<T> result = new GrowableObjectArray<T>();
     result.addAll(other);
     return result;
   }
 
-  int get length() {
-    return _length;
+  factory GrowableObjectArray.fromObjectArray(ObjectArray<T> data)
+    native "GrowableObjectArray_allocate";
+
+  int get length() native "GrowableObjectArray_getLength";
+
+  int get capacity() native "GrowableObjectArray_getCapacity";
+
+  void set length(int new_length) {
+    if (new_length > capacity) {
+      _grow(new_length);
+    } else {
+      for (int i = new_length; i < length; i++) {
+        this[i] = null;
+      }
+    }
+    _setLength(new_length);
   }
 
-  void set length(int new_length) {
-    if (new_length > backingArray.length) {
-      grow(new_length);
-    } else {
-      for (int i = new_length; i < _length; i++) {
-        backingArray[i] = null;
-      }
+  void _setLength(int new_length) native "GrowableObjectArray_setLength";
+
+  void set data(ObjectArray<T> array) native "GrowableObjectArray_setData";
+
+  T operator [](int index) native "GrowableObjectArray_getIndexed";
+
+  void operator []=(int index, T value) native "GrowableObjectArray_setIndexed";
+
+  // The length of this growable array. It is always less than or equal to the
+  // length of the object array, which itself is always greater than 0, so that
+  // grow() does not have to check for a zero length object array before
+  // doubling its size.
+  void add(T value) {
+    var len = length;
+    if (len == capacity) {
+      _grow(len * 2);
     }
-    _length = new_length;
-  }
-
-  T operator [](int index) {
-    if (index is !int) {
-      throw new IllegalArgumentException("[] with $index");
-    }
-    if (index >= _length) {
-      throw new IndexOutOfRangeException(index);
-    }
-    return backingArray[index];
-  }
-
-  void operator []=(int index, T value) {
-   if (index is !int) {
-     throw new IllegalArgumentException("[]= with $index");
-   }
-   if (index >= _length) {
-      throw new IndexOutOfRangeException(index);
-    }
-    backingArray[index] = value;
-  }
-
-  void grow(int capacity) {
-    ObjectArray<T> newArray = new ObjectArray<T>(capacity);
-    int length = backingArray.length;
-    for (int i = 0; i < length; i++) {
-      newArray[i] = backingArray[i];
-    }
-    backingArray = newArray;
-  }
-
-  void add(T value) {
-    if (_length == backingArray.length) {
-      grow(_length * 2);
-    }
-    backingArray[_length] = value;
-    ++_length;
+    _setLength(len + 1);
+    this[len] = value;
   }
 
   void addLast(T element) {
     add(element);
   }
 
   void addAll(Collection<T> collection) {
     for (T elem in collection) {
       add(elem);
     }
   }
 
   T removeLast() {
-    if (_length == 0) {
+    var len = length - 1;
+    if (len < 0) {
       throw new IndexOutOfRangeException(-1);
     }
-    _length--;
-    return backingArray[_length];
+    var elem = this[len];
+    this[len] = null;
+    _setLength(len);
+    return elem;
   }
 
   T last() {
-    if (_length === 0) {
+    if (length === 0) {
       throw new IndexOutOfRangeException(-1);
     }
-    return backingArray[_length - 1];
+    return this[length - 1];
   }
 
   int indexOf(T element, [int start = 0]) {
-    return Arrays.indexOf(backingArray, element, start, _length);
+    return Arrays.indexOf(this, element, start, length);
   }
 
   int lastIndexOf(T element, [int start = null]) {
     if (start === null) start = length - 1;
-    return Arrays.lastIndexOf(backingArray, element, start);
+    return Arrays.lastIndexOf(this, element, start);
+  }
+
+  void _grow(int new_length) {
+    var new_data = new ObjectArray<T>(new_length);
+    for (int i = 0; i < length; i++) {
+      new_data[i] = this[i];
+    }
+    data = new_data;
   }
 
   /**
    * Collection interface.
    */
 
   void forEach(f(T element)) {
     // TODO(srdjan): Use Collections.forEach(this, f);
-    // Using backingArray directly improves DeltaBlue performance by 25%.
-    for (int i = 0; i < _length; i++) {
-      f(backingArray[i]);
+    // Accessing the list directly improves DeltaBlue performance by 25%.
+    for (int i = 0; i < length; i++) {
+      f(this[i]);
     }
   }
 
   Collection map(f(T element)) {
-    return Collections.map(this, new GrowableObjectArray.withCapacity(length), f);
+    return Collections.map(this,
+                           new GrowableObjectArray.withCapacity(length), f);
   }
 
   Collection<T> filter(bool f(T element)) {
     return Collections.filter(this, new GrowableObjectArray<T>(), f);
   }
 
   bool every(bool f(T element)) {
     return Collections.every(this, f);
   }
 
@@ skipping 23 matching lines @@
 }
 
 
 // Iterator for arrays with variable size.
 class VariableSizeArrayIterator<T> implements Iterator<T> {
   VariableSizeArrayIterator(GrowableObjectArray<T> array)
       : _array = array,  _pos = 0 {
   }
 
   bool hasNext() {
-    return _array._length > _pos;
+    return _array.length > _pos;
   }
 
   T next() {
     if (!hasNext()) {
       throw const NoMoreElementsException();
     }
     return _array[_pos++];
   }
 
   final GrowableObjectArray<T> _array;
   int _pos;
 }
-