Fix #2129

Author: cowtowncoder

release-notes/CREDITS-2.x

@@ -884,6 +884,10 @@ Joe Barnett (josephlbarnett@github)
     ignored when creator properties are buffered
    (2.9.10)
 
+Zihui Ren (renzihui@github)
+  * Suggested #2129: Add `SerializationFeature.WRITE_ENUM_KEYS_USING_INDEX`, separate from value setting
+   (2.10.0)
+
 Yiqiu Huang (huangyq23@github
   * Reported #2164: `FactoryBasedEnumDeserializer` does not respect
    `DeserializationFeature.WRAP_EXCEPTIONS`

release-notes/VERSION-2.x

@@ -6,6 +6,8 @@ Project: jackson-databind
 
 2.10.0-final (not yet released)
 
+#2129: Add `SerializationFeature.WRITE_ENUM_KEYS_USING_INDEX`, separate from value setting
+ (suggested by renzihui@github)
 #2149: Add `MapperFeature.ACCEPT_CASE_INSENSITIVE_VALUES`
  (suggested by Craig P)
 #2164: `FactoryBasedEnumDeserializer` does not respect

src/main/java/com/fasterxml/jackson/databind/SerializationFeature.java

@@ -257,7 +257,7 @@ public enum SerializationFeature implements ConfigFeature
     WRITE_ENUMS_USING_TO_STRING(false),
 
     /**
-     * Feature that determines whethere Java Enum values are serialized
+     * Feature that determines whether Java Enum values are serialized
      * as numbers (true), or textual values (false). If textual values are
      * used, other settings are also considered.
      * If this feature is enabled,
@@ -267,10 +267,27 @@ public enum SerializationFeature implements ConfigFeature
      * Note that this feature has precedence over {@link #WRITE_ENUMS_USING_TO_STRING},
      * which is only considered if this feature is set to false.
      *<p>
+     * Note that since 2.10, this does NOT apply to {@link Enum}s written as
+     * keys of {@link java.util.Map} values, which has separate setting,
+     * {@link #WRITE_ENUM_KEYS_USING_INDEX}.
+     *<p>
      * Feature is disabled by default.
      */
     WRITE_ENUMS_USING_INDEX(false),
 
+    /**
+     * Feature that determines whether {link Enum}s
+     * used as {@link java.util.Map} keys are serialized
+     * as using {@link Enum#ordinal()} or not.
+     * Similar to {@link #WRITE_ENUMS_USING_INDEX} used when writing
+     * {@link Enum}s as regular values.
+     *<p>
+     * Feature is disabled by default.
+     * 
+     * @since 2.10
+     */
+    WRITE_ENUM_KEYS_USING_INDEX(false),
+    
     /**
      * Feature that determines whether Map entries with null values are
      * to be serialized (true) or not (false).

src/main/java/com/fasterxml/jackson/databind/ser/std/EnumSerializer.java

@@ -119,7 +119,6 @@ public JsonSerializer<?> createContextual(SerializerProvider serializers,
     public final void serialize(Enum<?> en, JsonGenerator gen, SerializerProvider serializers)
         throws IOException
     {
-        // [JACKSON-684]: serialize as index?
         if (_serializeAsIndex(serializers)) {
             gen.writeNumber(en.ordinal());
             return;

src/main/java/com/fasterxml/jackson/databind/ser/std/StdKeySerializers.java

@@ -166,7 +166,8 @@ public void serialize(Object value, JsonGenerator g, SerializerProvider provider
                         key = value.toString();
                     } else {
                         Enum<?> e = (Enum<?>) value;
-                        if (provider.isEnabled(SerializationFeature.WRITE_ENUMS_USING_INDEX)) {
+                        // 14-Sep-2019, tatu: [databind#2129] Use this specific feature
+                        if (provider.isEnabled(SerializationFeature.WRITE_ENUM_KEYS_USING_INDEX)) {
                             key = String.valueOf(e.ordinal());
                         } else {
                             key = e.name();
@@ -293,7 +294,8 @@ public void serialize(Object value, JsonGenerator g, SerializerProvider serializ
                 return;
             }
             Enum<?> en = (Enum<?>) value;
-            if (serializers.isEnabled(SerializationFeature.WRITE_ENUMS_USING_INDEX)) {
+            // 14-Sep-2019, tatu: [databind#2129] Use this specific feature
+            if (serializers.isEnabled(SerializationFeature.WRITE_ENUM_KEYS_USING_INDEX)) {
                 g.writeFieldName(String.valueOf(en.ordinal()));
                 return;
             }

src/test/java/com/fasterxml/jackson/databind/ser/TestEnumSerialization.java

@@ -288,10 +288,14 @@ public void testMapWithEnumKeys() throws Exception
         assertEquals("{\"map\":{\"b\":3}}", json);
 
         // [databind#1570]
+
+        // 14-Sep-2019, tatu: as per [databind#2129], must NOT use this feature but
+        //    instead new `WRITE_ENUM_KEYS_USING_INDEX` added in 2.10
         json = MAPPER.writer()
                 .with(SerializationFeature.WRITE_ENUMS_USING_INDEX)
                 .writeValueAsString(bean);
-        assertEquals(aposToQuotes("{'map':{'"+TestEnum.B.ordinal()+"':3}}"), json);
+//        assertEquals(aposToQuotes("{'map':{'"+TestEnum.B.ordinal()+"':3}}"), json);
+        assertEquals(aposToQuotes("{'map':{'B':3}}"), json);
     }
 
     public void testAsIndex() throws Exception

src/test/java/com/fasterxml/jackson/failing/EnumAsIndexMapKey1877Test.java

@@ -0,0 +1,68 @@
+package com.fasterxml.jackson.failing;
+
+import java.util.*;
+
+import com.fasterxml.jackson.databind.*;
+
+public class EnumAsIndexMapKey2129Test extends BaseMapTest
+{
+    // [databind#2129]
+    public enum Type {
+        FIRST,
+        SECOND;
+    }
+
+    static class TypeContainer {
+        public Map<Type, Integer> values;
+
+        public TypeContainer(Type type, int value) {
+            values = Collections.singletonMap(type, value);
+        }
+    }
+
+    final ObjectMapper MAPPER = newJsonMapper();
+    
+    // [databind#2129]
+    public void testEnumAsIndexForRootMap() throws Exception
+    {
+        final Map<Type, Integer> input = Collections.singletonMap(Type.FIRST, 3);
+
+        // by default, write using name()
+        assertEquals(aposToQuotes("{'FIRST':3}"),
+                MAPPER.writeValueAsString(input));
+
+        // but change with setting
+        assertEquals(aposToQuotes("{'0':3}"),
+                MAPPER.writer()
+                .with(SerializationFeature.WRITE_ENUM_KEYS_USING_INDEX)
+                .writeValueAsString(input));
+
+        // but NOT with value settings
+        assertEquals(aposToQuotes("{'FIRST':3}"),
+                MAPPER.writer()
+                    .with(SerializationFeature.WRITE_ENUMS_USING_INDEX)
+                    .writeValueAsString(input));
+    }
+    
+    // [databind#2129]
+    public void testEnumAsIndexForValueMap() throws Exception
+    {
+        final TypeContainer input = new TypeContainer(Type.SECOND, 72);
+
+        // by default, write using name()
+        assertEquals(aposToQuotes("{'values':{'SECOND':72}}"),
+                MAPPER.writeValueAsString(input));
+
+        // but change with setting
+        assertEquals(aposToQuotes("{'values':{'1':72}}"),
+                MAPPER.writer()
+                .with(SerializationFeature.WRITE_ENUM_KEYS_USING_INDEX)
+                .writeValueAsString(input));
+
+        // but NOT with value settings
+        assertEquals(aposToQuotes("{'values':{'SECOND':72}}"),
+                MAPPER.writer()
+                    .with(SerializationFeature.WRITE_ENUMS_USING_INDEX)
+                    .writeValueAsString(input));
+    }
+}