Add EfficientLength marker interface to some iterabels.

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].
  */
-abstract class Queue<E> implements Iterable<E> {
+abstract class Queue<E> implements Iterable<E>, EfficientLength {
 
   /**
    * Creates a queue.
    */
-  factory Queue() => new ListQueue<E>();
+  factory Queue() = ListQueue<E>;
 
   /**
    * Creates a queue with the elements of [other]. The order in
    * the queue will be the order provided by the iterator of [other].
    */
-  factory Queue.from(Iterable<E> other) => new ListQueue<E>.from(other);
+  factory Queue.from(Iterable<E> other) = ListQueue<E>.from;
+
+  /**
+   * Returns the number of elements in the queue.
+   *
+   * This operation is efficient and does not require iterating and counting
+   * the elements.
+   */
+  int get length;
 
   /**
    * Removes and returns the first element of this queue. Throws an
    * [StateError] exception if this queue is empty.
    */
   E removeFirst();
 
   /**
    * Removes and returns the last element of the queue. Throws an
    * [StateError] exception if this queue is empty.
@@ skipping 16 matching lines @@
   void add(E value);
 
   /**
    * Remove a single instance of [value] from the queue.
    *
    * Returns `true` if a value was removed, or `false` if the queue
    * contained no element equal to [value].
    */
   bool remove(Object object);
 
-
   /**
    * Adds all elements of [iterable] at the end of the queue. The
    * length of the queue is extended by the length of [iterable].
    */
   void addAll(Iterable<E> iterable);
 
   /**
    * Removes all elements in the queue. The size of the queue becomes zero.
    */
   void clear();
@@ skipping 226 matching lines @@
   _DoubleLinkedQueueIterator<E> get iterator {
     return new _DoubleLinkedQueueIterator<E>(_sentinel);
   }
 
   // TODO(zarah)  Remove this, and let it be inherited by IterableBase
   String toString() => IterableMixinWorkaround.toStringIterable(this, '{', '}');
 }
 
 class _DoubleLinkedQueueIterator<E> implements Iterator<E> {
   _DoubleLinkedQueueEntrySentinel<E> _sentinel;
-  DoubleLinkedQueueEntry<E> _currentEntry = null;
+  DoubleLinkedQueueEntry<E> _nextEntry = null;
   E _current;
 
   _DoubleLinkedQueueIterator(_DoubleLinkedQueueEntrySentinel<E> sentinel)
-      : _sentinel = sentinel, _currentEntry = sentinel;
+      : _sentinel = sentinel, _nextEntry = sentinel._next;
 
   bool moveNext() {
     // When [_currentEntry] it is set to [:null:] then it is at the end.
-    if (_currentEntry == null) {
-      assert(_current == null);
-      return false;
+    if (!identical(_nextEntry, _sentinel)) {
+      _current = _nextEntry._element;
+      _nextEntry = _nextEntry._next;
+      return true;
     }
-    _currentEntry = _currentEntry._next;
-    if (identical(_currentEntry, _sentinel)) {
-      _currentEntry = null;
-      _current = null;
-      _sentinel = null;
-      return false;
-    }
-    _current = _currentEntry.element;
-    return true;
+    _current = null;
+    _nextEntry = _sentinel = null;  // Still identical.
+    return false;
   }
 
   E get current => _current;
 }
 
 /**
  * List based [Queue].
  *
  * Keeps a cyclic buffer of elements, and grows to a larger buffer when
  * it fills up. This guarantees constant time peek and remove operations, and
@@ skipping 358 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;
   }
 }