Add a MapRule

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 {
   /**
    * Return true if this format stores primitives in their own area and uses
    * references to them (e.g. [SimpleFlatFormat]) and false if primitives
@@ skipping 77 matching lines @@
 class SimpleJsonFormat extends Format {
 
   /**
    * Indicate if we should store rule numbers with map/list data so that we
    * will know how to reconstruct it with a read operation. If we don't, this
    * will be more compliant with things that expect known format JSON as input,
    * but we won't be able to read back the objects.
    */
   final bool storeRoundTripInfo;
 
+  /**
+   * If we store the rule numbers, what key should we use to store them.
+   */
+  String ruleIdentifier = "__rule";
+
   SimpleJsonFormat({this.storeRoundTripInfo : false});
 
   /**
    * Generate output for this format from [w] and return it as a String which
    * is the [json] representation of a nested Map structure.
    */
   String generateOutput(Writer w) {
     jsonify(w);
     return json.stringify(w.stateForReference(w._rootReferences().first));
   }
@@ skipping 14 matching lines @@
    * For a particular [rule] modify the [ruleData] to conform to this format.
    */
   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;
+        if (storeRoundTripInfo) each[ruleIdentifier] = 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) {
     keysAndValues(map).forEach((key, value) {
       if (value is Reference) map[key] = w.stateForReference(value);
     });
   }
 
   /**
    * Read a [json] encoded string representing serialized data in this format
    * and return the Map representation that the reader expects, with top-level
    * entries for "rules", "data", and "roots". Nested lists/maps will be
    * converted into Reference objects. Note that if the data was not written
    * with [storeRoundTripInfo] true this will fail.
    */
   Map<String, dynamic> read(String input, Reader r) {
     var data = json.parse(input);
     var result = {};
     result["rules"] = null;
     var ruleData =
         new List(r.serialization.rules.length).mappedBy((x) => []).toList();
-    var rootRule = data["__rule"];
     var top = recursivelyFixUp(data, r, ruleData);
     result["data"] = ruleData;
     result["roots"] = [top];
     return result;
   }
 
   /**
    * Convert nested references in [data] into [Reference] objects.
    */
   recursivelyFixUp(data, Reader r, List result) {
     if (isPrimitive(data)) {
       result[r._primitiveRule().number].add(data);
       return data;
     }
-    var ruleNumber =
-        (data is List) ? data.removeLast() : data.remove("__rule");
+    var ruleNumber;
+    if (data is List) {
+      ruleNumber = data.removeLast();
+    } else if (data is Map) {
+      ruleNumber = data.remove(ruleIdentifier);
+    } else {
+      throw new SerializationException("Invalid data format");
+    }
     var newData = values(data).mappedBy(
         (x) => recursivelyFixUp(x, r, result));
+    // TODO(alanknight): Ugh. Get rid of this if we can resolve bug 7982/7940.
+    if (newData is MappedList) {
+      newData = newData.toList();
+    }
     result[ruleNumber].add(newData);
-    return new Reference(this, ruleNumber, result[ruleNumber].length - 1);
+    return new Reference(r, ruleNumber, result[ruleNumber].length - 1);
   }
 }
 
 /**
  * Writes to a simple mostly-flat format. Details are subject to change.
  * Right now this produces a List containing null, num, and String. This is
  * more space-efficient than the map formats, but much less human-readable.
  * Simple usage is to turn this into JSON for transmission.
  */
 class SimpleFlatFormat extends Format {
@@ skipping 27 matching lines @@
     w._rootReferences().forEach((x) => x.writeToList(result[2]));
     return result;
   }
 
   /**
    * Writes the data from [rule] into the [target] list.
    */
   void writeStateInto(SerializationRule rule, List ruleData, List target) {
     if (!ruleData.isEmpty) {
       var sample = ruleData.first;
-      if (sample is List) {
+      if (rule.storesStateAsLists || sample is List) {
         writeLists(rule, ruleData, target);
-      } else if (sample is Map) {
+      } else if (rule.storesStateAsMaps || sample is Map) {
         writeMaps(rule, ruleData, target);
+      } else if (rule.storesStateAsPrimitives || isPrimitive(sample)) {
+        writeObjects(ruleData, target);
       } else {
-        writeObjects(ruleData, target);
+        throw new SerializationException("Invalid data format");
       }
     } else {
       // If there is no data, write a zero for the length.
       target.add(0);
     }
   }
 
   /**
    * Write [entries], which contains Lists. Either the lists are variable
    * length, in which case we add a length field, or they are fixed length, in
@@ skipping 20 matching lines @@
    * right length when we read it back. Then we write alternating keys and
    * values. We expect the values to be references, which we store as
    * two numbers.
    */
   writeMaps(SerializationRule rule, List<Map> entries, List target) {
     target.add(STORED_AS_MAP);
     for (var eachEntry in entries) {
       if (rule.hasVariableLengthEntries) {
         target.add(eachEntry.length);
       }
-      // We take advantage of this being only a semi-flat format, and expecting
-      // that the keys here are field names, i.e. strings. So we write
-      // the keys as literals and the values as references. This duplicates the
-      // keys, so is quite inefficient. But generating maps rather than lists is
-      // not very efficient in the first place.
       eachEntry.forEach((key, value) {
-        target.add(key);
+        writeReference(key, target);
         writeReference(value, target);
       });
     }
   }
 
   /**
    * Write [entries], which contains simple objects which we can put directly
    * into [target].
    */
   writeObjects(List entries, List target) {
     target.add(STORED_AS_PRIMITIVE);
+    for (var each in entries) {
+      if (!isPrimitive(each)) throw new SerializationException("Invalid data");
+    }
     target.addAll(entries);
   }
 
   /**
    * Write [eachRef] to [target]. It will be written as two ints. If [eachRef]
    * is null it will be written as two nulls.
    */
   void writeReference(Reference eachRef, List target) {
     // TODO(alanknight): Writing nulls is problematic in a real flat format.
     if (eachRef == null) {
       target..add(null)..add(null);
     } else {
       eachRef.writeToList(target);
     }
   }
 
   /**
    * Read the data from [rawInput] in the context of [r] and return it as a
    * Map with entries for "roots", "data" and "rules", which the reader knows
    * how to interpret. We expect [rawInput] to have been generated from this
    * format.
    */
   Map<String, dynamic> read(List rawInput, Reader r) {
+    // TODO(alanknight): It's annoying to have to pass the reader around so
+    // much, consider having the format be specific to a particular
+    // serialization operation along with the reader and having it as a field.
     var input = {};
     input["rules"] = rawInput[0];
     r.readRules(input["rules"]);
 
     var flatData = rawInput[1];
     var stream = flatData.iterator;
     var tempData = new List(r.rules.length);
     for (var eachRule in r.rules) {
-       tempData[eachRule.number] = readRuleDataFrom(stream, eachRule);
+       tempData[eachRule.number] = readRuleDataFrom(stream, eachRule, r);
     }
     input["data"] = tempData;
 
     var roots = [];
     var rootsAsInts = rawInput[2].iterator;
     do {
-      roots.add(nextReferenceFrom(rootsAsInts));
+      roots.add(nextReferenceFrom(rootsAsInts, r));
     } while (rootsAsInts.current != null);
 
     input["roots"] = roots;
     return input;
   }
 
   /**
    * Read the data for [rule] from [input] and return it.
    */
-  readRuleDataFrom(Iterator input, SerializationRule rule) {
+  readRuleDataFrom(Iterator input, SerializationRule rule, Reader r) {
     var numberOfEntries = _next(input);
     var entryType = _next(input);
     if (entryType == STORED_AS_LIST) {
-      return readLists(input, rule, numberOfEntries);
+      return readLists(input, rule, numberOfEntries, r);
     }
     if (entryType == STORED_AS_MAP) {
-      return readMaps(input, rule, numberOfEntries);
+      return readMaps(input, rule, numberOfEntries, r);
     }
     if (entryType == STORED_AS_PRIMITIVE) {
       return readPrimitives(input, rule, numberOfEntries);
     }
     if (numberOfEntries == 0) {
       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) {
+  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));
+        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) {
+  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 = {};
+      var map = new Map();
       ruleData.add(map);
       for (var j = 0; j < subLength; j++) {
-        map[_next(input)] = nextReferenceFrom(input);
+        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) {
     var ruleData = [];
     for (var i = 0; i < length; i++) {
       ruleData.add(_next(input));
     }
     return ruleData;
   }
 
   /** Read the next Reference from the input. */
-  nextReferenceFrom(Iterator input) {
+  nextReferenceFrom(Iterator input, Reader r) {
     var a = _next(input);
     var b = _next(input);
     if (a == null) {
       return null;
     } else {
-      return new Reference(this, a, b);
+      return new Reference(r, a, b);
     }
   }
 
   /** Return the next element from the input. */
   _next(Iterator input) {
     input.moveNext();
     return input.current;
   }
 }