pkg/serialization types cleanup

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();
+
   /**
    * Return true if this format stores primitives in their own area and uses
    * references to them (e.g. [SimpleFlatFormat]) and false if primitives
    * are stored directly (e.g. [SimpleJsonFormat], [SimpleMapFormat]).
    */
   bool get shouldUseReferencesForPrimitives => false;
 
   /**
    * Generate output for [w] and return it. The particular form of the output
    * will depend on the format. The format can assume that [w] has data
@@ skipping 15 matching lines @@
 }
 
 /**
  * A format that stores the data in maps which are converted into a JSON
  * string. Note that the maps aren't nested, and it handles cyclic references
  * by converting object references to [Reference] objects. If you want simple
  * acyclic JSON look at [SimpleJsonFormat].
  */
 class SimpleMapFormat extends Format {
 
+  const SimpleMapFormat();
+
   /**
    * Generate output for this format from [w] and return it as a String which
    * is the [json] representation of a nested Map structure. The top level has
    * 3 fields, "rules" which may hold a definition of the rules used,
    * "data" which holds the serialized data, and "roots", which holds
    * [Reference] objects indicating the root objects. Note that roots are
    * necessary because the data is organized in the same way as the object
    * structure, it's a list of lists holding self-contained maps which only
    * refer to other parts via [Reference] objects.
    * This effectively defines a custom JSON serialization format, although
@@ skipping 38 matching lines @@
    * 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.
    */
-  static final String RULE = "_rule";
-  static final String RULES = "_rules";
-  static final String DATA = "_data";
-  static final String ROOTS = "_root";
+  static const String RULE = "_rule";
+  static const String RULES = "_rules";
+  static const String DATA = "_data";
+  static const String ROOTS = "_root";
 
-  SimpleJsonFormat({this.storeRoundTripInfo : false});
+  const SimpleJsonFormat({this.storeRoundTripInfo : false});
 
   /**
    * Generate output for this format from [w] and return it as
    * the [json] representation of a nested Map structure.
    */
   generateOutput(Writer w) {
     jsonify(w);
     var root = w._rootReferences().first;
     if (root is Reference) root = w.stateForReference(root);
     if (w.selfDescribing && storeRoundTripInfo) {
@@ skipping 113 matching lines @@
  * 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 {
   bool get shouldUseReferencesForPrimitives => true;
 
   /**
    * For each rule we store data to indicate whether it will be reconstructed
    * as a primitive, a list or a map.
    */
-  static final int STORED_AS_LIST = 1;
-  static final int STORED_AS_MAP = 2;
-  static final int STORED_AS_PRIMITIVE = 3;
+  static const int STORED_AS_LIST = 1;
+  static const int STORED_AS_MAP = 2;
+  static const int STORED_AS_PRIMITIVE = 3;
+
+  const SimpleFlatFormat();
 
   /**
    * Generate output for this format from [w]. This will return a List with
    * three entries, corresponding to the "rules", "data", and "roots" from
    * [SimpleMapFormat]. The data is stored as a single List containing
    * primitives.
    */
   List generateOutput(Writer w) {
     var result = new List(3);
     var flatData = [];
@@ skipping 30 matching lines @@
     }
   }
 
   /**
    * 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
    * which case we don't, and assume the [rule] will know how to read the
    * right length when we read it back. We expect everything in the list to be
    * a reference, which is stored as two numbers.
    */
-  writeLists(SerializationRule rule, List<List> entries, List target) {
+  void writeLists(SerializationRule rule, List<List> entries, List target) {
     target.add(STORED_AS_LIST);
     for (var eachEntry in entries) {
       if (rule.hasVariableLengthEntries) {
         target.add(eachEntry.length);
       }
       for (var eachReference in eachEntry) {
         writeReference(eachReference, target);
       }
     }
   }
 
   /**
    * Write [entries], which contains Maps. Either the Maps are variable
    * length, in which case we add a length field, or they are fixed length, in
    * which case we don't, and assume the [rule] will know how to read the
    * 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) {
+  void 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);
       }
       eachEntry.forEach((key, value) {
         writeReference(key, target);
         writeReference(value, target);
       });
     }
   }
 
   /**
    * Write [entries], which contains simple objects which we can put directly
    * into [target].
    */
-  writeObjects(List entries, List target) {
+  void 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.
@@ skipping 105 matching lines @@
    */
   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, Reader r) {
+  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;
   }
 }