support number key

Author: taowen

src/main/java/com/jsoniter/output/Codegen.java

@@ -79,7 +79,7 @@ private static synchronized Encoder gen(final String cacheKey, Type type) {
             }
             ClassInfo classInfo = new ClassInfo(type);
             if (Map.class.isAssignableFrom(classInfo.clazz) && classInfo.typeArgs.length > 1) {
-                DefaultMapKeyEncoder.registerOrGetExisting(classInfo.typeArgs[0]);
+                MapKeyEncoders.registerOrGetExisting(classInfo.typeArgs[0]);
             }
             if (mode == EncodingMode.REFLECTION_MODE) {
                 encoder = ReflectionEncoderFactory.create(classInfo);

src/main/java/com/jsoniter/output/CodegenAccess.java

@@ -53,8 +53,8 @@ public static void writeVal(String cacheKey, double obj, JsonStream stream) thro
     }
 
     public static void writeMapKey(String cacheKey, Object mapKey, JsonStream stream) throws IOException {
-        String encodedMapKey = JsoniterSpi.getMapKeyEncoder(cacheKey).encode(mapKey);
-        stream.writeVal(encodedMapKey);
+        Encoder mapKeyEncoder = JsoniterSpi.getMapKeyEncoder(cacheKey);
+        mapKeyEncoder.encode(mapKey, stream);
     }
 
     public static void writeStringWithoutQuote(String obj, JsonStream stream) throws IOException {

src/main/java/com/jsoniter/output/DefaultMapKeyEncoder.java

@@ -331,6 +331,15 @@ public final void writeObjectField(String field) throws IOException {
         }
     }
 
