#62 support map with non-string key

taowen · taowen · commit 8326d11f3336 · 2017-06-02T23:09:12.000+08:00
diff --git a/demo/src/test/java/com/jsoniter/demo/LazyAny.java b/demo/src/test/java/com/jsoniter/demo/LazyAny.java
@@ -2,7 +2,7 @@
 
 import com.jsoniter.any.Any;
 import com.jsoniter.JsonIterator;
-import com.jsoniter.Slice;
+import com.jsoniter.spi.Slice;
 import com.jsoniter.output.JsonStream;
 import org.junit.Test;
 import org.openjdk.jmh.Main;
@@ -12,8 +12,6 @@
 
 import java.io.IOException;
 import java.io.InputStream;
-import java.util.Arrays;
-import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 
diff --git a/pom.xml b/pom.xml
@@ -55,6 +55,12 @@
             <version>2.8.5</version>
             <optional>true</optional>
         </dependency>
+        <dependency>
+            <groupId>com.fasterxml.jackson.core</groupId>
+            <artifactId>jackson-databind</artifactId>
+            <version>2.8.5</version>
+            <optional>true</optional>
+        </dependency>
     </dependencies>
 
     <build>
diff --git a/src/main/java/com/jsoniter/Codegen.java b/src/main/java/com/jsoniter/Codegen.java
@@ -160,12 +160,12 @@ private static Type chooseImpl(Type type) {
                         "can not bind to generic collection without argument types, " +
                                 "try syntax like TypeLiteral<Map<String, String>>{}");
             }
-            if (keyType != String.class) {
-                throw new IllegalArgumentException("map key must be String");
-            }
             if (clazz == Map.class) {
                 clazz = implClazz == null ? HashMap.class : implClazz;
             }
