Format all dart: library files

sdk/lib/internal/iterable.dart

 // Copyright (c) 2011, 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._internal;
 
 /**
  * Marker interface for [Iterable] subclasses that have an efficient
  * [length] implementation.
  */
@@ skipping 76 matching lines @@
     int length = this.length;
     for (int i = 0; i < length; i++) {
       if (test(elementAt(i))) return true;
       if (length != this.length) {
         throw new ConcurrentModificationError(this);
       }
     }
     return false;
   }
 
-  E firstWhere(bool test(E element), { E orElse() }) {
+  E firstWhere(bool test(E element), {E orElse()}) {
     int length = this.length;
     for (int i = 0; i < length; i++) {
       E element = elementAt(i);
       if (test(element)) return element;
       if (length != this.length) {
         throw new ConcurrentModificationError(this);
       }
     }
     if (orElse != null) return orElse();
     throw IterableElementError.noElement();
   }
 
-  E lastWhere(bool test(E element), { E orElse() }) {
+  E lastWhere(bool test(E element), {E orElse()}) {
     int length = this.length;
     for (int i = length - 1; i >= 0; i--) {
       E element = elementAt(i);
       if (test(element)) return element;
       if (length != this.length) {
         throw new ConcurrentModificationError(this);
       }
     }
     if (orElse != null) return orElse();
     throw IterableElementError.noElement();
@@ skipping 55 matching lines @@
 
   E reduce(E combine(var value, E element)) {
     int length = this.length;
     if (length == 0) throw IterableElementError.noElement();
     E value = elementAt(0);
     for (int i = 1; i < length; i++) {
       value = combine(value, elementAt(i));
       if (length != this.length) {
         throw new ConcurrentModificationError(this);
       }
-
     }
     return value;
   }
 
   T fold<T>(T initialValue, T combine(T previousValue, E element)) {
     var value = initialValue;
     int length = this.length;
     for (int i = 0; i < length; i++) {
       value = combine(value, elementAt(i));
       if (length != this.length) {
         throw new ConcurrentModificationError(this);
       }
     }
     return value;
   }
 
   Iterable<E> skip(int count) => new SubListIterable<E>(this, count, null);
 
   Iterable<E> skipWhile(bool test(E element)) => super.skipWhile(test);
 
   Iterable<E> take(int count) => new SubListIterable<E>(this, 0, count);
 
   Iterable<E> takeWhile(bool test(E element)) => super.takeWhile(test);
 
-  List<E> toList({ bool growable: true }) {
+  List<E> toList({bool growable: true}) {
     List<E> result;
     if (growable) {
       result = new List<E>()..length = length;
     } else {
       result = new List<E>(length);
     }
     for (int i = 0; i < length; i++) {
       result[i] = elementAt(i);
     }
     return result;
   }
 
   Set<E> toSet() {
     Set<E> result = new Set<E>();
     for (int i = 0; i < length; i++) {
       result.add(elementAt(i));
     }
     return result;
   }
 }
 
 class SubListIterable<E> extends ListIterable<E> {
-  final Iterable<E> _iterable;  // Has efficient length and elementAt.
+  final Iterable<E> _iterable; // Has efficient length and elementAt.
   final int _start;
   /** If null, represents the length of the iterable. */
   final int _endOrLength;
 
   SubListIterable(this._iterable, this._start, this._endOrLength) {
     RangeError.checkNotNegative(_start, "start");
     if (_endOrLength != null) {
       RangeError.checkNotNegative(_endOrLength, "end");
       if (_start > _endOrLength) {
         throw new RangeError.range(_start, 0, _endOrLength, "start");
@@ skipping 49 matching lines @@
       return new SubListIterable<E>(_iterable, _start, newEnd);
     }
   }
 
   List<E> toList({bool growable: true}) {
     int start = _start;
     int end = _iterable.length;
     if (_endOrLength != null && _endOrLength < end) end = _endOrLength;
     int length = end - start;
     if (length < 0) length = 0;
-    List<E> result = growable ? (new List<E>()..length = length)
-                              : new List<E>(length);
+    List<E> result =
+        growable ? (new List<E>()..length = length) : new List<E>(length);
     for (int i = 0; i < length; i++) {
       result[i] = _iterable.elementAt(start + i);
       if (_iterable.length < end) throw new ConcurrentModificationError(this);
     }
     return result;
   }
 }
 
 /**
  * An [Iterator] that iterates a list-like [Iterable].
  *
  * All iterations is done in terms of [Iterable.length] and
  * [Iterable.elementAt]. These operations are fast for list-like
  * iterables.
  */
 class ListIterator<E> implements Iterator<E> {
   final Iterable<E> _iterable;
   final int _length;
   int _index;
   E _current;
 
   ListIterator(Iterable<E> iterable)
-      : _iterable = iterable, _length = iterable.length, _index = 0;
+      : _iterable = iterable,
+        _length = iterable.length,
+        _index = 0;
 
   E get current => _current;
 
   bool moveNext() {
     int length = _iterable.length;
     if (_length != length) {
       throw new ConcurrentModificationError(_iterable);
     }
     if (_index >= length) {
       _current = null;
@@ skipping 66 matching lines @@
 class MappedListIterable<S, T> extends ListIterable<T> {
   final Iterable<S> _source;
   final _Transformation<S, T> _f;
 
   MappedListIterable(this._source, this._f);
 
   int get length => _source.length;
   T elementAt(int index) => _f(_source.elementAt(index));
 }
 
-
 typedef bool _ElementPredicate<E>(E element);
 
 class WhereIterable<E> extends Iterable<E> {
   final Iterable<E> _iterable;
   final _ElementPredicate<E> _f;
 
   WhereIterable(this._iterable, this._f);
 
   Iterator<E> get iterator => new WhereIterator<E>(_iterable.iterator, _f);
 
@@ skipping 76 matching lines @@
   }
 
   TakeIterable._(this._iterable, this._takeCount);
 
   Iterator<E> get iterator {
     return new TakeIterator<E>(_iterable.iterator, _takeCount);
   }
 }
 
 class EfficientLengthTakeIterable<E> extends TakeIterable<E>
-                                     implements EfficientLengthIterable<E> {
+    implements EfficientLengthIterable<E> {
   EfficientLengthTakeIterable(Iterable<E> iterable, int takeCount)
       : super._(iterable, takeCount);
 
   int get length {
     int iterableLength = _iterable.length;
     if (iterableLength > _takeCount) return _takeCount;
     return iterableLength;
   }
 }
 
-
 class TakeIterator<E> extends Iterator<E> {
   final Iterator<E> _iterator;
   int _remaining;
 
   TakeIterator(this._iterator, this._remaining) {
     assert(_remaining is int && _remaining >= 0);
   }
 
   bool moveNext() {
     _remaining--;
@@ skipping 68 matching lines @@
     RangeError.checkNotNegative(_skipCount, "count");
     return new SkipIterable<E>._(_iterable, _skipCount + count);
   }
 
   Iterator<E> get iterator {
     return new SkipIterator<E>(_iterable.iterator, _skipCount);
   }
 }
 
 class EfficientLengthSkipIterable<E> extends SkipIterable<E>
-                                     implements EfficientLengthIterable<E> {
+    implements EfficientLengthIterable<E> {
   EfficientLengthSkipIterable(Iterable<E> iterable, int skipCount)
       : super._(iterable, skipCount);
 
   int get length {
     int length = _iterable.length - _skipCount;
     if (length >= 0) return length;
     return 0;
   }
 }
 
@@ skipping 52 matching lines @@
   const EmptyIterable();
 
   Iterator<E> get iterator => const EmptyIterator();
 
   void forEach(void action(E element)) {}
 
   bool get isEmpty => true;
 
   int get length => 0;
 
-  E get first { throw IterableElementError.noElement(); }
+  E get first {
+    throw IterableElementError.noElement();
+  }
 
-  E get last { throw IterableElementError.noElement(); }
+  E get last {
+    throw IterableElementError.noElement();
+  }
 
-  E get single { throw IterableElementError.noElement(); }
+  E get single {
+    throw IterableElementError.noElement();
+  }
 
-  E elementAt(int index) { throw new RangeError.range(index, 0, 0, "index"); }
+  E elementAt(int index) {
+    throw new RangeError.range(index, 0, 0, "index");
+  }
 
   bool contains(Object element) => false;
 
   bool every(bool test(E element)) => true;
 
   bool any(bool test(E element)) => false;
 
-  E firstWhere(bool test(E element), { E orElse() }) {
+  E firstWhere(bool test(E element), {E orElse()}) {
     if (orElse != null) return orElse();
     throw IterableElementError.noElement();
   }
 
-  E lastWhere(bool test(E element), { E orElse() }) {
+  E lastWhere(bool test(E element), {E orElse()}) {
     if (orElse != null) return orElse();
     throw IterableElementError.noElement();
   }
 
-  E singleWhere(bool test(E element), { E orElse() }) {
+  E singleWhere(bool test(E element), {E orElse()}) {
     if (orElse != null) return orElse();
     throw IterableElementError.noElement();
   }
 
   String join([String separator = ""]) => "";
 
   Iterable<E> where(bool test(E element)) => this;
 
   Iterable<T> map<T>(T f(E element)) => const EmptyIterable();
 
@@ skipping 35 matching lines @@
  * Creates errors throw by [Iterable] when the element count is wrong.
  */
 abstract class IterableElementError {
   /** Error thrown thrown by, e.g., [Iterable.first] when there is no result. */
   static StateError noElement() => new StateError("No element");
   /** Error thrown by, e.g., [Iterable.single] if there are too many results. */
   static StateError tooMany() => new StateError("Too many elements");
   /** Error thrown by, e.g., [List.setRange] if there are too few elements. */
   static StateError tooFew() => new StateError("Too few elements");
 }