Add a MapRule

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 119 matching lines @@
     useMaps = false;
   }
 
   /** Create either a list or a map to hold the object's state, depending
    * on the [useMaps] variable. If using a Map, we wrap it in order to keep
    * the protocol compatible. See [configureForLists]/[configureForMaps].
    */
    createStateHolder() =>
      useMaps ? new _MapWrapper(fields.contents) : new List(fields.length);
 
-  /** Wrap the state if it's passed in as a map. */
-  makeIndexableByNumber(state) =>
-      (state is Map) ? new _MapWrapper.fromMap(state, fields.contents) : state;
+  /**
+   * Wrap the state if it's passed in as a map, and if the keys are references,
+   * resolve them to the strings we expect. We leave the previous keys in there
+   * as well, as they shouldn't be harmful, and it costs more to remove them.
+   */
+  makeIndexableByNumber(state) {
+    if (!(state is Map)) return state;
+    // TODO(alanknight): This is quite inefficient, and we do it twice per
+    // instance. If the keys are references, we need to turn them into strings
+    // before we can look at indexing them by field position. It's also eager,
+    // but we know our keys are always primitives, so we don't have to worry
+    // about their instances not having been created yet.
+    for (var each in state.keys) {
+      if (each is Reference) {
+        var inflated = each.inflated();
+        state[inflated] = state[each];
+      }
+    }
+    return new _MapWrapper.fromMap(state, fields.contents);
+  }
 
   /**
    * Extract the state from [object] using an instanceMirror and the field
    * names in [fields]. Call the function [callback] on each value.
    */
   extractState(object, Function callback) {
     var result = createStateHolder();
     var mirror = reflect(object);
 
     keysAndValues(fields).forEach(
         (index, field) {
           var value = _value(mirror, field);
+          callback(field.name);
           callback(checkForEssentialLists(index, value));
           result[index] = value;
         });
     return _unwrap(result);
   }
 
+  flatten(state, Writer writer) {
+    if (state is List) {
+      keysAndValues(state).forEach((index, value) {
+        state[index] = writer._referenceFor(value);
+      });
+    } else {
+      var newState = new Map();
+      keysAndValues(state).forEach((key, value) {
+        newState[writer._referenceFor(key)] = writer._referenceFor(value);
+      });
+      return newState;
+    }
+  }
+
   /**
    * If the value is a List, and the field is a constructor field or
    * otherwise specially designated, we wrap it in something that indicates
    * a restriction on the rules that can be used. Which in this case amounts
    * to designating the rule, since we so far only have one rule per object.
    */
   checkForEssentialLists(index, value) {
     if (value is List && fields.contents[index].isEssential) {
       return new DesignatedRuleForObject(value,
           (SerializationRule rule) => rule is ListRuleEssential);
@@ skipping 41 matching lines @@
   void _findFields(List constructorFields, List regularFields,
       List excludeFields) {
     fields = new _FieldList(type);
     fields.constructorFields = constructorFields;
     fields.regular = regularFields;
     // TODO(alanknight): The order of this matters. It shouldn't.
     fields.exclude = excludeFields;
     fields.figureOutFields();
   }
 
+  bool get hasVariableLengthEntries => false;
+
+  int get dataLength => fields.length;
+
   /**
-   * Extract the value of the field [fieldName] from the object reflected
+   * Extract the value of [field] from the object reflected
    * by [mirror].
    */
   // TODO(alanknight): The framework should be resilient if there are fields
   // it expects that are missing, either for the case of de-serializing to a
   // different definition, or for the case that tree-shaking has removed state.
   // TODO(alanknight): This, and other places, rely on synchronous access to
   // mirrors. Should be changed to use a synchronous API once one is available,
   // or to be async, but that would be extremely ugly.
   _value(InstanceMirror mirror, _Field field) => field.valueIn(mirror);
 }
@@ skipping 273 matching lines @@
       regularFields().mappedBy((x) => x.index).toList();
 
   /**
    * If we weren't given any non-constructor fields to use, figure out what
    * we think they ought to be, based on the class definition.
    * We find public fields, getters that have corresponding setters, and getters
    * that are listed in the constructor fields.
    */
   void figureOutFields() {
     Iterable names(Iterable<DeclarationMirror> mirrors) =>
-        mirrors.mappedBy((each) => each.simpleName);
+        mirrors.mappedBy((each) => each.simpleName).toList();
 
     if (!_shouldFigureOutFields || !regularFields().isEmpty) return;
     var fields = publicFields(mirror);
     var getters = publicGetters(mirror);
     var gettersWithSetters = getters.where( (each)
         => mirror.setters["${each.simpleName}="] != null);
     var gettersThatMatchConstructor = getters.where((each)
         => (named(each.simpleName) != null) &&
             (named(each.simpleName).usedInConstructor)).toList();
     addAllNotExplicitlyExcluded(names(fields));
     addAllNotExplicitlyExcluded(names(gettersWithSetters));
     addAllNotExplicitlyExcluded(names(gettersThatMatchConstructor));
   }
+
+  toString() => "FieldList($contents)";
 }
 
 /**
  *  Provide a typedef for the setWith argument to setFieldWith. It would
  * be nice if we could put this closer to the definition.
  */
 typedef SetWithFunction(InstanceMirror m, object);
 
 /**
  * This represents a constructor that is to be used when re-creating a
@@ skipping 22 matching lines @@
     if (fieldNumbers == null) fieldNumbers = const [];
   }
 
   /**
    * Find the field values in [state] and pass them to the constructor.
    * If any of [fieldNumbers] is not an int, then use it as a literal value.
    */
   constructFrom(state, Reader r) {
     // TODO(alanknight): Handle named parameters
     Collection inflated = fieldNumbers.mappedBy(
-        (x) => (x is int) ? reflect(r.inflateReference(state[x])) : reflect(x))
-            .toList();
-    var result = type.newInstance(name, inflated);
+        (x) => (x is int) ? reflect(r.inflateReference(state[x])) : reflect(x));
+    var result = type.newInstance(name, inflated.toList());
     return deprecatedFutureValue(result);
   }
 }
 
 /**
  * This wraps a map to make it indexable by integer field numbers. It translates
  * from the index into a field name and then looks it up in the map.
  */
 class _MapWrapper {
-  Map<String, dynamic> _map = new Map<String, dynamic>();
+  final _map;
   List fieldList;
-  _MapWrapper(this.fieldList);
+  _MapWrapper(this.fieldList) : _map = new Map();
   _MapWrapper.fromMap(this._map, this.fieldList);
 
   operator [](key) => _map[fieldList[key].name];
+
   operator []=(key, value) { _map[fieldList[key].name] = value; }
   get length => _map.length;
 
   asMap() => _map;
 }