// Copyright (c) 2018, 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.
|
|
import 'package:analyzer/dart/element/element.dart';
|
import 'package:json_annotation/json_annotation.dart';
|
|
import 'constants.dart';
|
import 'helper_core.dart';
|
import 'type_helper.dart';
|
|
abstract class EncodeHelper implements HelperCore {
|
String _fieldAccess(FieldElement field) {
|
var fieldAccess = field.name;
|
if (config.generateToJsonFunction) {
|
fieldAccess = '$_toJsonParamName.$fieldAccess';
|
}
|
return fieldAccess;
|
}
|
|
String _mixinClassName(bool withConstraints) =>
|
'${prefix}SerializerMixin${genericClassArgumentsImpl(withConstraints)}';
|
|
String _wrapperClassName([bool withConstraints]) =>
|
'${prefix}JsonMapWrapper${genericClassArgumentsImpl(withConstraints)}';
|
|
Iterable<String> createToJson(Set<FieldElement> accessibleFields) sync* {
|
assert(config.createToJson);
|
|
final buffer = StringBuffer();
|
|
if (config.generateToJsonFunction) {
|
final functionName = '${prefix}ToJson${genericClassArgumentsImpl(true)}';
|
buffer.write('Map<String, dynamic> $functionName'
|
'($targetClassReference $_toJsonParamName) ');
|
} else {
|
//
|
// Generate the mixin class
|
//
|
buffer.writeln('abstract class ${_mixinClassName(true)} {');
|
|
// write copies of the fields - this allows the toJson method to access
|
// the fields of the target class
|
for (final field in accessibleFields) {
|
//TODO - handle aliased imports
|
buffer.writeln(' ${field.type} get ${field.name};');
|
}
|
|
buffer.write(' Map<String, dynamic> toJson() ');
|
}
|
|
final writeNaive = accessibleFields.every(_writeJsonValueNaive);
|
|
if (config.useWrappers) {
|
final param = config.generateToJsonFunction ? _toJsonParamName : 'this';
|
buffer.writeln('=> ${_wrapperClassName(false)}($param);');
|
} else {
|
if (writeNaive) {
|
// write simple `toJson` method that includes all keys...
|
_writeToJsonSimple(buffer, accessibleFields);
|
} else {
|
// At least one field should be excluded if null
|
_writeToJsonWithNullChecks(buffer, accessibleFields);
|
}
|
}
|
|
if (!config.generateToJsonFunction) {
|
// end of the mixin class
|
buffer.writeln('}');
|
}
|
|
yield buffer.toString();
|
|
if (config.useWrappers) {
|
yield _createWrapperClass(accessibleFields);
|
}
|
}
|
|
String _createWrapperClass(Iterable<FieldElement> fields) {
|
final buffer = StringBuffer();
|
buffer.writeln();
|
// TODO(kevmoo): write JsonMapWrapper if annotation lib is prefix-imported
|
|
final fieldType = config.generateToJsonFunction
|
? targetClassReference
|
: _mixinClassName(false);
|
|
buffer.writeln('''
|
class ${_wrapperClassName(true)} extends \$JsonMapWrapper {
|
final $fieldType _v;
|
${_wrapperClassName()}(this._v);
|
''');
|
|
if (fields.every(_writeJsonValueNaive)) {
|
// TODO(kevmoo): consider just doing one code path – if it's fast
|
// enough
|
final jsonKeys = fields.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\n Iterable<String> get keys sync* {');
|
|
for (final field in fields) {
|
final nullCheck = !_writeJsonValueNaive(field);
|
if (nullCheck) {
|
buffer.write(' if (_v.${field.name} != null) {\n ');
|
}
|
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 (final field in fields) {
|
final valueAccess = '_v.${field.name}';
|
buffer.writeln('''
|
case ${safeNameAccess(field)}:
|
return ${_serializeField(field, valueAccess)};''');
|
}
|
|
buffer.writeln('''
|
}
|
}
|
return null;
|
}''');
|
|
buffer.writeln('}');
|
return buffer.toString();
|
}
|
|
void _writeToJsonSimple(StringBuffer buffer, Iterable<FieldElement> fields) {
|
buffer.writeln('=> <String, dynamic>{');
|
|
buffer.writeAll(fields.map((field) {
|
final access = _fieldAccess(field);
|
final value =
|
'${safeNameAccess(field)}: ${_serializeField(field, access)}';
|
return ' $value';
|
}), ',\n');
|
|
if (fields.isNotEmpty) {
|
buffer.write('\n ');
|
}
|
|
buffer.writeln('};');
|
}
|
|
/// Name of the parameter used when generating top-level `toJson` functions
|
/// if [JsonSerializable.generateToJsonFunction] is `true`.
|
static const _toJsonParamName = 'instance';
|
|
void _writeToJsonWithNullChecks(
|
StringBuffer buffer, Iterable<FieldElement> fields) {
|
buffer.writeln('{');
|
|
buffer.writeln(' final $generatedLocalVarName = <String, dynamic>{');
|
|
// Note that the map literal is left open above. As long as target fields
|
// don't need to be intercepted by the `only if null` logic, write them
|
// to the map literal directly. In theory, should allow more efficient
|
// serialization.
|
var directWrite = true;
|
|
for (final field in fields) {
|
var safeFieldAccess = _fieldAccess(field);
|
final safeJsonKeyString = safeNameAccess(field);
|
|
// If `fieldName` collides with one of the local helpers, prefix
|
// access with `this.`.
|
if (safeFieldAccess == generatedLocalVarName ||
|
safeFieldAccess == toJsonMapHelperName) {
|
assert(!config.generateToJsonFunction,
|
'This code path should only be hit during the mixin codepath.');
|
safeFieldAccess = 'this.$safeFieldAccess';
|
}
|
|
final expression = _serializeField(field, safeFieldAccess);
|
if (_writeJsonValueNaive(field)) {
|
if (directWrite) {
|
buffer.writeln(' $safeJsonKeyString: $expression,');
|
} else {
|
buffer.writeln(
|
' $generatedLocalVarName[$safeJsonKeyString] = $expression;');
|
}
|
} else {
|
if (directWrite) {
|
// close the still-open map literal
|
buffer.writeln(' };');
|
buffer.writeln();
|
|
// write the helper to be used by all following null-excluding
|
// fields
|
buffer.writeln('''
|
void $toJsonMapHelperName(String key, dynamic value) {
|
if (value != null) {
|
$generatedLocalVarName[key] = value;
|
}
|
}
|
''');
|
directWrite = false;
|
}
|
buffer.writeln(
|
' $toJsonMapHelperName($safeJsonKeyString, $expression);');
|
}
|
}
|
|
buffer.writeln(' return $generatedLocalVarName;');
|
buffer.writeln(' }');
|
}
|
|
String _serializeField(FieldElement field, String accessExpression) {
|
try {
|
return getHelperContext(field)
|
.serialize(field.type, accessExpression)
|
.toString();
|
} on UnsupportedTypeError catch (e) {
|
throw createInvalidGenerationError('toJson', field, e);
|
}
|
}
|
|
/// Returns `true` if the field can be written to JSON 'naively' – meaning
|
/// we can avoid checking for `null`.
|
///
|
/// `true` if either:
|
/// `includeIfNull` is `true`
|
/// or
|
/// `nullable` is `false`.
|
bool _writeJsonValueNaive(FieldElement field) =>
|
jsonKeyFor(field).includeIfNull || !jsonKeyFor(field).nullable;
|
}
|
