Implement removeRange, and update some documentation on the list interface.

compiler/lib/implementation/array.dart

 // Copyright (c) 2011, 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 ArrayFactory {
   factory Array<E>.from(Iterable<E> other) {
     Array<E> array = new Array<E>();
     for (final e in other) {
       array.add(e);
     }
@@ skipping 102 matching lines @@
     } else {
       return new VariableSizeArrayIterator<T>(this);
     }
   }
 
   T _indexOperator(int index) native;
   void _indexAssignOperator(int index, T value) native;
   int get length() native;
   void _setLength(int length) native;
   void _add(T value) native;
+  void _splice(int start, int length) native;
 
   void forEach(void f(T element)) {
     Collections.forEach(this, f);
   }
 
   Collection<T> filter(bool f(T element)) {
     return Collections.filter(this, new Array<T>(), f);
   }
 
   bool every(bool f(T element)) {
@@ skipping 10 matching lines @@
 
   void sort(int compare(T a, T b)) {
     DualPivotQuicksort.sort(this, compare);
   }
 
   void copyFrom(Array<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 (_isFixed) {

[Anton Muhin, 2011/10/18 07:44:20]

may we have this in Arrays?  Ditto for removeRange.

[ngeoffray, 2011/10/18 07:46:09]

There is a 'rangeCheck' method in Arrays.

[Anton Muhin, 2011/10/18 08:54:46]

Sorry, I meant the whole logic of methods.  Even for removeRange we can pass
_splice.

On 2011/10/18 07:46:09, ngeoffray wrote:

[ngeoffray, 2011/10/18 08:58:01]

The _splice is really tight to the implementation, I'm not sure we want to share
that. Must your arrays support removeRange or insertRange?

[Anton Muhin, 2011/10/18 14:33:49]

I believe yes, but didn't double check.  Anyway, let's see how it will turn out,
we can always refactor later.

On 2011/10/18 08:58:01, ngeoffray wrote:

+      throw const UnsupportedOperationException(
+          "Cannot remove range of a non-extendable array");
+    }
+    if (length == 0) {
+      return;
+    }
+    if (length < 0) {
+      throw const IllegalArgumentException();
+    }
     Arrays.copy(from, startFrom, this, start, length);
   }
 
   void removeRange(int start, int length) {
-    throw const NotImplementedException();
+    if (_isFixed) {
+      throw const UnsupportedOperationException(
+          "Cannot remove range of a non-extendable array");
+    }
+    if (length == 0) {
+      return;
+    }
+    if (length < 0) {
+      throw const IllegalArgumentException();
+    }
+    if (start < 0 || start >= this.length) {
+      throw new IndexOutOfRangeException(start);
+    }
+    if (start + length > this.length) {
+      throw new IndexOutOfRangeException(start + length);
+    }
+    _splice(start, length);
   }
 
   void insertRange(int start, int length, [T initialValue = null]) {
     throw const NotImplementedException();
   }
 
   List<T> getRange(int start, int length) {
     throw const NotImplementedException();
   }
 
@@ skipping 108 matching lines @@
   }
 
   static Array _newArray(int len) native {
     return new Array(len);
   }
 
   static void _throwIndexOutOfRangeException(int index) native {
     throw new IndexOutOfRangeException(index);
   }
 }