pkg/serialization: add format param to Serialization.read method

pkg/serialization/lib/src/basic_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): Figure out how to reasonably separate out the things
 // that require reflection without making the API more awkward. Or if that is
 // in fact necessary. Maybe the tree-shaking will just remove it if unused.
 
@@ skipping 424 matching lines @@
    * All of our fields, indexed by name. Note that the names are
    * typically Symbols, but can also be arbitrary constants.
    */
   Map<dynamic, _Field> allFields = new Map<dynamic, _Field>();
 
   /**
    * The fields which are used in the constructor. The fields themselves also
    * know if they are constructor fields or not, but we need to keep this
    * information here because the order matters.
    */
-  List _constructorFields = const [];
+  final List<_Field> _constructorFields = <_Field>[];
 
   /** The list of fields to exclude if we are computing the list ourselves. */
-  List<Symbol> _excludedFieldNames = const [];
+  final List<Symbol> _excludedFieldNames = <Symbol>[];
 
   /** The mirror we will use to compute the fields. */
   final ClassMirror mirror;
 
   /** Cached, sorted list of fields. */
   List<_Field> _contents;
 
   /** Should we compute the fields or just use whatever we were given. */
   bool _shouldFigureOutFields = true;
 
   _FieldList(this.mirror);
 
   /** Look up a field by [name]. */
   _Field named(name) => allFields[name];
 
   /** Set the fields to be used in the constructor. */
   set constructorFields(List fieldNames) {
     if (fieldNames == null || fieldNames.isEmpty) return;
-    _constructorFields = [];
+    _constructorFields.clear();
     for (var each in fieldNames) {
       var symbol = _asSymbol(each);
       var name = _Field._isReallyAField(symbol, this) ? symbol : each;
       var field = new _Field(name, this)..usedInConstructor = true;
       allFields[name] = field;
       _constructorFields.add(field);
     }
     invalidate();
   }
 
   /** Set the fields that aren't used in the constructor. */
-  set regular(List<String> fields) {
-    if (fields == null) return;
+  void set regular(List<String> fields) {
+    if (fields == null) {

[Alan Knight, 2013/06/26 19:26:29]

As above for a guard clause.

+      return;
+    }
     _shouldFigureOutFields = false;
     addAllByName(fields);
   }
 
   /** Set the fields to be excluded. This is mutually exclusive with setting
    * the regular fields.
    */
-  set exclude(List<String> fields) {
+  void set exclude(List<String> fields) {
     // TODO(alanknight): This isn't well tested.
-    if (fields == null || fields.isEmpty) return;
+    if (fields == null || fields.isEmpty) {
+      return;
+    }
     if (allFields.length > _constructorFields.length) {
       throw "You can't specify both excludeFields and regular fields";
     }
-    _excludedFieldNames = fields.map((x) => new Symbol(x)).toList();
+    _excludedFieldNames.clear();
+    _excludedFieldNames.addAll(fields.map((x) => new Symbol(x)));
   }
 
   int get length => allFields.length;
 
   /** Add all the fields which aren't on the exclude list. */
   void addAllNotExplicitlyExcluded(Iterable<String> aCollection) {
-    if (aCollection == null) return;
-    var names = aCollection;
-    names = names.where((x) => !_excludedFieldNames.contains(x));
+    if (aCollection == null) {
+      return;
+    }
+    var names = aCollection.where((x) => !_excludedFieldNames.contains(x));
     addAllByName(names);
   }
 
   /** Add all the fields with the given names without any special properties. */
   void addAllByName(Iterable<String> names) {
     for (var each in names) {
       var symbol = _asSymbol(each);
       var field = new _Field(symbol, this);
       allFields.putIfAbsent(symbol, () => new _Field(symbol, this));
     }
@@ skipping 159 matching lines @@
   if (value is String) {
     try {
       return new Symbol(value);
     } on ArgumentError {
       return null;
     };
   } else {
     return null;
   }
 }