pkg/serialization types cleanup

pkg/serialization/lib/serialization.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.
 
 /**
  * This provides a general-purpose serialization facility for Dart objects. A
  * [Serialization] is defined in terms of [SerializationRule]s and supports
  * reading and writing to different formats.
  *
  * ## Installing ##
@@ skipping 209 matching lines @@
  * This class defines a particular serialization scheme, in terms of
  * [SerializationRule] instances, and supports reading and writing them.
  * See library comment for examples of usage.
  */
 class Serialization {
 
   /**
    * The serialization is controlled by the list of Serialization rules. These
    * are most commonly added via [addRuleFor].
    */
-  List _rules = [];
-
-  /**
-   * The serialization is controlled by the list of Serialization rules. These
-   * are most commonly added via [addRuleFor].
-   */
-  List get rules => _rules;
+  final List<SerializationRule> rules = new List<SerializationRule>();
 
   /**
    * When reading, we may need to resolve references to existing objects in
    * the system. The right action may not be to create a new instance of
    * something, but rather to find an existing instance and connect to it.
    * For example, if we have are serializing an Email message and it has a
    * link to the owning account, it may not be appropriate to try and serialize
    * the account. Instead we should just connect the de-serialized message
    * object to the account object that already exists there.
    */
@@ skipping 10 matching lines @@
   /**
    * When we write out data using this serialization, should we also write
    * out a description of the rules. This is on by default unless using
    * CustomRule subclasses, in which case it requires additional setup and
    * is off by default.
    */
   bool get selfDescribing {
     // TODO(alanknight): Should this be moved to the format?
     // TODO(alanknight): Allow self-describing in the presence of CustomRule.
     if (_selfDescribing != null) return _selfDescribing;
-    return !_rules.any((x) => x is CustomRule);
+    return !rules.any((x) => x is CustomRule);
   }
 
   /**
    * When we write out data using this serialization, should we also write
    * out a description of the rules. This is on by default unless using
    * CustomRule subclasses, in which case it requires additional setup and
    * is off by default.
    */
-  set selfDescribing(x) => _selfDescribing = x;
+  void set selfDescribing(bool value) => _selfDescribing = value;
 
   /**
    * Creates a new serialization with a default set of rules for primitives
    * and lists.
    */
   Serialization() {
     addDefaultRules();
   }
 
   /**
@@ skipping 56 matching lines @@
     addRule(new SymbolRule());
   }
 
   /**
    * Add a new SerializationRule [rule]. The addRuleFor method will probably
    * handle most simple cases, but for adding an arbitrary rule, including
    * a SerializationRule subclass which you have created, you can use this
    * method.
    */
   void addRule(SerializationRule rule) {
-    rule.number = _rules.length;
-    _rules.add(rule);
+    rule.number = rules.length;
+    rules.add(rule);
   }
 
   /**
    * This writes out an object graph rooted at [object] and returns the result.
    * The [format] parameter determines the form of the result. The default
    * format returns a String in [json] format.
    */
   write(Object object, [Format format]) {
     return newWriter(format).write(object);
   }
@@ skipping 44 matching lines @@
     // light of a more general mechanism for multiple rules per object.
     // TODO(alanknight): Finding which rules apply seems likely to be a
     // bottleneck, particularly with the current reflective implementation.
     // Consider how to improve it. e.g. cache the list of rules by class. But
     // be careful of issues like rules which have arbitrary predicates. Or
     // consider having the arbitrary predicates be secondary to an initial
     // class-based lookup mechanism.
     var target, candidateRules;
     if (object is DesignatedRuleForObject) {
       target = object.target;
-      candidateRules = object.possibleRules(_rules);
+      candidateRules = object.possibleRules(rules);
     } else {
       target = object;
-      candidateRules = _rules;
+      candidateRules = rules;
     }
     Iterable applicable = candidateRules.where(
         (each) => each.appliesTo(target, w));
 
     if (applicable.isEmpty) {
       return [addRuleFor(target)];
     }
 
     if (applicable.length == 1) return applicable;
     var first = applicable.first;
@@ skipping 59 matching lines @@
 }
 
 /**
  * An exception class for errors during serialization.
  */
 class SerializationException implements Exception {
   final String message;
   const SerializationException([this.message]);
   toString() => "SerializationException($message)";
 }