pkg/serialization types cleanup

pkg/serialization/lib/src/reader_writer.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;
 
 /**
  * This writes out the state of the objects to an external format. It holds
  * all of the intermediate state needed. The primary API for it is the
  * [write] method.
@@ skipping 13 matching lines @@
    * the full set of objects to be written.*/
   Trace trace;
 
   /**
    * When we write out objects, should we also write out a description
    * of the rules for the serialization. This defaults to the corresponding
    * value on the Serialization.
    */
   bool selfDescribing;
 
-  Format format = new SimpleMapFormat();
+  final Format format;
 
   /**
    * Objects that cannot be represented in-place in the serialized form need
    * to have references to them stored. The [Reference] objects are computed
    * once and stored here for each object. This provides some space-saving,
    * but also serves to record which objects we have already seen.
    */
   final Map<dynamic, Reference> references =
       new IdentityMap<Object, Reference>();
 
   /**
    * The state of objects that need to be serialized is stored here.
    * Each rule has a number, and rules keep track of the objects that they
    * serialize, in order. So the state of any object can be found by indexing
    * from the rule number and the object number within the rule.
    * The actual representation of the state is determined by the rule. Lists
    * and Maps are common, but it is arbitrary.
    */
   final List<List> states = new List<List>();
 
   /** Return the list of rules we use. */
-  List<SerializationRule> get rules => serialization._rules;
+  List<SerializationRule> get rules => serialization.rules;
 
   /**
    * Creates a new [Writer] that uses the rules from its parent
    * [Serialization]. Serializations do not keep any state
    * related to a particular read/write, so the same one can be used
    * for multiple different Readers/Writers.
    */
