Format all dart: library files

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;
 
 typedef bool _Predicate<T>(T value);
 
 /**
  * A node in a splay tree. It holds the sorting key and the left
@@ skipping 266 matching lines @@
   _Predicate _validKey;
 
   SplayTreeMap([int compare(K key1, K key2), bool isValidKey(potentialKey)])
       : _comparator = compare ?? Comparable.compare as Comparator<K>,
         _validKey = isValidKey ?? ((v) => v is K);
 
   /**
    * Creates a [SplayTreeMap] that contains all key/value pairs of [other].
    */
   factory SplayTreeMap.from(Map other,
-                            [int compare(K key1, K key2),
-                             bool isValidKey(potentialKey)]) {
+      [int compare(K key1, K key2), bool isValidKey(potentialKey)]) {
     SplayTreeMap<K, V> result = new SplayTreeMap<K, V>(compare, isValidKey);
-    other.forEach((k, v) { result[k as Object/*=K*/] = v as Object/*=V*/; });
+    other.forEach((k, v) {
+      result[k as Object/*=K*/] = v as Object/*=V*/;
+    });
     return result;
   }
 
   /**
    * Creates a [SplayTreeMap] where the keys and values are computed from the
    * [iterable].
    *
    * For each element of the [iterable] this constructor computes a key/value
    * pair, by applying [key] and [value] respectively.
    *
    * The keys of the key/value pairs do not need to be unique. The last
    * occurrence of a key will simply overwrite any previous value.
    *
    * If no functions are specified for [key] and [value] the default is to
    * use the iterable value itself.
    */
   factory SplayTreeMap.fromIterable(Iterable iterable,
-                                    {K key(element),
-                                     V value(element),
-                                     int compare(K key1, K key2),
-                                     bool isValidKey(potentialKey) }) {
+      {K key(element),
+      V value(element),
+      int compare(K key1, K key2),
+      bool isValidKey(potentialKey)}) {
     SplayTreeMap<K, V> map = new SplayTreeMap<K, V>(compare, isValidKey);
     Maps._fillMapWithMappedIterable(map, iterable, key, value);
     return map;
   }
 
   /**
    * Creates a [SplayTreeMap] associating the given [keys] to [values].
    *
    * This constructor iterates over [keys] and [values] and maps each element of
    * [keys] to the corresponding element of [values].
@@ skipping 37 matching lines @@
     // Splay on the key to move the last node on the search path for
     // the key to the root of the tree.
     int comp = _splay(key);
     if (comp == 0) {
       _root.value = value;
       return;
     }
     _addNewRoot(new _SplayTreeMapNode(key, value), comp);
   }
 
-
   V putIfAbsent(K key, V ifAbsent()) {
     if (key == null) throw new ArgumentError(key);
     int comp = _splay(key);
     if (comp == 0) {
       return _root.value;
     }
     int modificationCount = _modificationCount;
     int splayCount = _splayCount;
     V value = ifAbsent();
     if (modificationCount != _modificationCount) {
       throw new ConcurrentModificationError(this);
     }
     if (splayCount != _splayCount) {
       comp = _splay(key);
       // Key is still not there, otherwise _modificationCount would be changed.
       assert(comp != 0);
     }
     _addNewRoot(new _SplayTreeMapNode(key, value), comp);
     return value;
   }
 
   void addAll(Map<K, V> other) {
-    other.forEach((K key, V value) { this[key] = value; });
+    other.forEach((K key, V value) {
+      this[key] = value;
+    });
   }
 
   bool get isEmpty {
     return (_root == null);
   }
 
   bool get isNotEmpty => !isEmpty;
 
   void forEach(void f(K key, V value)) {
-    Iterator<_SplayTreeNode<K>> nodes =
-        new _SplayTreeNodeIterator<K>(this);
+    Iterator<_SplayTreeNode<K>> nodes = new _SplayTreeNodeIterator<K>(this);
     while (nodes.moveNext()) {
       _SplayTreeMapNode<K, V> node = nodes.current;
       f(node.key, node.value);
     }
   }
 
   int get length {
     return _count;
   }
 
@@ skipping 12 matching lines @@
       while (node != null) {
         if (node.value == value) return true;
         if (initialSplayCount != _splayCount) {
           throw new ConcurrentModificationError(this);
         }
         if (node.right != null && visit(node.right)) return true;
         node = node.left;
       }
       return false;
     }
+
     return visit(_root);
   }
 
   Iterable<K> get keys => new _SplayTreeKeyIterable<K>(this);
 
   Iterable<V> get values => new _SplayTreeValueIterable<K, V>(this);
 
   String toString() {
     return Maps.mapToString(this);
   }
@@ skipping 179 matching lines @@
 
 class _SplayTreeValueIterable<K, V> extends EfficientLengthIterable<V> {
   SplayTreeMap<K, V> _map;
   _SplayTreeValueIterable(this._map);
   int get length => _map._count;
   bool get isEmpty => _map._count == 0;
   Iterator<V> get iterator => new _SplayTreeValueIterator<K, V>(_map);
 }
 
 class _SplayTreeKeyIterator<K> extends _SplayTreeIterator<K, K> {
-  _SplayTreeKeyIterator(_SplayTree<K, _SplayTreeNode<K>> map): super(map);
+  _SplayTreeKeyIterator(_SplayTree<K, _SplayTreeNode<K>> map) : super(map);
   K _getValue(_SplayTreeNode<K> node) => node.key;
 }
 
 class _SplayTreeValueIterator<K, V> extends _SplayTreeIterator<K, V> {
-  _SplayTreeValueIterator(SplayTreeMap<K, V> map): super(map);
+  _SplayTreeValueIterator(SplayTreeMap<K, V> map) : super(map);
   V _getValue(_SplayTreeNode<K> node) {
     _SplayTreeMapNode<K, V> mapNode =
         node as dynamic/*=_SplayTreeMapNode<K, V>*/;
     return mapNode.value;
   }
 }
 
 class _SplayTreeNodeIterator<K>
     extends _SplayTreeIterator<K, _SplayTreeNode<K>> {
-  _SplayTreeNodeIterator(_SplayTree<K, _SplayTreeNode<K>> tree): super(tree);
+  _SplayTreeNodeIterator(_SplayTree<K, _SplayTreeNode<K>> tree) : super(tree);
   _SplayTreeNodeIterator.startAt(
       _SplayTree<K, _SplayTreeNode<K>> tree, K startKey)
       : super.startAt(tree, startKey);
   _SplayTreeNode<K> _getValue(_SplayTreeNode<K> node) => node;
 }
 
