pkg/serialization: add format param to Serialization.read method

pkg/serialization/lib/src/format.dart

 part of serialization;
 
 /**
  * An abstract class for serialization formats. Subclasses define how data
  * is read or written to a particular output mechanism.
  */
 abstract class Format {
 
   const Format();
 
@@ skipping 97 matching lines @@
     result["roots"] = result["roots"].map(
         (x) => x is Reference ? referenceToMap(x) : x).toList();
     return result;
   }
 
   /**
    * Convert the data generated by the rules to have maps with the fields
    * of [Reference] objects instead of the [Reference] so that the structure
    * can be serialized between isolates and json easily.
    */
-  forAllStates(ReaderOrWriter w, bool predicate(value),
+  void forAllStates(ReaderOrWriter w, bool predicate(value),
                void transform(value)) {
     for (var eachRule in w.rules) {
       var ruleData = w.states[eachRule.number];
       for (var data in ruleData) {
         keysAndValues(data).forEach((key, value) {
           if (predicate(value)) {
             data[key] = transform(value);
           }
         });
       }
@@ skipping 78 matching lines @@
           ..[DATA] = root;
     }
     return root;
   }
 
   /**
    * Convert the data generated by the rules to have nested maps instead
    * of Reference objects and to add rule numbers if [storeRoundTripInfo]
    * is true.
    */
-  jsonify(Writer w) {
+  void jsonify(Writer w) {
     for (var eachRule in w.rules) {
       var ruleData = w.states[eachRule.number];
       jsonifyForRule(ruleData, w, eachRule);
     }
   }
 
   /**
    * For a particular [rule] modify the [ruleData] to conform to this format.
    */
-  jsonifyForRule(List ruleData, Writer w, SerializationRule rule) {
+  void jsonifyForRule(List ruleData, Writer w, SerializationRule rule) {
     for (var i = 0; i < ruleData.length; i++) {
       var each = ruleData[i];
       if (each is List) {
         jsonifyEntry(each, w);
         if (storeRoundTripInfo) ruleData[i].add(rule.number);
       } else if (each is Map) {
         jsonifyEntry(each, w);
         if (storeRoundTripInfo) each[RULE] = rule.number;
       }
     }
   }
 
   /**
    * For one particular entry, which is either a Map or a List, update it
    * to turn References into a nested List/Map.
    */
-  jsonifyEntry(map, Writer w) {
+  void jsonifyEntry(map, Writer w) {
     // Note, if this is a Map, and the key might be a reference, we need to
     // bend over backwards to avoid concurrent modifications. Non-string keys
     // won't actually work if we try to write this to json, but might happen
     // if e.g. sending between isolates.
     var updates = new Map();
     keysAndValues(map).forEach((key, value) {
       if (value is Reference) updates[key] = w.stateForReference(value);
     });
     updates.forEach((k, v) => map[k] = v);
   }
@@ skipping 234 matching lines @@
       return [];
     } else {
       throw new SerializationException("Invalid data in serialization");
     }
   }
 
   /**
    * Read data for [rule] from [input] with [length] number of entries,
    * creating lists from the results.
    */
-  readLists(Iterator input, SerializationRule rule, int length, Reader r) {
+  List readLists(Iterator input, SerializationRule rule, int length, Reader r) {
     var ruleData = [];
     for (var i = 0; i < length; i++) {
       var subLength =
           rule.hasVariableLengthEntries ? _next(input) : rule.dataLength;
       var subList = [];
       ruleData.add(subList);
       for (var j = 0; j < subLength; j++) {
         subList.add(nextReferenceFrom(input, r));
       }
     }
     return ruleData;
   }
 
   /**
    * Read data for [rule] from [input] with [length] number of entries,
    * creating maps from the results.
    */
-  readMaps(Iterator input, SerializationRule rule, int length, Reader r) {
+  List readMaps(Iterator input, SerializationRule rule, int length, Reader r) {
     var ruleData = [];
     for (var i = 0; i < length; i++) {
       var subLength =
           rule.hasVariableLengthEntries ? _next(input) : rule.dataLength;
       var map = new Map();
       ruleData.add(map);
       for (var j = 0; j < subLength; j++) {
         var key = nextReferenceFrom(input, r);
         var value = nextReferenceFrom(input, r);
         map[key] = value;
       }
     }
     return ruleData;
   }
 
   /**
    * Read data for [rule] from [input] with [length] number of entries,
    * treating the data as primitives that can be returned directly.
    */
-  readPrimitives(Iterator input, SerializationRule rule, int length) {
+  List readPrimitives(Iterator input, SerializationRule rule, int length) {
     var ruleData = [];
     for (var i = 0; i < length; i++) {
       ruleData.add(_next(input));
     }
     return ruleData;
   }
 
   /** Read the next Reference from the input. */
   Reference nextReferenceFrom(Iterator input, Reader r) {
     var a = _next(input);
     var b = _next(input);
     if (a == null) {
       return null;
     } else {
       return new Reference(r, a, b);
     }
   }
 
   /** Return the next element from the input. */
   _next(Iterator input) {
     input.moveNext();
     return input.current;
   }
 }