Add an option to JsonSerializableGenerator to opt-in to wrappers

Author: kevmoo

json_annotation/CHANGELOG.md

@@ -1,5 +1,10 @@
 ## 0.2.1
 
+* Added a helper class – `$JsonMapWrapper` – and helper functions – `$wrapMap`, 
+  `$wrapMapHandleNull`, `$wrapList`, and `$wrapListHandleNull` – to support
+  the `useWrappers` option added to `JsonSerializableGenerator` in `v0.3.0` of
+  `package:json_serializable`.
+
 * `JsonSerializable` class annotation
   * Added `nullable` field.
   * Fixed doc comment.

json_annotation/lib/src/json_serializable.dart

@@ -2,6 +2,8 @@
 // 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.
 
+import 'dart:collection';
+
 class JsonSerializable {
   // TODO(kevmoo): document these fields
   final bool createFactory;
@@ -68,3 +70,55 @@ class JsonKey {
   /// Only required when the default behavior is not desired.
   const JsonKey({this.name, this.nullable, this.includeIfNull});
 }
+
+// TODO(kevmoo): Add documentation
+abstract class $JsonMapWrapper extends UnmodifiableMapBase<String, dynamic> {}
+
+Map<String, dynamic> $wrapMap<K, V>(
+        Map<K, V> source, dynamic converter(V key)) =>
+    new _MappingMap(source, converter);
+
+Map<String, dynamic> $wrapMapHandleNull<K, V>(
+        Map<K, V> source, dynamic converter(V key)) =>
+    source == null ? null : new _MappingMap(source, converter);
+
+List<dynamic> $wrapList<T>(List<T> source, dynamic converter(T key)) =>
+    new _MappingList(source, converter);
+
+List<dynamic> $wrapListHandleNull<T>(
+        List<T> source, dynamic converter(T key)) =>
+    source == null ? null : new _MappingList(source, converter);
+
+typedef dynamic _Convert<S>(S value);
+
+class _MappingList<S> extends ListBase<dynamic> {
+  final List<S> _source;
+  final _Convert<S> _converter;
+
+  _MappingList(this._source, this._converter);
+
+  @override
+  dynamic operator [](int index) => _converter(_source[index]);
+
+  @override
+  operator []=(int index, dynamic value) => throw new UnsupportedError('');
+
+  @override
+  int get length => _source.length;
+
+  @override
+  set length(int value) => throw new UnsupportedError('');
+}
+
+class _MappingMap<K, V> extends UnmodifiableMapBase<String, dynamic> {
+  final Map<K, V> _source;
+  final _Convert<V> _converter;
+
+  _MappingMap(this._source, this._converter);
+
+  @override
+  Iterable<String> get keys => _source.keys.map((k) => k as String);
+
+  @override
+  dynamic operator [](Object key) => _converter(_source[key]);
+}

json_serializable/CHANGELOG.md

@@ -1,4 +1,13 @@
-## 0.2.5
+## 0.3.0
+
+* **BREAKING** The arguments to `TypeHelper` `serialize` and `deserialize` have
+  changed.
+  * `SerializeContext` and `DeserializeContext` (new classes) are now passed 
+    instead of the `TypeHelperGenerator` typedef (which has been deleted).
+
+* `JsonSerializableGenerator` now supports an optional `useWrappers` argument
+  when generates and uses wrapper classes to (hopefully) improve the speed and
+  memory usage of serialization – at the cost of more code. 
 
 * Throw an exception if a duplicate JSON key is detected.
 

json_serializable/lib/src/json_serializable_generator.dart

@@ -36,20 +36,26 @@ class JsonSerializableGenerator
 
   final List<TypeHelper> _typeHelpers;
 
+  final bool useWrappers;
+
   /// Creates an instance of [JsonSerializableGenerator].
   ///
   /// If [typeHelpers] is not provided, two built-in helpers are used:
   /// [JsonHelper] and [DateTimeHelper].
-  const JsonSerializableGenerator({List<TypeHelper> typeHelpers})
-      : this._typeHelpers = typeHelpers ?? _defaultHelpers;
+  const JsonSerializableGenerator(
+      {List<TypeHelper> typeHelpers, bool useWrappers: false})
+      : this.useWrappers = useWrappers ?? false,
+        this._typeHelpers = typeHelpers ?? _defaultHelpers;
 
   /// Creates an instance of [JsonSerializableGenerator].
   ///
   /// [typeHelpers] provides a set of [TypeHelper] that will be used along with
   /// the built-in helpers: [JsonHelper] and [DateTimeHelper].
   factory JsonSerializableGenerator.withDefaultHelpers(
-          Iterable<TypeHelper> typeHelpers) =>
+          Iterable<TypeHelper> typeHelpers,
+          {bool useWrappers: false}) =>
       new JsonSerializableGenerator(
+          useWrappers: useWrappers,
           typeHelpers: new List.unmodifiable(
               [typeHelpers, _defaultHelpers].expand((e) => e)));
 
