Move toString() to collection classes.

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 61 matching lines @@
 
 
 /**
  * An entry in a doubly linked list. It contains a pointer to the next
  * entry, the previous entry, and the boxed element.
  *
  * WARNING: This class is temporary located in dart:core. It'll be removed
  * at some point in the near future.
  */
 class DoubleLinkedQueueEntry<E> {
+  
   DoubleLinkedQueueEntry<E> _previous;
   DoubleLinkedQueueEntry<E> _next;
   E _element;
 
   DoubleLinkedQueueEntry(E e) {
     _element = e;
   }
 
   void _link(DoubleLinkedQueueEntry<E> p,
              DoubleLinkedQueueEntry<E> n) {
@@ skipping 71 matching lines @@
 }
 
 /**
  * A [Queue] implementation based on a double-linked list.
  *
  * Allows constant time add, remove-at-ends and peek operations.
  *
  * Can do [removeAll] and [retainAll] in linear time.
  */
 class DoubleLinkedQueue<E> extends IterableBase<E> implements Queue<E> {
+  static List _toStringList = new List();
   _DoubleLinkedQueueEntrySentinel<E> _sentinel;
   int _elementCount = 0;
 
   DoubleLinkedQueue() {
     _sentinel = new _DoubleLinkedQueueEntrySentinel<E>();
   }
 
   factory DoubleLinkedQueue.from(Iterable<E> other) {
     Queue<E> list = new DoubleLinkedQueue();
     for (final e in other) {
@@ skipping 110 matching lines @@
     while (!identical(entry, _sentinel)) {
       DoubleLinkedQueueEntry<E> nextEntry = entry._next;
       f(entry);
       entry = nextEntry;
     }
   }
 
   _DoubleLinkedQueueIterator<E> get iterator {
     return new _DoubleLinkedQueueIterator<E>(_sentinel);
   }
-
+  
   String toString() {
-    return ToString.iterableToString(this);
+    for(int i = 0; i < _toStringList.length; i++) {

[floitsch, 2013/07/08 12:00:50]

Redirect to IterableMixinWorkaround for now. Add TODO, that code should be
inherited by IterableBase.

[zarah, 2013/07/08 14:35:15]

Done.

+      if(identical(_toStringList[i], this))
+          return '{...}';
+    }
+    _toStringList.add(this);
+    String result = IterableMixinWorkaround.toStringIterable(this);
+    _toStringList.remove(this);
+    return result;
   }
 }
 
 class _DoubleLinkedQueueIterator<E> implements Iterator<E> {
   _DoubleLinkedQueueEntrySentinel<E> _sentinel;
   DoubleLinkedQueueEntry<E> _currentEntry = null;
   E _current;
 
   _DoubleLinkedQueueIterator(_DoubleLinkedQueueEntrySentinel<E> sentinel)
       : _sentinel = sentinel, _currentEntry = sentinel;
@@ skipping 25 matching lines @@
  * it fills up. This guarantees constant time peek and remove operations, and
  * amortized constant time add operations.
  *
  * The structure is efficient for any queue or stack usage.
  *
  * Operations like [removeAll] and [removeWhere] are very
  * inefficient. If those are needed, use a [DoubleLinkedQueue] instead.
  */
 class ListQueue<E> extends IterableBase<E> implements Queue<E> {
   static const int _INITIAL_CAPACITY = 8;
+  static List _toStringList = new List();
   List<E> _table;
   int _head;
   int _tail;
   int _modificationCount = 0;
 
   /**
    * Create an empty queue.
    *
    * If [initialCapacity] is given, prepare the queue for at least that many
    * elements.
@@ skipping 162 matching lines @@
   void clear() {
     if (_head != _tail) {
       for (int i = _head; i != _tail; i = (i + 1) & (_table.length - 1)) {
         _table[i] = null;
       }
       _head = _tail = 0;
       _modificationCount++;
     }
   }
 
   String toString() {

[floitsch, 2013/07/08 12:00:50]

ditto.

[zarah, 2013/07/08 14:35:15]

Done.

-    return ToString.iterableToString(this);
+    for(int i = 0; i < _toStringList.length; i++) {
+      if(identical(_toStringList[i], this))
+          return '{...}';
+    }
+    _toStringList.add(this);
+    String result = IterableMixinWorkaround.toStringIterable(this);
+    _toStringList.remove(this);
+    return result;
   }
 
   // Queue interface.
 
   void addLast(E element) { _add(element); }
 
   void addFirst(E element) {
     _head = (_head - 1) & (_table.length - 1);
     _table[_head] = element;
     if (_head == _tail) _grow();
@@ skipping 131 matching lines @@
     _head = 0;
   }
 }
 
 /**
  * Iterator for a [ListQueue].
  *
  * Considers any add or remove operation a concurrent modification.
  */
 class _ListQueueIterator<E> implements Iterator<E> {
+  
   final ListQueue _queue;
   final int _end;
   final int _modificationCount;
   int _position;
   E _current;
 
   _ListQueueIterator(ListQueue queue)
       : _queue = queue,
         _end = queue._tail,
         _modificationCount = queue._modificationCount,
         _position = queue._head;
 
   E get current => _current;
 
   bool moveNext() {
     _queue._checkModification(_modificationCount);
     if (_position == _end) {
       _current = null;
       return false;
     }
     _current = _queue._table[_position];
     _position = (_position + 1) & (_queue._table.length - 1);
     return true;
   }
 }