+            if (keyType == Object.class) {
+                keyType = String.class;
+            }
             return new ParameterizedTypeImpl(new Type[]{keyType, valueType}, null, clazz);
         }
         if (implClazz != null) {
diff --git a/src/main/java/com/jsoniter/CodegenAccess.java b/src/main/java/com/jsoniter/CodegenAccess.java
@@ -141,6 +141,12 @@ public static final Slice readSlice(JsonIterator iter) throws IOException {
         return IterImpl.readSlice(iter);
     }
 
+    public static final Object readMapKey(String cacheKey, JsonIterator iter) throws IOException {
+        Slice mapKey = readObjectFieldAsSlice(iter);
+        MapKeyDecoder mapKeyDecoder = JsoniterSpi.getMapKeyDecoder(cacheKey);
+        return mapKeyDecoder.decode(mapKey);
+    }
+
     final static boolean skipWhitespacesWithoutLoadMore(JsonIterator iter) throws IOException {
         for (int i = iter.head; i < iter.tail; i++) {
             byte c = iter.buf[i];
diff --git a/src/main/java/com/jsoniter/CodegenImplEnum.java b/src/main/java/com/jsoniter/CodegenImplEnum.java
@@ -6,7 +6,7 @@ class CodegenImplEnum {
     public static String genEnum(Class clazz) {
         StringBuilder lines = new StringBuilder();
         append(lines, "if (iter.readNull()) { return null; }");
-        append(lines, "com.jsoniter.Slice field = com.jsoniter.CodegenAccess.readSlice(iter);");
+        append(lines, "com.jsoniter.spi.Slice field = com.jsoniter.CodegenAccess.readSlice(iter);");
         append(lines, "switch (field.len()) {");
         append(lines, renderTriTree(buildTriTree(Arrays.asList(clazz.getEnumConstants()))));
         append(lines, "}"); // end of switch
diff --git a/src/main/java/com/jsoniter/CodegenImplMap.java b/src/main/java/com/jsoniter/CodegenImplMap.java
@@ -1,12 +1,16 @@
 package com.jsoniter;
 
+import com.jsoniter.spi.TypeLiteral;
+
 import java.lang.reflect.Type;
 import java.util.HashMap;
 import java.util.Map;
 
 class CodegenImplMap {
 
     public static String genMap(Class clazz, Type[] typeArgs) {
+        Type keyType = typeArgs[0];
+        MapKeyDecoders.register(keyType);
         Type valueType = typeArgs[1];
         StringBuilder lines = new StringBuilder();
         append(lines, "{{clazz}} map = ({{clazz}})com.jsoniter.CodegenAccess.resetExistingObject(iter);");
@@ -16,11 +20,18 @@ public static String genMap(Class clazz, Type[] typeArgs) {
         append(lines, "return map;");
         append(lines, "}");
         append(lines, "do {");
-        append(lines, "String field = com.jsoniter.CodegenAccess.readObjectFieldAsString(iter);");
-        append(lines, "map.put(field, {{op}});");
+        if (keyType == String.class) {
+            append(lines, "Object mapKey = com.jsoniter.CodegenAccess.readObjectFieldAsString(iter);");
+        } else {
+            append(lines, "Object mapKey = com.jsoniter.CodegenAccess.readMapKey(\"" +
+                    TypeLiteral.create(keyType).getDecoderCacheKey() +"\", iter);");
+        }
+        append(lines, "map.put(mapKey, {{op}});");
         append(lines, "} while (com.jsoniter.CodegenAccess.nextToken(iter) == ',');");
         append(lines, "return map;");
-        return lines.toString().replace("{{clazz}}", clazz.getName()).replace("{{op}}", CodegenImplNative.genReadOp(valueType));
+        return lines.toString()
+                .replace("{{clazz}}", clazz.getName())
+                .replace("{{op}}", CodegenImplNative.genReadOp(valueType));
     }
 
     private static void append(StringBuilder lines, String str) {
diff --git a/src/main/java/com/jsoniter/CodegenImplObjectStrict.java b/src/main/java/com/jsoniter/CodegenImplObjectStrict.java
@@ -82,7 +82,7 @@ public static String genObjectUsingStrict(Class clazz, ClassDescriptor desc) {
         if (desc.onExtraProperties != null) {
             append(lines, "java.util.Map extra = null;");
         }
-        append(lines, "com.jsoniter.Slice field = com.jsoniter.CodegenAccess.readObjectFieldAsSlice(iter);");
+        append(lines, "com.jsoniter.spi.Slice field = com.jsoniter.CodegenAccess.readObjectFieldAsSlice(iter);");
         append(lines, "boolean once = true;");
         append(lines, "while (once) {");
         append(lines, "once = false;");
diff --git a/src/main/java/com/jsoniter/IterImpl.java b/src/main/java/com/jsoniter/IterImpl.java
@@ -2,6 +2,7 @@
 
 import com.jsoniter.any.Any;
 import com.jsoniter.spi.JsonException;
+import com.jsoniter.spi.Slice;
 
 import java.io.IOException;
 
diff --git a/src/main/java/com/jsoniter/IterImplForStreaming.java b/src/main/java/com/jsoniter/IterImplForStreaming.java
@@ -1,6 +1,7 @@
 package com.jsoniter;
 
 import com.jsoniter.any.Any;
+import com.jsoniter.spi.Slice;
 
 import java.io.IOException;
 
diff --git a/src/main/java/com/jsoniter/JsonIterator.java b/src/main/java/com/jsoniter/JsonIterator.java
@@ -3,6 +3,7 @@
 import com.jsoniter.annotation.JsoniterAnnotationSupport;
 import com.jsoniter.any.Any;
 import com.jsoniter.spi.JsonException;
+import com.jsoniter.spi.Slice;
 import com.jsoniter.spi.TypeLiteral;
 
 import java.io.Closeable;
@@ -51,6 +52,7 @@ public class JsonIterator implements Closeable {
         valueTypes['n'] = ValueType.NULL;
         valueTypes['['] = ValueType.ARRAY;
         valueTypes['{'] = ValueType.OBJECT;
+        MapKeyDecoders.registerNativeMapKeyDecoders();
     }
 
     private JsonIterator(InputStream in, byte[] buf, int head, int tail) {
diff --git a/src/main/java/com/jsoniter/MapKeyDecoders.java b/src/main/java/com/jsoniter/MapKeyDecoders.java
@@ -0,0 +1,57 @@
+package com.jsoniter;
+
+import com.jsoniter.spi.*;
+
+import java.io.IOException;
+import java.lang.reflect.Type;
+
+class MapKeyDecoders {
+    public static void registerNativeMapKeyDecoders() {
+        JsoniterSpi.registerMapKeyDecoder(String.class, new MapKeyDecoder() {
+            @Override
+            public Object decode(Slice mapKey) {
+                return mapKey.toString();
+            }
+        });
+    }
+
+    public static MapKeyDecoder register(Type mapKeyType) {
+        TypeLiteral typeLiteral = TypeLiteral.create(mapKeyType);
+        String cacheKey = typeLiteral.getDecoderCacheKey();
+        MapKeyDecoder mapKeyDecoder = JsoniterSpi.getMapKeyDecoder(cacheKey);
+        if (null != mapKeyDecoder) {
+            return mapKeyDecoder;
+        }
+        mapKeyDecoder = new DefaultMapKeyDecoder(typeLiteral);
+        JsoniterSpi.addNewMapDecoder(cacheKey, mapKeyDecoder);
+        return mapKeyDecoder;
+    }
+
+    private static class DefaultMapKeyDecoder implements MapKeyDecoder {
+
+        // can not reuse the tlsIter in JsonIterator
+        // as this will be invoked while tlsIter is in use
+        private ThreadLocal<JsonIterator> tlsIter = new ThreadLocal<JsonIterator>() {
+            @Override
+            protected JsonIterator initialValue() {
+                return new JsonIterator();
+            }
+        };
+        private final TypeLiteral mapKeyTypeLiteral;
+
+        private DefaultMapKeyDecoder(TypeLiteral mapKeyTypeLiteral) {
+            this.mapKeyTypeLiteral = mapKeyTypeLiteral;
+        }
+
+        @Override
+        public Object decode(Slice mapKey) {
+            JsonIterator iter = tlsIter.get();
+            iter.reset(mapKey);
+            try {
+                return iter.read(mapKeyTypeLiteral);
+            } catch (IOException e) {
+                throw new JsonException(e);
+            }
+        }
+    }
+}
diff --git a/src/main/java/com/jsoniter/ReflectionEnumDecoder.java b/src/main/java/com/jsoniter/ReflectionEnumDecoder.java
@@ -1,6 +1,7 @@
 package com.jsoniter;
 
 import com.jsoniter.spi.Decoder;
+import com.jsoniter.spi.Slice;
 
 import java.io.IOException;
 import java.util.HashMap;
diff --git a/src/main/java/com/jsoniter/ReflectionMapDecoder.java b/src/main/java/com/jsoniter/ReflectionMapDecoder.java
@@ -1,8 +1,6 @@
 package com.jsoniter;
 
-import com.jsoniter.spi.Decoder;
-import com.jsoniter.spi.JsonException;
-import com.jsoniter.spi.TypeLiteral;
+import com.jsoniter.spi.*;
 
 import java.io.IOException;
 import java.lang.reflect.Constructor;
@@ -13,13 +11,17 @@ class ReflectionMapDecoder implements Decoder {
 
     private final Constructor ctor;
     private final Decoder valueTypeDecoder;
+    private final MapKeyDecoder mapKeyDecoder;
+    private final Type keyType;
 
     public ReflectionMapDecoder(Class clazz, Type[] typeArgs) {
         try {
             ctor = clazz.getConstructor();
         } catch (NoSuchMethodException e) {
             throw new JsonException(e);
         }
+        keyType = typeArgs[0];
+        mapKeyDecoder = MapKeyDecoders.register(keyType);
         TypeLiteral valueTypeLiteral = TypeLiteral.create(typeArgs[1]);
         valueTypeDecoder = Codegen.getDecoder(valueTypeLiteral.getDecoderCacheKey(), typeArgs[1]);
     }
@@ -45,9 +47,17 @@ private Object decode_(JsonIterator iter) throws Exception {
             return map;
         }
         do {
-            String field = CodegenAccess.readObjectFieldAsString(iter);
-            map.put(field, valueTypeDecoder.decode(iter));
+            Object decodedMapKey = readMapKey(iter);
+            map.put(decodedMapKey, valueTypeDecoder.decode(iter));
         } while(CodegenAccess.nextToken(iter) == ',');
         return map;
     }
+
+    private Object readMapKey(JsonIterator iter) throws IOException {
+        if (keyType == String.class) {
+            return CodegenAccess.readObjectFieldAsString(iter);
+        }
+        Slice mapKey = CodegenAccess.readObjectFieldAsSlice(iter);
+        return mapKeyDecoder.decode(mapKey);
+    }
 }
diff --git a/src/main/java/com/jsoniter/extra/Base64.java b/src/main/java/com/jsoniter/extra/Base64.java
@@ -1,7 +1,7 @@
 package com.jsoniter.extra;
 
 import com.jsoniter.JsonIterator;
-import com.jsoniter.Slice;
+import com.jsoniter.spi.Slice;
 import com.jsoniter.output.JsonStream;
 
 import java.io.IOException;
diff --git a/src/main/java/com/jsoniter/extra/Base64FloatSupport.java b/src/main/java/com/jsoniter/extra/Base64FloatSupport.java
@@ -2,7 +2,7 @@
 
 import com.jsoniter.CodegenAccess;
 import com.jsoniter.JsonIterator;
-import com.jsoniter.Slice;
+import com.jsoniter.spi.Slice;
 import com.jsoniter.any.Any;
 import com.jsoniter.output.JsonStream;
 import com.jsoniter.spi.Decoder;
diff --git a/src/main/java/com/jsoniter/extra/Base64Support.java b/src/main/java/com/jsoniter/extra/Base64Support.java
@@ -1,7 +1,7 @@
 package com.jsoniter.extra;
 
 import com.jsoniter.JsonIterator;
-import com.jsoniter.Slice;
+import com.jsoniter.spi.Slice;
 import com.jsoniter.any.Any;
 import com.jsoniter.output.JsonStream;
 import com.jsoniter.spi.Decoder;
diff --git a/src/main/java/com/jsoniter/output/CodegenImplMap.java b/src/main/java/com/jsoniter/output/CodegenImplMap.java
@@ -21,9 +21,6 @@ public static CodegenResult genMap(String cacheKey, Class clazz, Type[] typeArgs
                     "can not bind to generic collection without argument types, " +
                             "try syntax like TypeLiteral<Map<String, String>>{}");
         }
-        if (keyType != String.class) {
-            throw new IllegalArgumentException("map key must be String");
-        }
         CodegenResult ctx = new CodegenResult();
         ctx.append("public static void encode_(java.lang.Object obj, com.jsoniter.output.JsonStream stream) throws java.io.IOException {");
         ctx.append("if (obj == null) { stream.writeNull(); return; }");
@@ -32,7 +29,7 @@ public static CodegenResult genMap(String cacheKey, Class clazz, Type[] typeArgs
         ctx.append("if(!iter.hasNext()) { return; }");
         ctx.append("java.util.Map.Entry entry = (java.util.Map.Entry)iter.next();");
         ctx.buffer('{');
-        ctx.append("stream.writeVal((String)entry.getKey());");
+        ctx.append("stream.writeVal(entry.getKey().toString());");
         ctx.buffer(':');
         if (isCollectionValueNullable) {
             ctx.append("if (entry.getValue() == null) { stream.writeNull(); } else {");
diff --git a/src/main/java/com/jsoniter/output/ReflectionMapEncoder.java b/src/main/java/com/jsoniter/output/ReflectionMapEncoder.java
@@ -27,16 +27,16 @@ public void encode(Object obj, JsonStream stream) throws IOException {
             stream.writeNull();
             return;
         }
-        Map<String, Object> map = (Map<String, Object>) obj;
+        Map<Object, Object> map = (Map<Object, Object>) obj;
         stream.writeObjectStart();
         boolean notFirst = false;
-        for (Map.Entry<String, Object> entry : map.entrySet()) {
+        for (Map.Entry<Object, Object> entry : map.entrySet()) {
             if (notFirst) {
                 stream.writeMore();
             } else {
                 notFirst = true;
             }
-            stream.writeObjectField(entry.getKey());
+            stream.writeObjectField(entry.getKey().toString());
             stream.writeVal(valueTypeLiteral, entry.getValue());
         }
         stream.writeObjectEnd();
diff --git a/src/main/java/com/jsoniter/spi/JsoniterSpi.java b/src/main/java/com/jsoniter/spi/JsoniterSpi.java
@@ -7,6 +7,7 @@ public class JsoniterSpi {
 
     static List<Extension> extensions = new ArrayList<Extension>();
     static Map<Class, Class> typeImpls = new HashMap<Class, Class>();
+    static volatile Map<String, MapKeyDecoder> mapKeyDecoders = new HashMap<String, MapKeyDecoder>();
     static volatile Map<String, Encoder> encoders = new HashMap<String, Encoder>();
     static volatile Map<String, Decoder> decoders = new HashMap<String, Decoder>();
     static volatile Map<Class, Extension> objectFactories = new HashMap<Class, Extension>();
@@ -19,6 +20,20 @@ public static List<Extension> getExtensions() {
         return Collections.unmodifiableList(extensions);
     }
 
+    public static void registerMapKeyDecoder(Type mapKeyType, MapKeyDecoder mapKeyDecoder) {
+        addNewMapDecoder(TypeLiteral.create(mapKeyType).getDecoderCacheKey(), mapKeyDecoder);
+    }
+
+    public synchronized static void addNewMapDecoder(String cacheKey, MapKeyDecoder mapKeyDecoder) {
+        HashMap<String, MapKeyDecoder> newCache = new HashMap<String, MapKeyDecoder>(mapKeyDecoders);
+        newCache.put(cacheKey, mapKeyDecoder);
+        mapKeyDecoders = newCache;
+    }
+
+    public static MapKeyDecoder getMapKeyDecoder(String cacheKey) {
+        return mapKeyDecoders.get(cacheKey);
+    }
+
     public static void registerTypeImplementation(Class superClazz, Class implClazz) {
         typeImpls.put(superClazz, implClazz);
     }
diff --git a/src/main/java/com/jsoniter/spi/MapKeyDecoder.java b/src/main/java/com/jsoniter/spi/MapKeyDecoder.java
@@ -0,0 +1,5 @@
+package com.jsoniter.spi;
+
+public interface MapKeyDecoder {
+    Object decode(Slice mapKey);
+}
diff --git a/src/main/java/com/jsoniter/spi/Slice.java b/src/main/java/com/jsoniter/spi/Slice.java
@@ -1,4 +1,4 @@
-package com.jsoniter;
+package com.jsoniter.spi;
 
 public class Slice {
 
diff --git a/src/test/java/com/jsoniter/TestMap.java b/src/test/java/com/jsoniter/TestMap.java
diff --git a/src/test/java/com/jsoniter/TestSlice.java b/src/test/java/com/jsoniter/TestSlice.java
diff --git a/src/test/java/com/jsoniter/output/TestMap.java b/src/test/java/com/jsoniter/output/TestMap.java
diff --git a/src/test/java/com/jsoniter/suite/AllTestCases.java b/src/test/java/com/jsoniter/suite/AllTestCases.java

Original file line number	Diff line number	Diff line change
`@@ -160,12 +160,12 @@ private static Type chooseImpl(Type type) {`
`160`	`160`	`"can not bind to generic collection without argument types, " +`
`161`	`161`	`"try syntax like TypeLiteral<Map<String, String>>{}");`
`162`	`162`	`}`
`163`		`- if (keyType != String.class) {`
`164`		`- throw new IllegalArgumentException("map key must be String");`
`165`		`- }`
`166`	`163`	`if (clazz == Map.class) {`
`167`	`164`	`clazz = implClazz == null ? HashMap.class : implClazz;`
`168`	`165`	`}`
	`166`	`+ if (keyType == Object.class) {`
	`167`	`+ keyType = String.class;`
	`168`	`+ }`
`169`	`169`	`return new ParameterizedTypeImpl(new Type[]{keyType, valueType}, null, clazz);`
`170`	`170`	`}`
`171`	`171`	`if (implClazz != null) {`
Original file line number	Diff line number	Diff line change
`@@ -82,7 +82,7 @@ public static String genObjectUsingStrict(Class clazz, ClassDescriptor desc) {`
`82`	`82`	`if (desc.onExtraProperties != null) {`
`83`	`83`	`append(lines, "java.util.Map extra = null;");`
`84`	`84`	`}`
`85`		`- append(lines, "com.jsoniter.Slice field = com.jsoniter.CodegenAccess.readObjectFieldAsSlice(iter);");`
	`85`	`+ append(lines, "com.jsoniter.spi.Slice field = com.jsoniter.CodegenAccess.readObjectFieldAsSlice(iter);");`
`86`	`86`	`append(lines, "boolean once = true;");`
`87`	`87`	`append(lines, "while (once) {");`
`88`	`88`	`append(lines, "once = false;");`