pkg/serialization updates

pkg/serialization/lib/src/serialization_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): We should have an example and tests for subclassing
 // serialization rule rather than using the hard-coded ClosureToMap rule. And
 // possibly an abstract superclass that's designed to be subclassed that way.
 /**
@@ skipping 89 matching lines @@
    * object's constructor. It is up to the rule what state is considered
    * essential.
    */
   inflateEssential(state, Reader reader);
 
   /**
    * The [object] has already been created. Set any of its non-essential
    * variables from the representation in [state]. Where there are references
    * to other objects they are resolved in the context of [reader].
    */
-  inflateNonEssential(state, object, Reader reader);
+  void inflateNonEssential(state, object, Reader reader);
 
   /**
    * If we have [object] as part of our state, should we represent that
    * directly, or should we make a reference for it. By default, true.
    * This may also delegate to [writer].
    */
   bool shouldUseReferenceFor(object, Writer writer) => true;
 
   /**
    * Return true if the data this rule returns is variable length, so a
@@ skipping 27 matching lines @@
       result.add(each);
       f(each);
     }
     return result;
   }
 
   inflateEssential(List state, Reader r) => new List();
 
   // For a list, we consider all of its state non-essential and add it
   // after creation.
-  inflateNonEssential(List state, List newList, Reader r) {
+  void inflateNonEssential(List state, List newList, Reader r) {
     populateContents(state, newList, r);
   }
 
   void populateContents(List state, List newList, Reader r) {
     for(var each in state) {
       newList.add(r.inflateReference(each));
     }
   }
 
   bool get hasVariableLengthEntries => true;
 }
 
 /**
  * This is a subclass of ListRule where all of the list's contents are
  * considered essential state. This is needed if an object X contains a List L,
  * but it expects L's contents to be fixed when X's constructor is called.
  */
 class ListRuleEssential extends ListRule {
 
   /** Create the new List and also inflate all of its contents. */
   inflateEssential(List state, Reader r) {
     var object = super.inflateEssential(state, r);
     populateContents(state, object, r);
     return object;
   }
 
   /** Does nothing, because all the work has been done in inflateEssential. */
-  inflateNonEssential(state, newList, reader) {}
+  void inflateNonEssential(state, newList, reader) {}
 
   bool get mustBePrimary => true;
 }
 
 /**
  * This rule handles things that implement Map. It will recreate them as
  * whatever the default implemenation of Map is on the target platform. If a
  * map has string keys it will attempt to retain it as a map for JSON formats,
  * otherwise it will store it as a list of references to keys and values.
  */
@@ skipping 33 matching lines @@
         newState.add(writer._referenceFor(value));
       });
       return newState;
     }
   }
 
   inflateEssential(state, Reader r) => new Map();
 
   // For a map, we consider all of its state non-essential and add it
   // after creation.
