generate method

void generate(IndentingWriter out)

Implementation

void generate(IndentingWriter out) {
  final commentBlock = fileGen?.commentBlock(fieldPath);
  if (commentBlock != null) {
    out.println(commentBlock);
  }
  if (_descriptor.options.deprecated) {
    out.println('@$coreImportPrefix.Deprecated(\'This enum is deprecated\')');
  }
  out.addAnnotatedBlock(
      'class $classname extends $protobufImportPrefix.ProtobufEnum {',
      '}\n', [
    NamedLocation(
        name: classname, fieldPathSegment: fieldPath, start: 'class '.length)
  ], () {
    // -----------------------------------------------------------------
    // Define enum types.
    final omitEnumNames = ConditionalConstDefinition('omit_enum_names');
    for (var i = 0; i < _canonicalValues.length; i++) {
      final val = _canonicalValues[i];
      final name = dartNames[val.name]!;
      out.addSuffix(
          omitEnumNames.constFieldName, omitEnumNames.constDefinition);
      final conditionalValName = omitEnumNames.createTernary(val.name);
      final fieldPathSegment = List<int>.from(fieldPath)
        ..addAll([_enumValueTag, _originalCanonicalIndices[i]]);

      final commentBlock = fileGen?.commentBlock(fieldPathSegment);
      if (commentBlock != null) {
        out.println(commentBlock);
      }

      if (val.options.deprecated) {
        out.println(
            '@$coreImportPrefix.Deprecated(\'This enum value is deprecated\')');
      }

      out.printlnAnnotated(
          'static const $classname $name = '
          '$classname._(${val.number}, $conditionalValName);',
          [
            NamedLocation(
                name: name,
                fieldPathSegment: fieldPathSegment,
                start: 'static const $classname '.length)
          ]);
    }
    if (_aliases.isNotEmpty) {
      out.println();
      for (var i = 0; i < _aliases.length; i++) {
        final alias = _aliases[i];
        final name = dartNames[alias.value.name]!;
        out.printlnAnnotated(
            'static const $classname $name ='
            ' ${dartNames[alias.canonicalValue.name]};',
            [
              NamedLocation(
                  name: name,
                  fieldPathSegment: List.from(fieldPath)
                    ..addAll([_enumValueTag, _originalAliasIndices[i]]),
                  start: 'static const $classname '.length)
            ]);
      }
    }
    out.println();

    out.println('static const $coreImportPrefix.List<$classname> values ='
        ' <$classname> [');
    for (final val in _canonicalValues) {
      final name = dartNames[val.name];
      out.println('  $name,');
    }
    out.println('];');
    out.println();

    var maxEnumValue = -1;
    for (final valueDescriptor in _canonicalValues) {
      if (valueDescriptor.number.isNegative) {
        maxEnumValue = -1; // don't use list
        break;
      }
      if (valueDescriptor.number > maxEnumValue) {
        maxEnumValue = valueDescriptor.number;
      }
    }

    final useList = _canonicalValues.isEmpty ||
        (maxEnumValue >= 0 &&
            _canonicalValues.length / (maxEnumValue + 1) >= 0.7);

    if (useList) {
      out.println(
          'static final $coreImportPrefix.List<$classname?> _byValue ='
          ' $protobufImportPrefix.ProtobufEnum.\$_initByValueList(values, $maxEnumValue);');

      out.println('static $classname? valueOf($coreImportPrefix.int value) =>'
          '  value < 0 || value >= _byValue.length ? null : _byValue[value];');
    } else {
      out.println(
          'static final $coreImportPrefix.Map<$coreImportPrefix.int, $classname> _byValue ='
          ' $protobufImportPrefix.ProtobufEnum.initByValue(values);');

      out.println('static $classname? valueOf($coreImportPrefix.int value) =>'
          ' _byValue[value];');
    }

    out.println();

    out.println('const $classname._(super.value, super.name);');
  });
}