Add fromIterable(s) constructors in SplayTreeMap and LinkedHashMap.

sdk/lib/collection/splay_tree.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.
 
 part of dart.collection;
 
 /**
  * A node in a splay tree. It holds the sorting key and the left
  * and right children in the tree.
  */
@@ skipping 227 matching lines @@
  * Keys of the map are compared using the `compare` function passed in
  * the constructor. If that is omitted, the objects are assumed to be
  * [Comparable], and are compared using their [Comparable.compareTo]
  * method. This also means that `null` is *not* allowed as a key.
  */
 class SplayTreeMap<K, V> extends _SplayTree<K> implements Map<K, V> {
   // TODO(ngeoffray): Restore type when feature is implemented in dart2js
   // checked mode. http://dartbug.com/7733
   Function /* Comparator<K> */_comparator;
 
+  static _id(x) => x;
+
   SplayTreeMap([int compare(K key1, K key2)])
       : _comparator = (compare == null) ? Comparable.compare : compare;
 
   factory SplayTreeMap.from(Map<K, V> other, [int compare(K key1, K key2)]) =>
       new SplayTreeMap(compare)..addAll(other);
 
+  factory SplayTreeMap.fromIterable(Iterable iterable,
+      {int compare(K key1, K key2), K key(element), V value(element)}) {

[floitsch, 2013/06/27 15:21:38]

move compare last. It doesn't make any semantic difference, but for
documentation and consistency I prefer it there.

[zarah, 2013/06/27 15:58:52]

Done.

+    SplayTreeMap<K, V> map = new SplayTreeMap<K, V>(compare);
+
+    if (key == null) key = _id;
+    if (value == null) value = _id;
+
+    for (var element in iterable) {
+      map[key(element)] = value(element);
+    }
+
+    return map;
+  }
+
+  factory SplayTreeMap.fromIterables(Iterable<K> keys, Iterable<V> values,
+      [int compare(K key1, K key2)]) {
+    SplayTreeMap<K, V> map = new SplayTreeMap<K, V>(compare);
+
+    Iterator<K> keyIterator = keys.iterator;
+    Iterator<V> valueIterator = values.iterator;
+
+    bool hasNextKey = keyIterator.moveNext();
+    bool hasNextValue = valueIterator.moveNext();
+
+    while (hasNextKey && hasNextValue) {
+      map[keyIterator.current] = valueIterator.current;
+      hasNextKey = keyIterator.moveNext();
+      hasNextValue = valueIterator.moveNext();
+    }
+
+    if (hasNextKey || hasNextValue) {
+      throw new ArgumentError("Iterables do not have same length.");
+    }
+
+    return map;
+  }
+
   int _compare(K key1, K key2) => _comparator(key1, key2);
 
   SplayTreeMap._internal();
 
   V operator [](Object key) {
     if (key == null) throw new ArgumentError(key);
     if (key is! K) return null;
     if (_root != null) {
       int comp = _splay(key);
       if (comp == 0) {
@@ skipping 273 matching lines @@
 class _SplayTreeValueIterator<K, V> extends _SplayTreeIterator<V> {
   _SplayTreeValueIterator(SplayTreeMap<K, V> map): super(map);
   V _getValue(_SplayTreeMapNode node) => node.value;
 }
 
 class _SplayTreeNodeIterator<K>
     extends _SplayTreeIterator<_SplayTreeNode<K>> {
   _SplayTreeNodeIterator(_SplayTree<K> map): super(map);
   _SplayTreeNode<K> _getValue(_SplayTreeNode node) => node;
 }