+    public final void writeObjectField(Object key, Encoder keyEncoder) throws IOException {
+        keyEncoder.encode(key, this);
+        if (indention > 0) {
+            write((byte) ':', (byte) ' ');
+        } else {
+            write(':');
+        }
+    }
+
     public final void writeObjectEnd() throws IOException {
         int indentionStep = currentConfig().indentionStep();
         writeIndention(indentionStep);

src/main/java/com/jsoniter/output/JsonStream.java

@@ -0,0 +1,50 @@
+package com.jsoniter.output;
+
+import com.jsoniter.spi.*;
+
+import java.io.IOException;
+import java.lang.reflect.Type;
+
+class MapKeyEncoders {
+
+    public static Encoder registerOrGetExisting(Type mapKeyType) {
+        String cacheKey = JsoniterSpi.getMapKeyEncoderCacheKey(mapKeyType);
+        Encoder mapKeyEncoder = JsoniterSpi.getMapKeyEncoder(cacheKey);
+        if (null != mapKeyEncoder) {
+            return mapKeyEncoder;
+        }
+        mapKeyEncoder = createDefaultEncoder(mapKeyType);
+        JsoniterSpi.addNewMapEncoder(cacheKey, mapKeyEncoder);
+        return mapKeyEncoder;
+    }
+
+    private static Encoder createDefaultEncoder(Type mapKeyType) {
+        if (mapKeyType == String.class) {
+            return new StringKeyEncoder();
+        }
+        if (mapKeyType instanceof Class) {
+            if (Number.class.isAssignableFrom((Class<?>) mapKeyType)) {
+                return new NumberKeyEncoder();
+            }
+        }
+        throw new JsonException("can not encode map key type: " + mapKeyType);
+    }
+
+    private static class StringKeyEncoder implements Encoder {
+
+        @Override
+        public void encode(Object obj, JsonStream stream) throws IOException {
+            stream.writeVal(obj);
+        }
+    }
+
+    private static class NumberKeyEncoder implements Encoder {
+
+        @Override
+        public void encode(Object obj, JsonStream stream) throws IOException {
+            stream.write('"');
+            stream.writeVal(obj);
+            stream.write('"');
+        }
+    }
+}

src/main/java/com/jsoniter/output/MapKeyEncoders.java

@@ -11,7 +11,7 @@
 class ReflectionMapEncoder implements Encoder.ReflectionEncoder {
 
     private final TypeLiteral valueTypeLiteral;
-    private final MapKeyEncoder mapKeyEncoder;
+    private final Encoder mapKeyEncoder;
 
     public ReflectionMapEncoder(Class clazz, Type[] typeArgs) {
         Type keyType = String.class;
@@ -20,11 +20,7 @@ public ReflectionMapEncoder(Class clazz, Type[] typeArgs) {
             keyType = typeArgs[0];
             valueType = typeArgs[1];
         }
-        if (keyType == String.class) {
-            mapKeyEncoder = null;
-        } else {
-            mapKeyEncoder = DefaultMapKeyEncoder.registerOrGetExisting(keyType);
-        }
+        mapKeyEncoder = MapKeyEncoders.registerOrGetExisting(keyType);
         valueTypeLiteral = TypeLiteral.create(valueType);
     }
 
@@ -58,11 +54,7 @@ private boolean writeEntry(JsonStream stream, boolean notFirst, Map.Entry<Object
             stream.writeIndention();
             notFirst = true;
         }
-        if (mapKeyEncoder == null) {
-            stream.writeObjectField((String) entry.getKey());
-        } else {
-            stream.writeObjectField(mapKeyEncoder.encode(entry.getKey()));
-        }
+        stream.writeObjectField(entry.getKey(), mapKeyEncoder);
         stream.writeVal(valueTypeLiteral, entry.getValue());
         return notFirst;
     }

src/main/java/com/jsoniter/output/ReflectionMapEncoder.java

@@ -13,7 +13,7 @@ public class JsoniterSpi {
     private static List<Extension> extensions = new ArrayList<Extension>();
     private static Map<Class, Class> typeImpls = new HashMap<Class, Class>();
     private static Map<Type, MapKeyDecoder> globalMapKeyDecoders = new HashMap<Type, MapKeyDecoder>();
-    private static Map<Type, MapKeyEncoder> globalMapKeyEncoders = new HashMap<Type, MapKeyEncoder>();
+    private static Map<Type, Encoder> globalMapKeyEncoders = new HashMap<Type, Encoder>();
     private static Map<Type, Decoder> globalTypeDecoders = new HashMap<Type, Decoder>();
     private static Map<Type, Encoder> globalTypeEncoders = new HashMap<Type, Encoder>();
     private static Map<TypeProperty, Decoder> globalPropertyDecoders = new HashMap<TypeProperty, Decoder>();
@@ -27,7 +27,7 @@ protected Config initialValue() {
         }
     };
     private static volatile Map<Object, String> configNames = new HashMap<Object, String>();
-    private static volatile Map<String, MapKeyEncoder> mapKeyEncoders = new HashMap<String, MapKeyEncoder>();
+    private static volatile Map<String, Encoder> mapKeyEncoders = new HashMap<String, Encoder>();
     private static volatile Map<String, MapKeyDecoder> mapKeyDecoders = new HashMap<String, MapKeyDecoder>();
     private static volatile Map<String, Encoder> encoders = new HashMap<String, Encoder>();
     private static volatile Map<String, Decoder> decoders = new HashMap<String, Decoder>();
@@ -103,7 +103,7 @@ public static void registerMapKeyDecoder(Type mapKeyType, MapKeyDecoder mapKeyDe
         copyGlobalMapKeyDecoder(getCurrentConfig().configName(), mapKeyType, mapKeyDecoder);
     }
 
-    public static void registerMapKeyEncoder(Type mapKeyType, MapKeyEncoder mapKeyEncoder) {
+    public static void registerMapKeyEncoder(Type mapKeyType, Encoder mapKeyEncoder) {
         globalMapKeyEncoders.put(mapKeyType, mapKeyEncoder);
         copyGlobalMapKeyEncoder(getCurrentConfig().configName(), mapKeyType, mapKeyEncoder);
     }
@@ -162,7 +162,7 @@ private static void copyGlobalSettings(String configName) {
         for (Map.Entry<Type, MapKeyDecoder> entry : globalMapKeyDecoders.entrySet()) {
             copyGlobalMapKeyDecoder(configName, entry.getKey(), entry.getValue());
         }
-        for (Map.Entry<Type, MapKeyEncoder> entry : globalMapKeyEncoders.entrySet()) {
+        for (Map.Entry<Type, Encoder> entry : globalMapKeyEncoders.entrySet()) {
             copyGlobalMapKeyEncoder(configName, entry.getKey(), entry.getValue());
         }
         for (Map.Entry<Type, Decoder> entry : globalTypeDecoders.entrySet()) {
@@ -200,7 +200,7 @@ private static void copyGlobalMapKeyDecoder(String configName, Type mapKeyType,
         addNewMapDecoder(TypeLiteral.create(mapKeyType).getDecoderCacheKey(configName), mapKeyDecoder);
     }
 
-    private static void copyGlobalMapKeyEncoder(String configName, Type mapKeyType, MapKeyEncoder mapKeyEncoder) {
+    private static void copyGlobalMapKeyEncoder(String configName, Type mapKeyType, Encoder mapKeyEncoder) {
         addNewMapEncoder(TypeLiteral.create(mapKeyType).getEncoderCacheKey(configName), mapKeyEncoder);
     }
 
@@ -226,13 +226,13 @@ public static MapKeyDecoder getMapKeyDecoder(String cacheKey) {
         return mapKeyDecoders.get(cacheKey);
     }
 
-    public synchronized static void addNewMapEncoder(String cacheKey, MapKeyEncoder mapKeyEncoder) {
-        HashMap<String, MapKeyEncoder> newCache = new HashMap<String, MapKeyEncoder>(mapKeyEncoders);
+    public synchronized static void addNewMapEncoder(String cacheKey, Encoder mapKeyEncoder) {
+        HashMap<String, Encoder> newCache = new HashMap<String, Encoder>(mapKeyEncoders);
         newCache.put(cacheKey, mapKeyEncoder);
         mapKeyEncoders = newCache;
     }
 
-    public static MapKeyEncoder getMapKeyEncoder(String cacheKey) {
+    public static Encoder getMapKeyEncoder(String cacheKey) {
         return mapKeyEncoders.get(cacheKey);
     }
 

src/main/java/com/jsoniter/spi/JsoniterSpi.java

@@ -1,9 +1,6 @@
 package com.jsoniter.output;
 
-import com.jsoniter.spi.Config;
-import com.jsoniter.spi.JsoniterSpi;
-import com.jsoniter.spi.MapKeyEncoder;
-import com.jsoniter.spi.TypeLiteral;
+import com.jsoniter.spi.*;
 import junit.framework.TestCase;
 
 import java.io.ByteArrayOutputStream;
@@ -70,11 +67,11 @@ public static class TestObject1 {
     }
 
     public void test_MapKeyCodec() {
-        JsoniterSpi.registerMapKeyEncoder(TestObject1.class, new MapKeyEncoder() {
+        JsoniterSpi.registerMapKeyEncoder(TestObject1.class, new Encoder() {
             @Override
-            public String encode(Object mapKey) {
-                TestObject1 obj = (TestObject1) mapKey;
-                return String.valueOf(obj.Field);
+            public void encode(Object obj, JsonStream stream) throws IOException {
+                TestObject1 mapKey = (TestObject1) obj;
+                stream.writeVal(String.valueOf(mapKey.Field));
             }
         });
         HashMap<TestObject1, Object> obj = new HashMap<TestObject1, Object>();
@@ -120,4 +117,11 @@ public void test_indention_with_empty_map() {
                 .build();
         assertEquals("{}", JsonStream.serialize(config, new HashMap<String, String>()));
     }
+
+    public void test_int_as_map_key() {
+        HashMap<Integer, Integer> m = new HashMap<Integer, Integer>();
+        m.put(1, 2);
+        assertEquals("{\"1\":2}", JsonStream.serialize(new TypeLiteral<Map<Integer, Integer>>(){
+        }, m));
+    }
 }