-  Writer(this.serialization, [Format newFormat]) {
+  Writer(this.serialization, [Format newFormat]) :
+    format = (newFormat == null) ? const SimpleMapFormat() : newFormat {
     trace = new Trace(this);
     selfDescribing = serialization.selfDescribing;
-    if (newFormat != null) format = newFormat;
   }
 
   /**
    * This is the main API for a [Writer]. It writes the objects and returns
    * the serialized representation, as determined by [format].
    */
   write(anObject) {
     trace.addRoot(anObject);
     trace.traceAll();
     _flatten();
@@ skipping 60 matching lines @@
 
   /**
    * Returns a serialized version of the [SerializationRule]s used to write
    * the data, if [selfDescribing] is true, otherwise returns null.
    */
   serializedRules() {
     if (!selfDescribing) return null;
     var meta = serialization.ruleSerialization();
     var writer = new Writer(meta, format);
     writer.selfDescribing = false;
-    return writer.write(serialization._rules);
+    return writer.write(serialization.rules);
   }
 
   /** Record a [state] entry for a particular rule. */
   void _addStateForRule(eachRule, state) {
     _growStates(eachRule);
     states[eachRule.number].add(state);
   }
 
   /** Find what the object number for the thing we're about to add will be.*/
   int _nextObjectNumberFor(SerializationRule rule) {
@@ skipping 31 matching lines @@
    */
   int _objectNumberFor(object) {
     var reference = references[object];
     return (reference == null) ? -1 : reference.objectNumber;
   }
 
   /**
    * Return a list of [Reference] objects pointing to our roots. This will be
    * stored in the output under "roots" in the default format.
    */
-  _rootReferences() => trace.roots.map(_referenceFor).toList();
+  List _rootReferences() => trace.roots.map(_referenceFor).toList();
 
   /**
    * Given an object, return a reference for it if one exists. If there's
    * no reference, return the object itself. Once we have finished the tracing
    * step, all objects that should have a reference (roughly speaking,
    * non-primitives) can be relied on to have a reference.
    */
   _referenceFor(object) {
     var result = references[object];
     return (result == null) ? object : result;
   }
 
   /**
    * Return true if the [Serialization.namedObjects] collection has a
    * reference to [object].
    */
   // TODO(alanknight): Should the writer also have its own namedObjects
   // collection specific to the particular write, or is that just adding
   // complexity for little value?
-  hasNameFor(object) => serialization._hasNameFor(object);
+  bool hasNameFor(object) => serialization._hasNameFor(object);
 
   /**
    * Return the name we have for this object in the [Serialization.namedObjects]
    * collection.
    */
-  nameFor(object) => serialization._nameFor(object);
+  String nameFor(object) => serialization._nameFor(object);
 
   // For debugging/testing purposes. Find what state a reference points to.
   stateForReference(Reference r) => states[r.ruleNumber][r.objectNumber];
 
   /** Return the state pointed to by [reference]. */
   resolveReference(reference) => stateForReference(reference);
 }
 
 /**
  * An abstract class for Reader and Writer, which primarily exists so we can
@@ skipping 41 matching lines @@
    */
   List<List> _data;
 
   /**
    * The resulting objects, indexed according to the same scheme as
    * _data, where each rule has a number, and rules keep track of the objects
    * that they serialize, in order.
    */
   List<List> objects;
 
-  Format format = new SimpleMapFormat();
+  final Format format;
 
   /**
    * Creates a new [Reader] that uses the rules from its parent
    * [Serialization]. Serializations do not keep any state related to
    * a particular read or write operation, so the same one can be used
    * for multiple different Writers/Readers.
    */
-  Reader(this.serialization, [Format newFormat]) {
+  Reader(this.serialization, [Format newFormat]) :
+    format = (newFormat == null) ? const SimpleMapFormat() : newFormat  {
     selfDescribing = serialization.selfDescribing;
-    if (newFormat != null) format = newFormat;
   }
 
   /**
    * When we read, we may need to look up objects by name in order to link to
    * them. This is particularly true if we have references to classes,
    * functions, mirrors, or other non-portable entities. The map in which we
    * look things up can be provided as an argument to read, but we can also
    * provide a map here, and objects will be looked up in both places.
    */
   Map namedObjects;
@@ skipping 13 matching lines @@
 
   void keyNotFound(key) {
     throw new SerializationException(
         'Cannot find named object to link to: $key');
   }
 
   /**
    * Return the list of rules to be used when writing. These come from the
    * [serialization].
    */
-  List<SerializationRule> get rules => serialization._rules;
+  List<SerializationRule> get rules => serialization.rules;
 
   /**
    * Internal use only, for testing purposes. Set the data for this reader
    * to a List of Lists whose size must match the number of rules.
    */
   // When we set the data, initialize the object storage to a matching size.
   void set data(List<List> newData) {
     _data = newData;
     objects = _data.map((x) => new List(x.length)).toList();
   }
@@ skipping 24 matching lines @@
       rulesWeRead.forEach(serialization.addRule);
     }
   }
 
   /**
    * Inflate all of the objects for [rule]. Does the essential state for all
    * objects first, then the non-essential state. This avoids cycles in
    * non-essential state, because all the objects will have already been
    * created.
    */
-  inflateForRule(rule) {
+  void inflateForRule(rule) {
     var dataForThisRule = _data[rule.number];
     keysAndValues(dataForThisRule).forEach((position, state) {
       inflateOne(rule, position, state);
     });
     keysAndValues(dataForThisRule).forEach((position, state) {
       rule.inflateNonEssential(state, allObjectsForRule(rule)[position], this);
     });
   }
 
   /**
@@ skipping 47 matching lines @@
 
   /** Given [rule], return the storage for its objects. */
   allObjectsForRule(SerializationRule rule) => objects[rule.number];
 
   /** Given [reference], return the the state we have stored for it. */
   _stateFor(Reference reference) =>
       _data[reference.ruleNumber][reference.objectNumber];
 
   /** Given a reference, return the rule it references. */
   SerializationRule ruleFor(Reference reference) =>
-      serialization._rules[reference.ruleNumber];
+      serialization.rules[reference.ruleNumber];
 
   /**
    * Return the primitive rule we are using. This is an ugly mechanism to
    * support the extra information to reconstruct objects in the
    * [SimpleJsonFormat].
    */
   SerializationRule _primitiveRule() {
     for (var each in rules) {
       if (each.runtimeType == PrimitiveRule) {
         return each;
@@ skipping 42 matching lines @@
   // this as a separate class?
   final Writer writer;
 
   /**
    * This class works by doing a breadth-first traversal of the objects,
    * with the traversal order maintained in [queue].
    */
   final Queue queue = new Queue();
 
   /** The root objects from which we will be tracing. */
-  List roots = [];
+  final List roots = [];
 
   Trace(this.writer);
 
   addRoot(object) {
     roots.add(object);
   }
 
   /** A convenience method to add a single root and trace it in one step. */
   trace(object) {
     addRoot(object);
@@ skipping 59 matching lines @@
    */
   inflated() => parent.resolveReference(this);
 
   /**
    * Convert the reference to a map in JSON format. This is specific to the
    * custom JSON format we define, and must be consistent with the
    * [Reader.asReference] method.
    */
   // TODO(alanknight): This is a hack both in defining a toJson specific to a
   // particular representation, and the use of a bogus sentinel "__Ref"
-  toJson() => {
+  Map<String, dynamic> toJson() => {
     "__Ref" : true,
     "rule" : ruleNumber,
     "object" : objectNumber
   };
 
   /** Write our information to [list]. Useful in writing to flat formats.*/
-  writeToList(List list) {
+  void writeToList(List list) {
     list.add(ruleNumber);
     list.add(objectNumber);
   }
 
-  toString() => "Reference($ruleNumber, $objectNumber)";
+  String toString() => "Reference($ruleNumber, $objectNumber)";
 }
 
 /**
  * This is used during tracing to indicate that an object should be processed
  * using a particular rule, rather than the one that might ordinarily be
  * found for it. This normally only makes sense if the object is uniquely
  * referenced, and is a more or less internal collection. See ListRuleEssential
  * for an example. It knows how to return its object and how to filter.
  */
 class DesignatedRuleForObject {
-  Function rulePredicate;
+  final Function rulePredicate;
   final target;
 
   DesignatedRuleForObject(this.target, this.rulePredicate);
 
-  possibleRules(List rules) => rules.where(rulePredicate).toList();
+  List possibleRules(List rules) => rules.where(rulePredicate).toList();
 }