@@ -125,6 +131,7 @@ class JsonSerializableGenerator
 
     if (classAnnotation.createToJson) {
       var mixClassName = '${prefix}SerializerMixin';
+      var helpClassName = '${prefix}JsonMapWrapper';
 
       //
       // Generate the mixin class
@@ -138,23 +145,95 @@ class JsonSerializableGenerator
         buffer.writeln('  ${field.type} get ${field.name};');
       }
 
-      buffer.writeln('  Map<String, dynamic> toJson() ');
-      if (fieldsList
-          .every((e) => _includeIfNull(e, classAnnotation.includeIfNull))) {
-        // write simple `toJson` method that includes all keys...
-        _writeToJsonSimple(buffer, fields.values, classAnnotation.nullable);
+      buffer.write('  Map<String, dynamic> toJson() ');
+
+      if (useWrappers) {
+        buffer.writeln('=> new $helpClassName(this);');
       } else {
-        // At least one field should be excluded if null
-        _writeToJsonWithNullChecks(buffer, fields.values, classAnnotation);
+        if (fieldsList
+            .every((e) => _includeIfNull(e, classAnnotation.includeIfNull))) {
+          // write simple `toJson` method that includes all keys...
+          _writeToJsonSimple(buffer, fields.values, classAnnotation.nullable);
+        } else {
+          // At least one field should be excluded if null
+          _writeToJsonWithNullChecks(buffer, fields.values, classAnnotation);
+        }
       }
 
       // end of the mixin class
       buffer.writeln('}');
+
+      if (useWrappers) {
+        _writeWrapper(
+            buffer, helpClassName, mixClassName, classAnnotation, fields);
+      }
     }
 
     return buffer.toString();
   }
 
