Fix String.trim implementation (follow spec).

corelib/src/implementation/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.
 
 
 /**
  * An entry in a doubly linked list. It contains a pointer to the next
  * entry, the previous entry, and the boxed element.
  */
 class DoubleLinkedQueueEntry<E> {
@@ skipping 153 matching lines @@
   }
 
   void clear() {
     _sentinel._next = _sentinel;
     _sentinel._previous = _sentinel;
   }
 
   void forEach(void f(E element)) {
     DoubleLinkedQueueEntry<E> entry = _sentinel._next;
     while (entry !== _sentinel) {
+      DoubleLinkedQueueEntry<E> nextEntry = entry._next;
       f(entry._element);
-      entry = entry._next;
+      entry = nextEntry;
     }
   }
 
   void forEachEntry(void f(DoubleLinkedQueueEntry<E> element)) {
     DoubleLinkedQueueEntry<E> entry = _sentinel._next;
     while (entry !== _sentinel) {
+      DoubleLinkedQueueEntry<E> nextEntry = entry._next;
       f(entry);
-      entry = entry._next;
+      entry = nextEntry;

[siva, 2011/11/14 21:26:17]

How will this protect against somebody writing an
'f' that removes both entry and entry._next from the queue.

Shouldn't we just throw some kind of ConcurrentModification Exception when we
detect that the code modifies a collection directly while it is iterating over
the collection.

[hausner, 2011/11/14 21:58:02]

I agree with Siva's comment. Probably need to have some sort of mutation count
or something.

On 2011/11/14 21:26:17, asiva wrote:

[srdjan, 2011/11/14 22:15:33]

It is possible for programmers to write the closures in a non-functional way so
that the list is modified twice during one for each. It is much rarer situation
than the typical usage, and closure itself cannot modify the list, only the
entry.

Filed a bug for ConcurrentModification clarification (442)

[srdjan, 2011/11/14 22:15:33]

Filed bug 442 for clarification of modification behavior.

     }
   }
 
   bool every(bool f(E element)) {
     DoubleLinkedQueueEntry<E> entry = _sentinel._next;
     while (entry !== _sentinel) {
+      DoubleLinkedQueueEntry<E> nextEntry = entry._next;
       if (!f(entry._element)) return false;
-      entry = entry._next;
+      entry = nextEntry;
     }
     return true;
   }
 
   bool some(bool f(E element)) {
     DoubleLinkedQueueEntry<E> entry = _sentinel._next;
     while (entry !== _sentinel) {
+      DoubleLinkedQueueEntry<E> nextEntry = entry._next;
       if (f(entry._element)) return true;
-      entry = entry._next;
+      entry = nextEntry;
     }
     return false;
   }
 
   Queue<E> filter(bool f(E element)) {
     Queue<E> other = new Queue<E>();
     DoubleLinkedQueueEntry<E> entry = _sentinel._next;
     while (entry !== _sentinel) {
+      DoubleLinkedQueueEntry<E> nextEntry = entry._next;
       if (f(entry._element)) other.addLast(entry._element);
-      entry = entry._next;
+      entry = nextEntry;
     }
     return other;
   }
 
   _DoubleLinkedQueueIterator<E> iterator() {
     return new _DoubleLinkedQueueIterator<E>(_sentinel);
   }
 }
 
 class _DoubleLinkedQueueIterator<E> implements Iterator<E> {
   final _DoubleLinkedQueueEntrySentinel<E> _sentinel;
   DoubleLinkedQueueEntry<E> _currentEntry;
 
   _DoubleLinkedQueueIterator(_DoubleLinkedQueueEntrySentinel this._sentinel) {
     _currentEntry = _sentinel;
   }
 
   bool hasNext() {
     return _currentEntry._next !== _sentinel;
   }
 
   E next() {
     if (!hasNext()) {
       throw const NoMoreElementsException();
     }
     _currentEntry = _currentEntry._next;
     return _currentEntry.element;
   }
 }