Big merge from experimental to bleeding edge.

pkg/serialization/lib/src/serialization_rule.dart

 // Copyright (c) 2012, 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 serialization;
 
 // TODO(alanknight): We should have an example and tests for subclassing
 // serialization rule rather than using the hard-coded ClosureToMap rule. And
 // possibly an abstract superclass that's designed to be subclassed that way.
 /**
@@ skipping 132 matching lines @@
    * the flat format. Return false if the results are fixed length.
    */
   // TODO(alanknight): This should probably go away with more general formats.
   bool get writeLengthInFlatFormat => false;
 
   /**
    * The inverse of dumpStateInto, this reads the rule's state from an
    * iterator in a flat format.
    */
   pullStateFrom(Iterator stream) {
-    var numberOfEntries = stream.next();
+    stream.moveNext();
+    var numberOfEntries = stream.current;
     var ruleData = new List();
     for (var i = 0; i < numberOfEntries; i++) {
       var subLength = dataLengthIn(stream);
       var subList = [];
       ruleData.add(subList);
       for (var j = 0; j < subLength; j++) {
-        var a = stream.next();
-        var b = stream.next();
-        if (!(a is int)) {
+        stream.moveNext();
+        var a = stream.current;
+        stream.moveNext();
+        var b = stream.current;
+        if (a is! int) {
           // This wasn't a reference, just use the first object as a literal.
           // particularly used for the case of null.
           subList.add(a);
         } else {
           subList.add(new Reference(this, a, b));
         }
       }
     }
     return ruleData;
   }
 
   /**
    * Return the length of the list of data we expect to see on a particular
    * iterator in a flat format. This may have been encoded in the stream if we
-   * are variable length, or it may be constant. Note that this is expressed in
-   *
+   * are variable length, or it may be constant. Returns null if the [Iterator]
+   * is empty.
    */
   dataLengthIn(Iterator stream) =>
-      writeLengthInFlatFormat ? stream.next() : dataLength;
+      writeLengthInFlatFormat ? (stream..moveNext()).current : dataLength;
 
   /**
    * If the data is fixed length, return it here. Unused in the non-flat
    * format, or if the data is variable length.
    */
   int get dataLength => 0;
 }
 
 /**
  * This rule handles things that implement List. It will recreate them as
@@ skipping 32 matching lines @@
    * When reading from a flat format we are given [stream] and need to pull as
    * much data from it as we need. Our format is that we have an integer N
    * indicating the number of objects and then for each object a length M,
    * and then M references, where a reference is stored in the stream as two
    * integers. Or, in the special case of null, two nulls.
    */
   pullStateFrom(Iterator stream) {
     // TODO(alanknight): This is much too close to the basicRule implementation,
     // and I'd refactor them if I didn't think this whole mechanism needed to
     // change soon.
-    var length = stream.next();
+    stream.moveNext();
+    var length = stream.current;
     var ruleData = new List();
     for (var i = 0; i < length; i++) {
-      var subLength = stream.next();
+      stream.moveNext();
+      var subLength = stream.current;
       var subList = new List();
       ruleData.add(subList);
       for (var j = 0; j < subLength; j++) {
-        var a = stream.next();
-        var b = stream.next();
+        stream.moveNext();
+        var a = stream.current;
+        stream.moveNext();
+        var b = stream.current;
         if (!(a is int)) {
           // This wasn't a reference, just use the first object as a literal.
           // particularly used for the case of null.
           subList.add(a);
         } else {
           subList.add(new Reference(this, a, b));
         }
       }
     }
     return ruleData;
@@ skipping 60 matching lines @@
   void dumpStateInto(List ruleData, List target) {
     target.addAll(ruleData);
   }
 
   /**
    * When reading from a flat format we are given [stream] and need to pull as
    * much data from it as we need. Our format is that we have an integer N
    * indicating the number of objects and then N simple objects.
    */
   pullStateFrom(Iterator stream) {
-    var length = stream.next();
+    stream.moveNext();
+    var length = stream.current;
     var ruleData = new List();
     for (var i = 0; i < length; i++) {
-      ruleData.add(stream.next());
+      stream.moveNext();
+      ruleData.add(stream.current);
     }
     return ruleData;
   }
 }
 
 /** Typedef for the object construction closure used in ClosureRule. */
 typedef ConstructType(Map m);
 
 /** Typedef for the state-getting closure used in ClosureToMapRule. */
 typedef Map<String, dynamic> GetStateType(object);
