Format all dart: library files

sdk/lib/collection/queue.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.collection;
 
 /**
  * A [Queue] is a collection that can be manipulated at both ends. One
  * can iterate over the elements of a queue through [forEach] or with
  * an [Iterator].
  *
  * It is generally not allowed to modify the queue (add or remove entries) while
  * an operation on the queue is being performed, for example during a call to
  * [forEach].
  * Modifying the queue while it is being iterated will most likely break the
  * iteration.
  * This goes both for using the [iterator] directly, or for iterating an
  * `Iterable` returned by a method like [map] or [where].
  */
 abstract class Queue<E> implements EfficientLengthIterable<E> {
-
   /**
    * Creates a queue.
    */
   factory Queue() = ListQueue<E>;
 
   /**
    * Creates a queue containing all [elements].
    *
    * The element order in the queue is as if the elements were added using
    * [addLast] in the order provided by [elements.iterator].
@@ skipping 56 matching lines @@
    * The `test` function must not throw or modify the queue.
    */
   void retainWhere(bool test(E element));
 
   /**
    * Removes all elements in the queue. The size of the queue becomes zero.
    */
   void clear();
 }
 
-
 class _DoubleLink<Link extends _DoubleLink> {
   Link _previousLink;
   Link _nextLink;
 
   void _link(Link previous, Link next) {
     _nextLink = next;
     _previousLink = previous;
     if (previous != null) previous._nextLink = this;
     if (next != null) next._previousLink = this;
   }
@@ skipping 39 matching lines @@
 }
 
 /**
  * Interface for the link classes used by [DoubleLinkedQueue].
  *
  * Both the [_DoubleLinkedQueueElement] and [_DoubleLinkedQueueSentinel]
  * implement this interface.
  * The entry contains a link back to the queue, so calling `append`
  * or `prepend` can correctly update the element count.
  */