+  void _writeWrapper(
+      StringBuffer buffer,
+      String helpClassName,
+      String mixClassName,
+      JsonSerializable classAnnotation,
+      Map<String, FieldElement> fields) {
+    buffer.writeln();
+    // TODO(kevmoo): write JsonMapWrapper if annotation lib is prefix-imported
+    buffer.writeln('''class $helpClassName extends \$JsonMapWrapper {
+      final $mixClassName _v;
+      $helpClassName(this._v);
+    ''');
+
+    if (fields.values
+        .every((e) => _includeIfNull(e, classAnnotation.includeIfNull))) {
+      // TODO(kevmoo): consider just doing one code path – if it's fast
+      //               enough
+      var jsonKeys = fields.values.map(_safeNameAccess).join(', ');
+
+      // TODO(kevmoo): maybe put this in a static field instead?
+      //               const lists have unfortunate overhead
+      buffer.writeln('''  @override
+      Iterable<String> get keys => const [${jsonKeys}];
+    ''');
+    } else {
+      // At least one field should be excluded if null
+      buffer.writeln('@override\nIterable<String> get keys sync* {');
+
+      for (var field in fields.values) {
+        var nullCheck = !_includeIfNull(field, classAnnotation.includeIfNull);
+        if (nullCheck) {
+          buffer.writeln('if (_v.${field.name} != null) {');
+        }
+        buffer.writeln('yield ${_safeNameAccess(field)};');
+        if (nullCheck) {
+          buffer.writeln('}');
+        }
+      }
+
+      buffer.writeln('}\n');
+    }
+
+    buffer.writeln('''@override
+    dynamic operator [](Object key) {
+    if (key is String) {
+    switch(key) {
+    ''');
+
+    for (var field in fields.values) {
+      var valueAccess = '_v.${field.name}';
+      buffer.write('''case ${_safeNameAccess(field)}:
+        return ${_serializeField(field, classAnnotation.nullable, accessOverride:  valueAccess)};''');
+    }
+
+    buffer.writeln('''
+      }}
+      return null;
+    }''');
+
+    buffer.writeln('}');
+  }
+
   void _writeToJsonWithNullChecks(StringBuffer buffer,
       Iterable<FieldElement> fields, JsonSerializable classAnnotation) {
     buffer.writeln('{');
@@ -352,7 +431,8 @@ void $toJsonMapHelperName(String key, dynamic value) {
   /// representing the serialization of a value.
   String _serialize(DartType targetType, String expression, bool nullable) =>
       _allHelpers
-          .map((h) => h.serialize(targetType, expression, nullable, _serialize))
+          .map((h) =>
+              h.serialize(targetType, expression, nullable, _helperContext))
           .firstWhere((r) => r != null,
               orElse: () =>
                   throw new UnsupportedTypeError(targetType, expression));
@@ -377,10 +457,35 @@ void $toJsonMapHelperName(String key, dynamic value) {
   String _deserialize(DartType targetType, String expression, bool nullable) =>
       _allHelpers
           .map((th) =>
-              th.deserialize(targetType, expression, nullable, _deserialize))
+              th.deserialize(targetType, expression, nullable, _helperContext))
           .firstWhere((r) => r != null,
               orElse: () =>
                   throw new UnsupportedTypeError(targetType, expression));
+
+  _TypeHelperContext get _helperContext => _typeHelperContextExpando[this] ??=
+      new _TypeHelperContext(_serialize, _deserialize, useWrappers);
+}
+
+final _typeHelperContextExpando = new Expando<_TypeHelperContext>();
+
+typedef String _TypeHelperGenerator(
+    DartType fieldType, String expression, bool nullable);
+
+class _TypeHelperContext implements SerializeContext, DeserializeContext {
+  final _TypeHelperGenerator _serialize, _deserialize;
+
+  @override
+  final bool useWrappers;
+
+  _TypeHelperContext(this._serialize, this._deserialize, this.useWrappers);
+
+  @override
+  String serialize(DartType fieldType, String expression, bool nullable) =>
+      _serialize(fieldType, expression, nullable);
+
+  @override
+  String deserialize(DartType fieldType, String expression, bool nullable) =>
+      _deserialize(fieldType, expression, nullable);
 }
 
 String _safeNameAccess(FieldElement field) {

json_serializable/lib/src/type_helper.dart

@@ -15,8 +15,14 @@ List<DartType> typeArgumentsOf(DartType type, TypeChecker checker) {
   return implementation?.typeArguments;
 }
 
-typedef String TypeHelperGenerator(
-    DartType fieldType, String expression, bool nullable);
+abstract class SerializeContext {
+  bool get useWrappers;
+  String serialize(DartType fieldType, String expression, bool nullable);
+}
+
+abstract class DeserializeContext {
+  String deserialize(DartType fieldType, String expression, bool nullable);
+}
 
 abstract class TypeHelper {
   const TypeHelper();
@@ -36,9 +42,9 @@ abstract class TypeHelper {
   /// String serialize(DartType targetType, String expression) =>
   ///   "$expression.id";
   /// ```.
-  // TODO(kevmoo) – document `serializeNested`
+  // TODO(kevmoo) – document `context`
   String serialize(DartType targetType, String expression, bool nullable,
-      TypeHelperGenerator serializeNested);
+      SerializeContext context);
 
   /// Returns Dart code that deserializes an [expression] representing a JSON
   /// literal to into [targetType].
@@ -63,9 +69,9 @@ abstract class TypeHelper {
   /// String deserialize(DartType targetType, String expression) =>
   ///   "new ${targetType.name}.fromInt($expression)";
   /// ```.
-  // TODO(kevmoo) – document `deserializeNested`
+  // TODO(kevmoo) – document `context`
   String deserialize(DartType targetType, String expression, bool nullable,
-      TypeHelperGenerator deserializeNested);
+      DeserializeContext context);
 }
 
 /// A [TypeChecker] for [String], [bool] and [num].

json_serializable/lib/src/type_helpers/enum_helper.dart

@@ -7,7 +7,7 @@ class EnumHelper extends TypeHelper {
 
   @override
   String serialize(DartType targetType, String expression, bool nullable,
-      TypeHelperGenerator serializeNested) {
+      SerializeContext context) {
     if (targetType is InterfaceType && targetType.element.isEnum) {
       return commonNullPrefix(
           nullable, expression, "$expression.toString().split('.')[1]");
@@ -18,7 +18,7 @@ class EnumHelper extends TypeHelper {
 
   @override
   String deserialize(DartType targetType, String expression, bool nullable,
-      TypeHelperGenerator deserializeNested) {
+      DeserializeContext context) {
     if (targetType is InterfaceType && targetType.element.isEnum) {
       return commonNullPrefix(
           nullable,

json_serializable/lib/src/type_helpers/iterable_helper.dart

@@ -10,16 +10,21 @@ class IterableHelper extends TypeHelper {
 
   @override
   String serialize(DartType targetType, String expression, bool nullable,
-      TypeHelperGenerator serializeNested) {
+      SerializeContext context) {
     if (!_coreIterableChecker.isAssignableFromType(targetType)) {
       return null;
     }
 
+    var args = typeArgumentsOf(targetType, _coreIterableChecker);
+    assert(args.length == 1);
+
+    var keyType = args[0];
+
     // This block will yield a regular list, which works fine for JSON
     // Although it's possible that child elements may be marked unsafe
 
     var isList = _coreListChecker.isAssignableFromType(targetType);
-    var subFieldValue = serializeNested(
+    var subFieldValue = context.serialize(
         _getIterableGenericType(targetType), _closureArg, nullable);
 
     var optionalQuestion = nullable ? '?' : '';
@@ -28,6 +33,15 @@ class IterableHelper extends TypeHelper {
     // will be identical to `substitute` – so no explicit mapping is needed.
     // If they are not equal, then we to write out the substitution.
     if (subFieldValue != _closureArg) {
+      if (context.useWrappers && isList) {
+        var method = '\$wrapList';
+        if (nullable) {
+          method = '${method}HandleNull';
+        }
+
+        return '$method<$keyType>($expression, ($_closureArg) => $subFieldValue)';
+      }
+
       // TODO: the type could be imported from a library with a prefix!
       expression =
           '${expression}${optionalQuestion}.map(($_closureArg) => $subFieldValue)';
@@ -47,15 +61,15 @@ class IterableHelper extends TypeHelper {
 
   @override
   String deserialize(DartType targetType, String expression, bool nullable,
-      TypeHelperGenerator deserializeNested) {
+      DeserializeContext context) {
     if (!_coreIterableChecker.isAssignableFromType(targetType)) {
       return null;
     }
 
     var iterableGenericType = _getIterableGenericType(targetType);
 
     var itemSubVal =
-        deserializeNested(iterableGenericType, _closureArg, nullable);
+        context.deserialize(iterableGenericType, _closureArg, nullable);
 
     // If `itemSubVal` is the same, then we don't need to do anything fancy
     if (_closureArg == itemSubVal) {