Add List.asMap().

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);
+  }
 }
 
 /**
  * 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 200 matching lines @@
  */
 class CodeUnits extends UnmodifiableListBase<int> {
   /** The string that this is the code units of. */
   String _string;
 
   CodeUnits(this._string);
 
   int get length => _string.length;
   int operator[](int i) => _string.codeUnitAt(i);
 }
+
+class _ListIndexIterable extends ListIterable<int> {
+  List _backedList;
+
+  _ListIndexIterable(this._backedList);
+
+  int get length => _backedList.length;
+  int elementAt(int index) {
+    if (index < 0 || index >= length) throw new RangeError(index);
+    return index;
+  }
+}
+
+class ListMapView<E> implements Map<int, E> {
+  List<E> _values;
+
+  ListMapView(this._values);
+
+  E operator[] (int key) => containsKey(key) ? _values[key] : null;
+  int get length => _values.length;
+
+  Iterable<E> get values => new SubListIterable<E>(_values, 0, null);
+  Iterable<int> get keys => new _ListIndexIterable(_values);

[Lasse Reichstein Nielsen, 2013/03/04 08:28:37]

_ListIndicesIterable?

[floitsch, 2013/03/04 16:50:20]

Done.

+
+  bool get isEmpty => _values.isEmpty;
+  bool containsValue(E value) => _values.contains(value);
+  bool containsKey(int key) => key is int && key >= 0 && key < length;

[Lasse Reichstein Nielsen, 2013/03/04 08:28:37]

Drop the "key is int".

[floitsch, 2013/03/04 16:50:20]

The key is int is crucial. Otherwise it will return true for things that aren't
in it.
Since we decide to move towards accepting any Object (removing the type in the
signature) I will keep it.

+
+  void forEach(void f(int key, E value)) {
+    int length = _values.length;
+    for (int i = 0; i < length; i++) {
+      f(i, _values[i]);
+      if (length != _values.length) {
+        throw new ConcurrentModificationError(_values);
+      }
+    }
+  }
+
+  void operator[]= (int key, E value) {
+    throw new UnsupportedError("Cannot modify an unmodifiable map");
+  }
+
+  E putIfAbsent(int key, E ifAbsent()) {
+    throw new UnsupportedError("Cannot modify an unmodifiable map");
+  }
+
+  E remove(int key) {
+    throw new UnsupportedError("Cannot modify an unmodifiable map");
+  }
+
+  void clear() {
+    throw new UnsupportedError("Cannot modify an unmodifiable map");
+  }
+}