-abstract class _DoubleLinkedQueueEntry<E>
-    extends DoubleLinkedQueueEntry<E> {
+abstract class _DoubleLinkedQueueEntry<E> extends DoubleLinkedQueueEntry<E> {
   DoubleLinkedQueue<E> _queue;
   _DoubleLinkedQueueEntry(E element, this._queue) : super(element);
 
   DoubleLinkedQueueEntry<E> _asNonSentinelEntry();
 
   void _append(E e) {
     new _DoubleLinkedQueueElement<E>(e, _queue)._link(this, _nextLink);
   }
 
   void _prepend(E e) {
@@ skipping 55 matching lines @@
 
 /**
  * A sentinel in a double linked list is used to manipulate the list
  * at both ends.
  * A double linked list has exactly one sentinel,
  * which is the only entry when the list is constructed.
  * Initially, a sentinel has its next and previous entry point to itself.
  * A sentinel does not box any user element.
  */
 class _DoubleLinkedQueueSentinel<E> extends _DoubleLinkedQueueEntry<E> {
-  _DoubleLinkedQueueSentinel(DoubleLinkedQueue<E> queue)
-      : super(null, queue) {
+  _DoubleLinkedQueueSentinel(DoubleLinkedQueue<E> queue) : super(null, queue) {
     _previousLink = this;
     _nextLink = this;
   }
 
   DoubleLinkedQueueEntry<E> _asNonSentinelEntry() {
     return null;
   }
 
   /** Hit by, e.g., [DoubleLinkedQueue.removeFirst] if the queue is empty. */
   E _remove() {
@@ skipping 91 matching lines @@
   }
 
   void _filter(bool test(E element), bool removeMatching) {
     _DoubleLinkedQueueEntry<E> entry = _sentinel._nextLink;
     while (!identical(entry, _sentinel)) {
       bool matches = test(entry._element);
       if (!identical(this, entry._queue)) {
         // Entry must still be in the queue.
         throw new ConcurrentModificationError(this);
       }
-      _DoubleLinkedQueueEntry<E> next = entry._nextLink;  // Cannot be null.
+      _DoubleLinkedQueueEntry<E> next = entry._nextLink; // Cannot be null.
       if (identical(removeMatching, matches)) {
         entry._remove();
         _elementCount--;
       }
       entry = next;
     }
   }
 
   void removeWhere(bool test(E element)) {
     _filter(test, true);
@@ skipping 148 matching lines @@
   int _head;
   int _tail;
   int _modificationCount = 0;
 
   /**
    * Create an empty queue.
    *
    * If [initialCapacity] is given, prepare the queue for at least that many
    * elements.
    */
-  ListQueue([int initialCapacity]) : _head = 0, _tail = 0 {
+  ListQueue([int initialCapacity])
+      : _head = 0,
+        _tail = 0 {
     if (initialCapacity == null || initialCapacity < _INITIAL_CAPACITY) {
       initialCapacity = _INITIAL_CAPACITY;
     } else if (!_isPowerOf2(initialCapacity)) {
       initialCapacity = _nextPowerOf2(initialCapacity);
     }
     assert(_isPowerOf2(initialCapacity));
     _table = new List<E>(initialCapacity);
   }
 
   /**
@@ skipping 24 matching lines @@
         result.addLast(element as Object/*=E*/);
       }
       return result;
     }
   }
 
   // Iterable interface.
 
   Iterator<E> get iterator => new _ListQueueIterator<E>(this);
 
-  void forEach(void action (E element)) {
+  void forEach(void action(E element)) {
     int modificationCount = _modificationCount;
     for (int i = _head; i != _tail; i = (i + 1) & (_table.length - 1)) {
       action(_table[i]);
       _checkModification(modificationCount);
     }
   }
 
   bool get isEmpty => _head == _tail;
 
   int get length => (_tail - _head) & (_table.length - 1);
@@ skipping 12 matching lines @@
     if (_head == _tail) throw IterableElementError.noElement();
     if (length > 1) throw IterableElementError.tooMany();
     return _table[_head];
   }
 
   E elementAt(int index) {
     RangeError.checkValidIndex(index, this);
     return _table[(_head + index) & (_table.length - 1)];
   }
 
-  List<E> toList({ bool growable: true }) {
+  List<E> toList({bool growable: true}) {
     List<E> list;
     if (growable) {
       list = new List<E>()..length = length;
     } else {
       list = new List<E>(length);
     }
     _writeToList(list);
     return list;
   }
 
@@ skipping 87 matching lines @@
       }
       _head = _tail = 0;
       _modificationCount++;
     }
   }
 
   String toString() => IterableBase.iterableToFullString(this, "{", "}");
 
   // Queue interface.
 
-  void addLast(E value) { _add(value); }
+  void addLast(E value) {
+    _add(value);
+  }
 
   void addFirst(E value) {
     _head = (_head - 1) & (_table.length - 1);
     _table[_head] = value;
     if (_head == _tail) _grow();
     _modificationCount++;
   }
 
   E removeFirst() {
     if (_head == _tail) throw IterableElementError.noElement();
@@ skipping 25 matching lines @@
   /**
    * Rounds [number] up to the nearest power of 2.
    *
    * If [number] is a power of 2 already, it is returned.
    *
    * Only works for positive numbers.
    */
   static int _nextPowerOf2(int number) {
     assert(number > 0);
     number = (number << 1) - 1;
-    for(;;) {
+    for (;;) {
       int nextNumber = number & (number - 1);
       if (nextNumber == 0) return number;
       number = nextNumber;
     }
   }
 
   /** Check if the queue has been modified during iteration. */
   void _checkModification(int expectedModificationCount) {
     if (expectedModificationCount != _modificationCount) {
       throw new ConcurrentModificationError(this);
@@ skipping 112 matching lines @@
     _queue._checkModification(_modificationCount);
     if (_position == _end) {
       _current = null;
       return false;
     }
     _current = _queue._table[_position];
     _position = (_position + 1) & (_queue._table.length - 1);
     return true;
   }
 }