Implement missing functions on ListBase.

sdk/lib/_collection_dev/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.dev;
 
 /**
  * Class implementing the read-operations on [List].
  *
  * Implements all read-only operations, except [:operator[]:] and [:length:],
  * in terms of those two operations.
  */
 abstract class ListBase<E> extends ListIterable<E> implements List<E> {
   // List interface.
   int get length;
   E operator[](int index);
 
   // Collection interface.
   // Implement in a fully mutable specialized class if necessary.
   // The fixed-length and unmodifiable lists throw on all members
   // of the collection interface.
 
   // Iterable interface.
   E elementAt(int index) {
     return this[index];
   }
+
   Map<int, E> asMap() {
     return new ListMapView(this);
   }
 
+  List<E> getRange(int start, int length) {
+    if (start < 0 || start > this.length) {
+      throw new RangeError.range(start, 0, this.length);
+    }
+    if (length < 0 || start + length > this.length) {
+      throw new RangeError.range(length, 0, this.length - start);
+    }
+    List<E> result = new List<E>(length);
+    for (int i = 0; i < length; i++) {
+      result[i] = this[start + i];
+    }
+    return result;
+  }
+
+  int indexOf(E element, [int start = 0]) {
+    return Arrays.indexOf(this, element, start, this.length);
+  }
+
+  int lastIndexOf(E element, [int start = null]) {
+    if (start == null) start = length - 1;
+    return Arrays.lastIndexOf(this, element, start);
+  }
+
+  Iterable<E> get reversed => new ReversedListIterable(this);
 }
 
 /**
  * Abstract class implementing the non-length changing operations of [List].
  *
  * All modifications are performed using [[]=].
  */
 abstract class FixedLengthListBase<E> extends ListBase<E> {
   void operator[]=(int index, E value);
 
@@ skipping 42 matching lines @@
   void retainAll(Iterable elements) {
     throw new UnsupportedError(
         "Cannot remove from a fixed-length list");
   }
 
   void removeMatching(bool test(E element)) {
     throw new UnsupportedError(
         "Cannot remove from a fixed-length list");
   }
 
+  void retainMatching(bool test(E element)) {
+    throw new UnsupportedError(
+        "Cannot remove from a fixed-length list");
+  }
+
   void clear() {
     throw new UnsupportedError(
         "Cannot clear a fixed-length list");
   }
 
   E removeAt(int index) {
     throw new UnsupportedError(
         "Cannot remove from a fixed-length list");
   }
 
@@ skipping 56 matching lines @@
   void retainAll(Iterable elements) {
     throw new UnsupportedError(
         "Cannot remove from an unmodifiable list");
   }
 
   void removeMatching(bool test(E element)) {
     throw new UnsupportedError(
         "Cannot remove from an unmodifiable list");
   }
 
+  void retainMatching(bool test(E element)) {
+    throw new UnsupportedError(
+        "Cannot remove from an unmodifiable list");
+  }
+
   void sort([Comparator<E> compare]) {
     throw new UnsupportedError(
         "Cannot modify an unmodifiable list");
   }
 
   void clear() {
     throw new UnsupportedError(
         "Cannot clear an unmodifiable list");
   }
 
@@ skipping 14 matching lines @@
 
   void removeRange(int start, int length) {
     throw new UnsupportedError(
         "Cannot remove from an unmodifiable list");
   }
 
   void insertRange(int start, int length, [E initialValue]) {
     throw new UnsupportedError(
         "Cannot insert range in an unmodifiable list");
   }
-
-  List<E> getRange(int start, int length) {
-    if (start < 0 || start > this.length) {
-      throw new RangeError.range(start, 0, this.length);
-    }
-    if (length < 0 || start + length > this.length) {
-      throw new RangeError.range(length, 0, this.length - start);
-    }
-    List<E> result = new List<E>(length);
-    for (int i = 0; i < length; i++) {
-      result[i] = this[start + i];
-    }
-    return result;
-  }
 }
 
 /** An empty fixed-length list. */
 class EmptyList<E> extends FixedLengthListBase<E> {
   int get length => 0;
   E operator[](int index) { throw new RangeError.value(index); }
   void operator []=(int index, E value) { throw new RangeError.value(index); }
   Iterable<E> skip(int count) => const EmptyIterable();
   Iterable<E> take(int count) => const EmptyIterable();
   Iterable<E> get reversed => const EmptyIterable();
@@ skipping 68 matching lines @@
   }
 
   E remove(int key) {
     throw new UnsupportedError("Cannot modify an unmodifiable map");
   }
 
   void clear() {
     throw new UnsupportedError("Cannot modify an unmodifiable map");
   }
 }