Make input/output formats pluggable, adapt to new libraries

pkg/serialization/lib/src/basic_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): Figure out how to reasonably separate out the things
 // that require reflection without making the API more awkward. Or if that is
 // in fact necessary. Maybe the tree-shaking will just remove it if unused.
 
@@ skipping 212 matching lines @@
    * Extract the value of the field [fieldName] from the object reflected
    * by [mirror].
    */
   // TODO(alanknight): The framework should be resilient if there are fields
   // it expects that are missing, either for the case of de-serializing to a
   // different definition, or for the case that tree-shaking has removed state.
   // TODO(alanknight): This, and other places, rely on synchronous access to
   // mirrors. Should be changed to use a synchronous API once one is available,
   // or to be async, but that would be extremely ugly.
   _value(InstanceMirror mirror, _Field field) => field.valueIn(mirror);
-
-  /**
-   * 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 N fields, which
-   * are references, where a reference is stored in the stream as two integers.
-   * Or, in the special case of null, two nulls.
-   */
-  pullStateFrom(Iterator stream) {
-    stream.moveNext();
-    var dataLength = stream.current;
-    var ruleData = new List();
-    for (var i = 0; i < dataLength; i++) {
-      var subList = new List();
-      ruleData.add(subList);
-      for (var j = 0; j < fields.length; j++) {
-        stream.moveNext();
-        var a = stream.current;
-        stream.moveNext();
-        var b = stream.current;
-        if (!(a is int)) {
-          // This wasn't a reference, so 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;
-  }
 }
 
 /**
  * This represents a field in an object. It is intended to be used as part of
  * a [_FieldList].
  */
 abstract class _Field implements Comparable {
 
   /** The FieldList that contains us. */
   final _FieldList fieldList;
@@ skipping 82 matching lines @@
    * it is used in the constructor, or because it's been designated
    * using [setFieldWith].
    */
   bool get isEssential => super.isEssential || customSetter != null;
 
   /** Set the [value] of our field in the given mirrored [object]. */
   void setValue(InstanceMirror object, value) {
     setter(object, value);
   }
 
-  valueIn(InstanceMirror mirror) {
-    var futureValue = deprecatedFutureValue(mirror.getField(name));
-    return futureValue.reflectee;
-  }
+  valueIn(InstanceMirror mirror) =>
+      deprecatedFutureValue(mirror.getField(name)).reflectee;
 
   /** Return the function to use to set our value. */
   Function get setter =>
       (customSetter != null) ? customSetter : defaultSetter;
 
   /** Return a default setter function. */
   void defaultSetter(InstanceMirror object, value) {
     object.setField(name, reflect(value));
   }
 
@@ skipping 88 matching lines @@
     if (fields == null || fields.isEmpty) return;
     if (allFields.length > _constructorFields.length) {
       throw "You can't specify both excludeFields and regular fields";
     }
     _excludeFields = fields;
   }
 
   int get length => allFields.length;
 
   /** Add all the fields which aren't on the exclude list. */
-  void addAllNotExplicitlyExcluded(List<String> aCollection) {
+  void addAllNotExplicitlyExcluded(Iterable<String> aCollection) {
     if (aCollection == null) return;
     var names = aCollection;
     names = names.where((x) => !_excludeFields.contains(x));
     addAllByName(names);
   }
 
   /** Add all the fields with the given names without any special properties. */
   void addAllByName(Iterable<String> names) {
     for (var each in names) {
       allFields.putIfAbsent(each, () => new _Field(each, this));
@@ skipping 38 matching lines @@
         f(each);
       }
     }
   }
 
   List get constructorFields => _constructorFields;
   List constructorFieldNames() =>
       constructorFields.mappedBy((x) => x.name).toList();
   List constructorFieldIndices() =>
       constructorFields.mappedBy((x) => x.index).toList();
-  List regularFields() =>
-      contents.where((x) => !x.usedInConstructor).toList();
-  List regularFieldNames() =>
-      regularFields().mappedBy((x) => x.name).toList();
+  List regularFields() => contents.where((x) => !x.usedInConstructor).toList();
+  List regularFieldNames() => regularFields().mappedBy((x) => x.name).toList();
   List regularFieldIndices() =>
       regularFields().mappedBy((x) => x.index).toList();
 
-
   /**
    * If we weren't given any non-constructor fields to use, figure out what
    * we think they ought to be, based on the class definition.
    * We find public fields, getters that have corresponding setters, and getters
    * that are listed in the constructor fields.
    */
   void figureOutFields() {
-    List names(Collection<DeclarationMirror> mirrors) =>
-        mirrors.mappedBy((each) => each.simpleName).toList();
+    Iterable names(Iterable<DeclarationMirror> mirrors) =>
+        mirrors.mappedBy((each) => each.simpleName);
 
     if (!_shouldFigureOutFields || !regularFields().isEmpty) return;
     var fields = publicFields(mirror);
     var getters = publicGetters(mirror);
     var gettersWithSetters = getters.where( (each)
-        => mirror.setters["${each.simpleName}="] != null).toList();
+        => mirror.setters["${each.simpleName}="] != null);
     var gettersThatMatchConstructor = getters.where((each)
         => (named(each.simpleName) != null) &&
             (named(each.simpleName).usedInConstructor)).toList();
     addAllNotExplicitlyExcluded(names(fields));
     addAllNotExplicitlyExcluded(names(gettersWithSetters));
     addAllNotExplicitlyExcluded(names(gettersThatMatchConstructor));
   }
 }
 
 /**
@@ skipping 30 matching lines @@
   }
 
   /**
    * Find the field values in [state] and pass them to the constructor.
    * If any of [fieldNumbers] is not an int, then use it as a literal value.
    */
   constructFrom(state, Reader r) {
     // TODO(alanknight): Handle named parameters
     Collection inflated = fieldNumbers.mappedBy(
         (x) => (x is int) ? reflect(r.inflateReference(state[x])) : reflect(x))
-        .toList();
+            .toList();
     var result = type.newInstance(name, inflated);
     return deprecatedFutureValue(result);
   }
 }
 
 /**
  * This wraps a map to make it indexable by integer field numbers. It translates
  * from the index into a field name and then looks it up in the map.
  */
 class _MapWrapper {
   Map<String, dynamic> _map = new Map<String, dynamic>();
   List fieldList;
   _MapWrapper(this.fieldList);
   _MapWrapper.fromMap(this._map, this.fieldList);
 
   operator [](key) => _map[fieldList[key].name];
   operator []=(key, value) { _map[fieldList[key].name] = value; }
   get length => _map.length;
 
   asMap() => _map;
 }