alef 0.110.2

Opinionated polyglot binding generator for Rust libraries
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107

{% if is_external %}
/** Custom serializer for serde's externally tagged enum shape. */
{% elif is_adjacent %}
/** Custom serializer for sealed interface with unwrapped variants. Emits serde's adjacently tagged shape: the discriminator under "{{ tag_field_doc }}" and the whole payload under "{{ content_field_doc }}". */
{% else %}
/** Custom serializer for sealed interface with unwrapped variants. Emits the discriminator tag alongside the inner record's fields (flat object). */
{% endif %}
class {{ class_name }}Serializer extends StdSerializer<{{ class_name }}> {
  private static final long serialVersionUID = 1L;
  /** ObjectMapper for serializing inner variant values. */
  private static final com.fasterxml.jackson.databind.ObjectMapper MAPPER = createMapper();

  private static com.fasterxml.jackson.databind.ObjectMapper createMapper() {
    var mapper = new com.fasterxml.jackson.databind.ObjectMapper()
        .registerModule(new com.fasterxml.jackson.datatype.jdk8.Jdk8Module())
        .setPropertyNamingStrategy(
            com.fasterxml.jackson.databind.PropertyNamingStrategies.SNAKE_CASE)
        .setSerializationInclusion(com.fasterxml.jackson.annotation.JsonInclude.Include.NON_NULL);
{% for variant in variants %}
{% if not variant.is_unit and not variant.is_tuple %}
    mapper.addMixIn({{ class_name }}.{{ variant.name }}.class, VariantDefaultSerializerMixin.class);
{% endif %}
{% endfor %}
    return JsonMapperFactory.withNativePathSerialization(mapper);
  }

{% if has_struct_variants %}
  @com.fasterxml.jackson.databind.annotation.JsonSerialize(
      using = com.fasterxml.jackson.databind.JsonSerializer.None.class)
  private abstract static class VariantDefaultSerializerMixin {}
{% endif %}

  /** Creates a new {{ class_name }}Serializer. */
  {{ class_name }}Serializer() {
    super({{ class_name }}.class);
  }

  @Override
  @SuppressWarnings("PMD.CyclomaticComplexity")
  public void serialize({{ class_name }} value, JsonGenerator gen, SerializerProvider provider)
      throws java.io.IOException {
{% if is_external and has_untagged_string_variant %}
{% for variant in variants %}
{% if variant.is_untagged and variant.is_tuple %}
    if (value instanceof {{ class_name }}.{{ variant.name }} untagged{{ variant.name }}) {
      gen.writeString(untagged{{ variant.name }}.value());
      return;
    }
{% endif %}
{% endfor %}

{% endif %}
    String tag;
    Object inner;
    {%- for variant in variants %}
    {% if loop.index0 > 0 %}else {% endif %}if (value instanceof {{ class_name }}.{{ variant.name }} variant{{ variant.name }}) {
      tag = "{{ variant.discriminator }}";
      {%- if variant.is_unit %}
      inner = null;
      {%- elif variant.is_tuple %}
      inner = variant{{ variant.name }}.value();
      {%- else %}
      inner = variant{{ variant.name }};
      {%- endif %}
    }
    {%- endfor %}
    else {
      throw new com.fasterxml.jackson.databind.JsonMappingException(
          gen, "Unknown {{ class_name }} variant: " + value.getClass().getName());
    }

{% if is_external %}
    if (inner == null) {
      gen.writeString(tag);
      return;
    }
    gen.writeStartObject();
    gen.writeFieldName(tag);
    gen.writeTree(MAPPER.valueToTree(inner));
    gen.writeEndObject();
{% else %}
    gen.writeStartObject();
    gen.writeStringField("{{ tag_field }}", tag);
{% if is_adjacent %}
    if (inner != null) {
      gen.writeFieldName("{{ content_field }}");
      gen.writeTree(MAPPER.valueToTree(inner));
    }
{% else %}
    if (inner != null) {
      com.fasterxml.jackson.databind.JsonNode tree = MAPPER.valueToTree(inner);
      if (tree.isObject()) {
        java.util.Iterator<java.util.Map.Entry<String, com.fasterxml.jackson.databind.JsonNode>>
            fieldIterator = tree.fields();
        while (fieldIterator.hasNext()) {
          java.util.Map.Entry<String, com.fasterxml.jackson.databind.JsonNode> field =
              fieldIterator.next();
          gen.writeFieldName(field.getKey());
          gen.writeTree(field.getValue());
        }
      }
    }
{% endif %}
    gen.writeEndObject();
{% endif %}
  }
}