Make DoubleLinkedQueueEntry subclassable again.

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].
@@ skipping 78 matching lines @@
    */
   void retainWhere(bool test(E element));
 
   /**
    * Removes all elements in the queue. The size of the queue becomes zero.
    */
   void clear();
 }
 
 
-class _DoubleLink<E extends _DoubleLink> {
-  E _previousLink;
-  E _nextLink;
+class _DoubleLink<Link extends _DoubleLink> {
+  Link _previousLink;
+  Link _nextLink;
 
-  void _link(E previous, E next) {
+  void _link(Link previous, Link next) {
     _nextLink = next;
     _previousLink = previous;
     if (previous != null) previous._nextLink = this;
     if (next != null) next._previousLink = this;
   }
 
   void _unlink() {
     if (_previousLink != null) _previousLink._nextLink = _nextLink;
     if (_nextLink != null) _nextLink._previousLink = _previousLink;
     _nextLink = null;
     _previousLink = null;
   }
 }
 
 /**
  * An entry in a doubly linked list. It contains a pointer to the next
  * entry, the previous entry, and the boxed element.
  */
-abstract class DoubleLinkedQueueEntry<E> {
-  factory DoubleLinkedQueueEntry(E element) = _UserDoubleLinkedQueueEntry<E>;
+class DoubleLinkedQueueEntry<E> extends _DoubleLink<DoubleLinkedQueueEntry<E>> {
+  /// The element in the queue.
+  E element;
 
-  /// The element in the queue.
-  E get element;
+  DoubleLinkedQueueEntry(this.element);
 
   /// Appends the given [e] as entry just after this entry.
-  void append(E e);
+  void append(E e) {
+    new DoubleLinkedQueueEntry<E>(e)._link(this, _nextLink);
+  }
 
   /// Prepends the given [e] as entry just before this entry.
-  void prepend(E e);
-
-  /// Returns the previous entry or `null` if there is none.
-  DoubleLinkedQueueEntry<E> previousEntry();
-
-  /// Returns the next entry or `null` if there is none.
-  DoubleLinkedQueueEntry<E> nextEntry();
-}
-
-/// Default implementation of a doubly linked queue entry.
-///
-/// This implementation is only used if a user instantiates a
-/// [DoubleLinkedQueueEntry] directly. The internal implementations don't use
-/// this class.
-class _UserDoubleLinkedQueueEntry<E>
-    extends _DoubleLink<_UserDoubleLinkedQueueEntry<E>>
-    implements DoubleLinkedQueueEntry<E> {
-  E element;
-
-  _UserDoubleLinkedQueueEntry(this.element);
-
-  void append(E e) {
-    new _UserDoubleLinkedQueueEntry<E>(e)._link(this, _nextLink);
-  }
-
   void prepend(E e) {
-    new _UserDoubleLinkedQueueEntry<E>(e)._link(_previousLink, this);
+    new DoubleLinkedQueueEntry<E>(e)._link(_previousLink, this);
   }
 
   E remove() {
     _unlink();
     return element;
   }
 
+  /// Returns the previous entry or `null` if there is none.
   DoubleLinkedQueueEntry<E> previousEntry() => _previousLink;
 
+  /// Returns the next entry or `null` if there is none.
   DoubleLinkedQueueEntry<E> nextEntry() => _nextLink;
 }
 
 /**
  * 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 _DoubleLink<_DoubleLinkedQueueEntry<E>> {
+    extends DoubleLinkedQueueEntry<E> {
   DoubleLinkedQueue<E> _queue;
-  _DoubleLinkedQueueEntry(this._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) {
     new _DoubleLinkedQueueElement<E>(e, _queue)._link(_previousLink, this);
   }
 
   E _remove();
 
-  E get element;
+  E get _element => element;
 
   DoubleLinkedQueueEntry<E> nextEntry() {
-    return _nextLink._asNonSentinelEntry();
+    _DoubleLinkedQueueEntry<E> entry =
+        _nextLink as dynamic/*=DoubleLinkedQueueEntry<E>*/;
+    return entry._asNonSentinelEntry();
   }
 
   DoubleLinkedQueueEntry<E> previousEntry() {
-    return _previousLink._asNonSentinelEntry();
+    _DoubleLinkedQueueEntry<E> entry =
+        _previousLink as dynamic/*=DoubleLinkedQueueEntry<E>*/;
+    return entry._asNonSentinelEntry();
   }
 }
 
 /**
  * The actual entry type used by the [DoubleLinkedQueue].
  *
  * The entry contains a reference to the queue, allowing
  * [append]/[prepend] to update the list length.
  */
-class _DoubleLinkedQueueElement<E> extends _DoubleLinkedQueueEntry<E>
-                                   implements DoubleLinkedQueueEntry<E> {
-  E element;
-  _DoubleLinkedQueueElement(this.element, DoubleLinkedQueue<E> queue)
-      : super(queue);
+class _DoubleLinkedQueueElement<E> extends _DoubleLinkedQueueEntry<E> {
+  _DoubleLinkedQueueElement(E element, DoubleLinkedQueue<E> queue)
+      : super(element, queue);
 
   void append(E e) {
     _append(e);
     if (_queue != null) _queue._elementCount++;
   }
 
   void prepend(E e) {
     _prepend(e);
     if (_queue != null) _queue._elementCount++;
   }
@@ skipping 16 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(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() {
     throw IterableElementError.noElement();
   }
 
   /** Hit by, e.g., [DoubleLinkedQueue.first] if the queue is empty. */
-  E get element {
+  E get _element {
     throw IterableElementError.noElement();
   }
 }
 
 /**
  * A [Queue] implementation based on a double-linked list.
  *
  * Allows constant time add, remove-at-ends and peek operations.
  */
 class DoubleLinkedQueue<E> extends Iterable<E> implements Queue<E> {
@@ skipping 53 matching lines @@
   E removeFirst() {
     _DoubleLinkedQueueEntry<E> firstEntry = _sentinel._nextLink;
     E result = firstEntry._remove();
     _elementCount--;
     return result;
   }
 
   bool remove(Object o) {
     _DoubleLinkedQueueEntry<E> entry = _sentinel._nextLink;
     while (!identical(entry, _sentinel)) {
-      if (entry.element == o) {
+      if (entry._element == o) {
         entry._remove();
         _elementCount--;
         return true;
       }
       entry = entry._nextLink;
     }
     return false;
   }
 
   void _filter(bool test(E element), bool removeMatching) {
     _DoubleLinkedQueueEntry<E> entry = _sentinel._nextLink;
     while (!identical(entry, _sentinel)) {
       _DoubleLinkedQueueEntry<E> next = entry._nextLink;
-      if (identical(removeMatching, test(entry.element))) {
+      if (identical(removeMatching, test(entry._element))) {
         entry._remove();
         _elementCount--;
       }
       entry = next;
     }
   }
 
   void removeWhere(bool test(E element)) {
     _filter(test, true);
   }
 
   void retainWhere(bool test(E element)) {
     _filter(test, false);
   }
 
   E get first {
     _DoubleLinkedQueueEntry<E> firstEntry = _sentinel._nextLink;
-    return firstEntry.element;
+    return firstEntry._element;
   }
 
   E get last {
     _DoubleLinkedQueueEntry<E> lastEntry = _sentinel._previousLink;
-    return lastEntry.element;
+    return lastEntry._element;
   }
 
   E get single {
     // Note that this throws correctly if the queue is empty
     // because reading element on the sentinel throws.
     if (identical(_sentinel._nextLink, _sentinel._previousLink)) {
       _DoubleLinkedQueueEntry<E> entry = _sentinel._nextLink;
-      return entry.element;
+      return entry._element;
     }
     throw IterableElementError.tooMany();
   }
 
   DoubleLinkedQueueEntry<E> lastEntry() {
     return _sentinel.previousEntry();
   }
 
   DoubleLinkedQueueEntry<E> firstEntry() {
     return _sentinel.nextEntry();
@@ skipping 39 matching lines @@
     if (identical(_nextEntry, _sentinel)) {
       _current = null;
       _nextEntry = null;
       _sentinel = null;
       return false;
     }
     _DoubleLinkedQueueElement<E> elementEntry = _nextEntry;
     if (elementEntry._queue == null) {
       throw new ConcurrentModificationError(_sentinel._queue);
     }
-    _current = elementEntry.element;
+    _current = elementEntry._element;
     _nextEntry = elementEntry._nextLink;
     return true;
   }
 
   E get current => _current;
 }
 
 /**
  * List based [Queue].
  *
@@ skipping 374 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;
   }
 }