Fix String.trim implementation (follow spec).

corelib/src/implementation/queue.dart

Index: corelib/src/implementation/queue.dart
===================================================================
--- corelib/src/implementation/queue.dart	(revision 1518)
+++ corelib/src/implementation/queue.dart	(working copy)
@@ -171,24 +171,27 @@
   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;
   }
@@ -196,8 +199,9 @@
   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;
   }
@@ -206,8 +210,9 @@
     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;
   }