Add setAll, insertAll, replaceRange and fillRange.

sdk/lib/collection/list.dart

 // Copyright (c) 2013, 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.
 
 part of dart.collection;
 
 /**
  * Abstract implementation of a list.
  *
  * All operations are defined in terms of `length`, `operator[]`,
@@ skipping 156 matching lines @@
         }
       }
       return buffer.toString();
     }
   }
 
   Iterable<E> where(bool test(E element)) => new WhereIterable<E>(this, test);
 
   Iterable map(f(E element)) => new MappedListIterable(this, f);
 
+  Iterable expand(Iterable f(E element)) =>

[floitsch, 2013/04/15 16:22:48]

Extracted into a separate CL.
I need to commit before I can merge and remove it from this CL.

+      new ExpandIterable<E, dynamic>(this, f);
+
   E reduce(E combine(E previousValue, E element)) {
     if (length == 0) throw new StateError("No elements");
     E value = this[0];
     for (int i = 1; i < length; i++) {
       value = combine(value, this[i]);
     }
     return value;
   }
 
   fold(var initialValue, combine(var previousValue, E element)) {
@@ skipping 104 matching lines @@
   }
 
   void sort([Comparator<E> compare]) {
     Sort.sort(this, compare);
   }
 
   Map<int, E> asMap() {
     return new ListMapView(this);
   }
 
-  List<E> sublist(int start, [int end]) {
-    if (end == null) end = length;
+  void _rangeCheck(int start, int end) {
     if (start < 0 || start > this.length) {
       throw new RangeError.range(start, 0, this.length);
     }
     if (end < start || end > this.length) {
       throw new RangeError.range(end, start, this.length);
     }
+  }
+
+  List<E> sublist(int start, [int end]) {
+    if (end == null) end = length;
+    _rangeCheck(start, end);
     int length = end - start;
     List<E> result = new List<E>()..length = length;
     for (int i = 0; i < length; i++) {
       result[i] = this[start + i];
     }
     return result;
   }
 
   Iterable<E> getRange(int start, int end) {
-    if (start < 0 || start > this.length) {
-      throw new RangeError.range(start, 0, this.length);
-    }
-    if (end < start || end > this.length) {
-      throw new RangeError.range(end, start, this.length);
-    }
+    _rangeCheck(start, end);
     return new SubListIterable(this, start, end);
   }
 
   void removeRange(int start, int end) {
-    if (start < 0 || start > this.length) {
-      throw new RangeError.range(start, 0, this.length);
-    }
-    if (end < start || end > this.length) {
-      throw new RangeError.range(end, start, this.length);
-    }
+    _rangeCheck(start, end);
     int length = end - start;
     setRange(start, this.length - length, this, end);
     this.length -= length;
   }
 
-  void clearRange(int start, int length, [E fill]) {
-    for (int i = 0; i < length; i++) {
-      this[start + i] = fill;
+  void fillRange(int start, int end, [E fill]) {
+    _rangeCheck(start, end);
+    for (int i = start; i < end; i++) {
+      this[i] = fill;
     }
   }
 
   void setRange(int start, int end, Iterable<E> iterable, [int skipCount = 0]) {
-    if (start < 0 || start > this.length) {
-      throw new RangeError.range(start, 0, this.length);
-    }
-    if (end < 0 || end > this.length) {
-      throw new RangeError.range(end, start, this.length);
-    }
+    _rangeCheck(start, end);
     int length = end - start;
     if (length == 0) return;
 
     if (skipCount < 0) throw new ArgumentError(skipCount);
 
     List otherList;
     int otherStart;
     // TODO(floitsch): Make this accept more.
     if (iterable is List) {
       otherList = iterable;
@@ skipping 10 matching lines @@
       for (int i = length - 1; i >= 0; i--) {
         this[start + i] = otherList[otherStart + i];
       }
     } else {
       for (int i = 0; i < length; i++) {
         this[start + i] = otherList[otherStart + i];
       }
     }
   }
 
+  void replaceRange(int start, int end, Iterable<E> newContents) {
+    // TODO(floitsch): Optimize this.
+    removeRange(start, end);
+    insertAll(start, newContents);
+  }
+
   int indexOf(E element, [int startIndex = 0]) {
     if (startIndex >= this.length) {
       return -1;
     }
     if (startIndex < 0) {
       startIndex = 0;
     }
     for (int i = startIndex; i < this.length; i++) {
       if (this[i] == element) {
         return i;
@@ skipping 19 matching lines @@
       }
     }
     for (int i = startIndex; i >= 0; i--) {
       if (this[i] == element) {
         return i;
       }
     }
     return -1;
   }
 
+  void insert(int index, E element) {

[floitsch, 2013/04/15 16:22:48]

Extracted into a separate CL.
I need to commit before I can merge and remove it from this CL.

+    if (index < 0 || index > length) {
+      throw new RangeError.range(index, 0, length);
+    }
+    if (index == this.length) {
+      add(element);
+      return;
+    }
+    // We are modifying the length just below the is-check. Without the check
+    // Array.copy could throw an exception, leaving the list in a bad state
+    // (with a length that has been increased, but without a new element).
+    if (index is! int) throw new ArgumentError(index);
+    this.length++;
+    setRange(index + 1, this.length, this, index);
+    this[index] = element;
+  }
+
+  E removeAt(int index) {

[floitsch, 2013/04/15 16:22:48]

Extracted into a separate CL.
I need to commit before I can merge and remove it from this CL.

+    E result = this[index];
+    setRange(index, this.length - 1, this, index + 1);
+    length--;
+    return result;
+  }
+
+  void insertAll(int index, Iterable<E> iterable) {
+    if (index < 0 || index > length) {
+      throw new RangeError.range(index, 0, length);
+    }
+    // TODO(floitsch): we can probably detect more cases.
+    if (iterable is! List && iterable is! Set && iterable is! SubListIterable) {
+      iterable = iterable.toList();
+    }
+    int insertionLength = iterable.length;
+    // There might be errors after the length change, in which case the list
+    // will end up being modified but the operation not complete. Unless we
+    // always go through a "toList" we can't really avoid that.
+    this.length += insertionLength;
+    setRange(index + insertionLength, this.length, this, index);
+    setAll(index, iterable);
+  }
+
+  void setAll(int index, Iterable<E> iterable) {
+    if (iterable is List) {
+      setRange(index, index + iterable.length, iterable);
+    } else {
+      for (E element in iterable) {
+        this[index++] = element;
+      }
+    }
+  }
+
   Iterable<E> get reversed => new ReversedListIterable(this);
 }