Change default format to produce output that can be passed between isolates

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 223 matching lines @@
 
 /**
  * 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 internal collection of object state and [Reference] objects. */
+  List<List> get states;
+
   /**
    * 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.
@@ skipping 17 matching lines @@
   /**
    * The state of objects that have been 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. See [Writer.states].
    */
   List<List> _data;
 
+  /** Return the internal collection of object state and [Reference] objects. */
+  get states => _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;
 
   final Format format;
 
   /**
@@ skipping 169 matching lines @@
 
   /**
    * Given a possible reference [anObject], call either [ifReference] or
    * [ifNotReference], depending if it's a reference or not. This is the
    * primary place that knows about the serialized representation of a
    * reference.
    */
   asReference(anObject, {Function ifReference: doNothing,
       Function ifNotReference : doNothing}) {
     if (anObject is Reference) return ifReference(anObject);
-    if (anObject is Map && anObject["__Ref"] == true) {
+    if (anObject is Map && anObject["__Ref"] != null) {
       var ref =
           new Reference(this, anObject["rule"], anObject["object"]);
       return ifReference(ref);
     } else {
       return ifNotReference(anObject);
     }
   }
 }
 
 /**
@@ skipping 97 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"
-  Map<String, dynamic> toJson() => {
-    "__Ref" : true,
+  Map<String, int> toJson() => {
+    "__Ref" : 0,
     "rule" : ruleNumber,
     "object" : objectNumber
   };
 
   /** Write our information to [list]. Useful in writing to flat formats.*/
   void writeToList(List list) {
     list.add(ruleNumber);
     list.add(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 {
   final Function rulePredicate;
   final target;
 
   DesignatedRuleForObject(this.target, this.rulePredicate);
 
   List possibleRules(List rules) => rules.where(rulePredicate).toList();
 }