-  inflateNonEssential(state, Map newMap, Reader r) {
+  void inflateNonEssential(state, Map newMap, Reader r) {
     if (state is List) {
       inflateNonEssentialFromList(state, newMap, r);
     } else {
       inflateNonEssentialFromMap(state, newMap, r);
     }
   }
 
   void inflateNonEssentialFromList(List state, Map newMap, Reader r) {
     var key;
     for (var each in state) {
@@ skipping 18 matching lines @@
 /**
  * This rule handles primitive types, defined as those that we can normally
  * represent directly in the output format. We hard-code that to mean
  * num, String, and bool.
  */
 class PrimitiveRule extends SerializationRule {
   bool appliesTo(object, Writer w) => isPrimitive(object);
   extractState(object, Function f, Writer w) => object;
   flatten(object, Writer writer) {}
   inflateEssential(state, Reader r) => state;
-  inflateNonEssential(object, _, Reader r) {}
+  void inflateNonEssential(object, _, Reader r) {}
 
   bool get storesStateAsPrimitives => true;
 
   /**
    * Indicate whether we should save pointers to this object as references
    * or store the object directly. For primitives this depends on the format,
    * so we delegate to the writer.
    */
   bool shouldUseReferenceFor(object, Writer w) =>
       w.shouldUseReferencesForPrimitives;
@@ skipping 13 matching lines @@
 /**
  * This is a rule where the extraction and creation are hard-coded as
  * closures. The result is expected to be a map indexed by field name.
  */
 class ClosureRule extends CustomRule {
 
   /** The runtimeType of objects that this rule applies to. Used in appliesTo.*/
   final Type type;
 
   /** The function for constructing new objects when reading. */
-  ConstructType construct;
+  final ConstructType construct;
 
   /** The function for returning an object's state as a Map. */
-  GetStateType getStateFunction;
+  final GetStateType getStateFunction;
 
   /** The function for setting an object's state from a Map. */
-  NonEssentialStateType setNonEssentialState;
+  final NonEssentialStateType setNonEssentialState;
 
   /**
    * Create a ClosureToMapRule for the given [type] which gets an object's
    * state by calling [getState], creates a new object by calling [construct]
    * and sets the new object's state by calling [setNonEssentialState].
    */
   ClosureRule(this.type, this.getStateFunction, this.construct,
       this.setNonEssentialState);
 
   bool appliesTo(object, Writer w) => object.runtimeType == type;
@@ skipping 37 matching lines @@
   // proven necessary.
   flatten(state, Writer writer) {
     state[0] = writer._referenceFor(state[0]);
   }
 
   /** Look up the named object and return it. */
   inflateEssential(state, Reader r) =>
       r.objectNamed(r.resolveReference(state.first));
 
   /** Set any non-essential state on the object. For this rule, a no-op. */
-  inflateNonEssential(state, object, Reader r) {}
+  void inflateNonEssential(state, object, Reader r) {}
 
   /** Return the name for this object in the Writer. */
   String nameFor(object, Writer writer) => writer.nameFor(object);
 }
 
 /**
  * This rule handles the special case of Mirrors. It stores the mirror by its
  * qualifiedName and attempts to look it up in both the namedObjects
  * collection, or if it's not found there, by looking it up in the mirror
  * system. When reading, the user is responsible for supplying the appropriate
@@ skipping 101 matching lines @@
   create(state) => new Symbol(state[0]);
   void setState(symbol, state) {}
   int get dataLength => 1;
   bool get hasVariableLengthEntries => false;
 }
 
 /** A hard-coded rule for DateTime. */
 class DateTimeRule extends CustomRule {
   bool appliesTo(instance, _) => instance is DateTime;
   List getState(DateTime date) => [date.millisecondsSinceEpoch, date.isUtc];
-  create(List state) =>
+  DateTime create(List state) =>
       new DateTime.fromMillisecondsSinceEpoch(state[0], isUtc: state[1]);
   void setState(date, state) {}
   // Let the system know we don't have to store a length for these.
   int get dataLength => 2;
   bool get hasVariableLengthEntries => false;
 }
 
 /** Create a lazy list/map that will inflate its items on demand in [r]. */
 _lazy(l, Reader r) {
   if (l is List) return new _LazyList(l, r);
@@ skipping 41 matching lines @@
   void addAll(Map other) => _throw();
 }
 
 /**
  * This provides an implementation of List that wraps a list which may
  * contain references to (potentially) non-inflated objects. If these
  * are accessed it will inflate them. This allows us to pass something that
  * looks like it's just a list of objects to a [CustomRule] without needing
  * to inflate all the references in advance.
  */
-class _LazyList extends IterableBase with ListMixin implements List {
+class _LazyList extends ListBase {
   _LazyList(this._raw, this._reader);
 
   final List _raw;
   final Reader _reader;
 
   operator [](int x) => _reader.inflateReference(_raw[x]);
   int get length => _raw.length;
 
   void set length(int value) => _throw();
 
   void operator []=(int index, value) => _throw();
 
   void _throw() {
     throw new UnsupportedError("Not modifiable");
   }
 }