@@ skipping 143 matching lines @@
       setState(object, _lazy(state, r));
 
   // We don't want to have to make the end user tell us how long the list is
   // separately, so write it out for each object, even though they're all
   // expected to be the same length.
   get writeLengthInFlatFormat => true;
 }
 
 /** Create a lazy list/map that will inflate its items on demand in [r]. */
 _lazy(l, Reader r) {
-  if (l is List) return new _LazyList(l, r);
+  if (l is List) return l.mappedBy(r.inflateReference);
   if (l is Map) return new _LazyMap(l, r);
   throw new SerializationException("Invalid type: must be Map or List - $l");
 }
 
 /**
  * This provides an implementation of Map that wraps a list which may
  * contain references to (potentially) non-inflated objects. If these
  * are accessed it will inflate them. This allows us to pass something that
  * looks like it's just a list of objects to a [CustomRule] without needing
  * to inflate all the references in advance.
  */
 class _LazyMap implements Map {
   _LazyMap(this._raw, this._reader);
 
   Map _raw;
   Reader _reader;
 
   // This is the only operation that really matters.
   operator [](x) => _reader.inflateReference(_raw[x]);
 
   int get length => _raw.length;
   bool get isEmpty => _raw.isEmpty;
-  List get keys => _raw.keys;
+  Iterable get keys => _raw.keys;
   bool containsKey(x) => _raw.containsKey(x);
 
   // These operations will work, but may be expensive, and are probably
   // best avoided.
   get _inflated => keysAndValues(_raw).map(_reader.inflateReference);
   bool containsValue(x) => _inflated.containsValue(x);
-  List get values => _inflated.values;
+  Iterable get values => _inflated.values;
   void forEach(f) => _inflated.forEach(f);
 
   // These operations are all invalid
   _throw() => throw new UnsupportedError("Not modifiable");
   operator []=(x, y) => _throw();
   putIfAbsent(x, y) => _throw();
   remove(x) => _throw();
   clear() => _throw();
 }
-
-/**
- * This provides an implementation of List that wraps a list which may
- * contain references to (potentially) non-inflated objects. If these
- * are accessed it will inflate them. This allows us to pass something that
- * looks like it's just a list of objects to a [CustomRule] without needing
- * to inflate all the references in advance.
- */
-class _LazyList implements List {
-  _LazyList(this._raw, this._reader);
-
-  List _raw;
-  Reader _reader;
-
-  // This is the only operation that really matters.
-  operator [](x) => _reader.inflateReference(_raw[x]);
-
-  int get length => _raw.length;
-  bool get isEmpty => _raw.isEmpty;
-  get first => _reader.inflateReference(_raw.first);
-  get last => _reader.inflateReference(_raw.last);
-
-  // These operations will work, but may be expensive, and are probably
-  // best avoided.
-  get _inflated => _raw.map(_reader.inflateReference);
-  map(f) => _inflated.map(f);
-  filter(f) => _inflated.filter(f);
-  bool contains(element) => _inflated.filter(element);
-  forEach(f) => _inflated.forEach(f);
-  reduce(x, f) => _inflated.reduce(x, f);
-  every(f) => _inflated(f);
-  some(f) => _inflated(f);
-  iterator() => _inflated.iterator();
-  indexOf(x, [pos = 0]) => _inflated.indexOf(x);
-  lastIndexOf(x, [pos]) => _inflated.lastIndexOf(x);
-
-  // These operations are all invalid
-  _throw() => throw new UnsupportedError("Not modifiable");
-  operator []=(x, y) => _throw();
-  add(x) => _throw();
-  addLast(x) => _throw();
-  addAll(x) => _throw();
-  sort([f]) => _throw();
-  clear() => _throw();
-  removeAt(x) => _throw();
-  removeLast() => _throw();
-  getRange(x, y) => _throw();
-  setRange(x, y, z, [a]) => _throw();
-  removeRange(x, y) => _throw();
-  insertRange(x, y, [z]) => _throw();
-  void set length(x) => _throw();
-}