Add a MapRule

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.
  */
 // TODO(alanknight): For simple serialization formats this does a lot of work
 // that isn't necessary, e.g. detecting cycles and maintaining references.
 // Consider having an abstract superclass with the basic functionality and
 // simple serialization subclasses where we know there aren't cycles.
-class Writer {
+class Writer implements ReaderOrWriter {
   /**
    * The [serialization] holds onto the rules that define how objects
    * are serialized.
    */
   final Serialization serialization;
 
   /** The [trace] object keeps track of the objects to be visited while finding
    * the full set of objects to be written.*/
   Trace trace;
 
@@ skipping 54 matching lines @@
   /**
    * Given that we have fully populated the list of [states], and more
    * importantly, the list of [references], go through each state and turn
    * anything that requires a [Reference] into one. Since only the rules
    * know the representation they use for state, delegate to them.
    */
   void _flatten() {
     for (var eachRule in rules) {
       _growStates(eachRule);
       var index = eachRule.number;
-      for (var eachState in states[index]) {
-        eachRule.flatten(eachState, this);
+      var statesForThisRule = states[index];
+      for (var i = 0; i < statesForThisRule.length; i++) {
+        var eachState = statesForThisRule[i];
+        var newState = eachRule.flatten(eachState, this);
+        if (newState != null) {
+          statesForThisRule[i] = newState;
+        }
       }
     }
   }
 
   /**
    * As the [trace] processes each object, it will call this method on us.
    * We find the rules for this object, and record the state of the object
    * as determined by each rule.
    */
   void _process(object, Trace trace) {
@@ skipping 86 matching lines @@
   }
 
   /**
    * 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.mappedBy(_referenceFor).toList();
 
   /**
    * Given an object, return a reference for it if one exists. If there's
-   * no reference, return null. 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.
+   * 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) => references[object];
+  _referenceFor(object) {
+    var result = references[object];
+    return (result == null) ? object : result;
+  }
 
   /**
    * Return true if the [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);
 
   /**
    * Return the name we have for this object in the [namedObjects] collection.
    */
   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
+ * type things that will refer to one or the other, depending on which
+ * operation we're doing.
+ */
+abstract class ReaderOrWriter {
+  /** Return the list of serialization rules we are using.*/
+  List<SerializationRule> get rules;
+
+  /**
+   * Return the object, or state, that ref points to, depending on which
+   * we're generating.
+   */
+  resolveReference(Reference ref);
 }
 
 /**
  * The main class responsible for reading. It holds
  * onto the necessary state and to the objects that have been inflated.
  */
-class Reader {
+class Reader implements ReaderOrWriter {
 
   /**
    * The serialization that specifies how we read. Note that in contrast
    * to the Writer, this is not final. This is because we may be created
    * with an empty [Serialization] and then read the rules from the data,
    * if [selfDescribing] is true.
    */
   Serialization serialization;
 
   /**
@@ skipping 144 matching lines @@
     // TODO This seems too complicated.
     return asReference(possibleReference,
         ifReference: (reference) {
           var rule = ruleFor(reference);
           var state = _stateFor(reference);
           inflateOne(rule, reference.objectNumber, state);
           return _objectFor(reference);
         });
   }
 
+  /** Return the object pointed to by [reference]. */
+  resolveReference(reference) => inflateReference(reference);
+
   /**
    * Given [reference], return what we have stored as an object for it. Note
    * that, depending on the current state, this might be null or a Sentinel.
    */
   _objectFor(Reference reference) =>
       objects[reference.ruleNumber][reference.objectNumber];
 
   /** Given [rule], return the storage for its objects. */
   allObjectsForRule(SerializationRule rule) => objects[rule.number];
 
@@ skipping 110 matching lines @@
 }
 
 /**
  * Any pointers to objects that can't be represented directly in the
  * serialization format has to be stored as a reference. A reference encodes
  * the rule number of the rule that saved it in the Serialization that was used
  * for writing, and the object number within that rule.
  */
 class Reference {
   /** The [Reader] or [Writer] that owns this reference. */
-  final parent;
+  final ReaderOrWriter parent;
   /** The position of the rule that controls this reference in [parent]. */
   final int ruleNumber;
   /** The index of the referred-to object in the storage of [parent] */
   final int objectNumber;
 
-  const Reference(this.parent, this.ruleNumber, this.objectNumber);
+  Reference(this.parent, this.ruleNumber, this.objectNumber) {
+    if (ruleNumber == null || objectNumber == null) {
+      throw new SerializationException("Invalid Reference");
+    }
+    if (parent.rules.length < ruleNumber) {
+      throw new SerializationException("Invalid Reference");
+    }
+  }
+
+  /**
+   * Return the thing this reference points to. Assumes that we have a valid
+   * parent and that it is a Reader, as inflating is not meaningful when
+   * writing.
+   */
+  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
    * [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() => {
     "__Ref" : true,
     "rule" : ruleNumber,
     "object" : objectNumber
   };
 
   /** Write our information to [list]. Useful in writing to flat formats.*/
   writeToList(List list) {
     list.add(ruleNumber);
     list.add(objectNumber);
   }
 
-  toString() => "Reference $ruleNumber, $objectNumber";
+  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 target;
 
   DesignatedRuleForObject(this.target, this.rulePredicate);
 
   possibleRules(List rules) => rules.where(rulePredicate).toList();
 }