-
 /**
  * A [Set] of objects that can be ordered relative to each other.
  *
  * The set is based on a self-balancing binary tree. It allows most operations
  * in amortized logarithmic time.
  *
  * Elements of the set are compared using the `compare` function passed in
  * the constructor, both for ordering and for equality.
  * If the set contains only an object `a`, then `set.contains(b)`
  * will return `true` if and only if `compare(a, b) == 0`,
@@ skipping 41 matching lines @@
         _validKey = isValidKey ?? ((v) => v is E);
 
   /**
    * Creates a [SplayTreeSet] that contains all [elements].
    *
    * The set works as if created by `new SplayTreeSet<E>(compare, isValidKey)`.
    *
    * All the [elements] should be valid as arguments to the [compare] function.
    */
   factory SplayTreeSet.from(Iterable elements,
-                            [int compare(E key1, E key2),
-                             bool isValidKey(potentialKey)]) {
+      [int compare(E key1, E key2), bool isValidKey(potentialKey)]) {
     SplayTreeSet<E> result = new SplayTreeSet<E>(compare, isValidKey);
     for (final element in elements) {
       E e = element as Object/*=E*/;
       result.add(e);
     }
     return result;
   }
 
   int _compare(E e1, E e2) => _comparator(e1, e2);
 
@@ skipping 106 matching lines @@
     var set = new SplayTreeSet<E>(_comparator, _validKey);
     set._count = _count;
     set._root = _copyNode(_root);
     return set;
   }
 
   // Copies the structure of a SplayTree into a new similar structure.
   // Works on _SplayTreeMapNode as well, but only copies the keys,
   _SplayTreeNode<E> _copyNode(_SplayTreeNode<E> node) {
     if (node == null) return null;
-    return new _SplayTreeNode<E>(node.key)..left = _copyNode(node.left)
-                                          ..right = _copyNode(node.right);
+    return new _SplayTreeNode<E>(node.key)
+      ..left = _copyNode(node.left)
+      ..right = _copyNode(node.right);
   }
 
-  void clear() { _clear(); }
+  void clear() {
+    _clear();
+  }
 
   Set<E> toSet() => _clone();
 
   String toString() => IterableBase.iterableToFullString(this, '{', '}');
 }