decode integer key

taowen · taowen · commit bc9681c69401 · 2018-02-24T21:27:48.000+08:00
diff --git a/src/main/java/com/jsoniter/Codegen.java b/src/main/java/com/jsoniter/Codegen.java
@@ -171,7 +171,7 @@ private static Type chooseImpl(Type type) {
             if (keyType == Object.class) {
                 keyType = String.class;
             }
-            DefaultMapKeyDecoder.registerOrGetExisting(keyType);
+            MapKeyDecoders.registerOrGetExisting(keyType);
             return GenericsHelper.createParameterizedType(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
@@ -142,9 +142,8 @@ public static final Slice readSlice(JsonIterator iter) throws IOException {
     }
 
     public static final Object readMapKey(String cacheKey, JsonIterator iter) throws IOException {
-        Slice encodedMapKey = readObjectFieldAsSlice(iter);
-        MapKeyDecoder mapKeyDecoder = JsoniterSpi.getMapKeyDecoder(cacheKey);
-        return mapKeyDecoder.decode(encodedMapKey);
+        Decoder mapKeyDecoder = JsoniterSpi.getMapKeyDecoder(cacheKey);
+        return mapKeyDecoder.decode(iter);
     }
 
     final static boolean skipWhitespacesWithoutLoadMore(JsonIterator iter) throws IOException {
diff --git a/src/main/java/com/jsoniter/DefaultMapKeyDecoder.java b/src/main/java/com/jsoniter/DefaultMapKeyDecoder.java
diff --git a/src/main/java/com/jsoniter/MapKeyDecoders.java b/src/main/java/com/jsoniter/MapKeyDecoders.java
@@ -0,0 +1,60 @@
+package com.jsoniter;
+
+import com.jsoniter.spi.*;
+
+import java.io.IOException;
+import java.lang.reflect.Type;
+
+class MapKeyDecoders {
+
+    public static Decoder registerOrGetExisting(Type mapKeyType) {
+        String cacheKey = JsoniterSpi.getMapKeyDecoderCacheKey(mapKeyType);
+        Decoder mapKeyDecoder = JsoniterSpi.getMapKeyDecoder(cacheKey);
+        if (null != mapKeyDecoder) {
+            return mapKeyDecoder;
+        }
+        mapKeyDecoder = createMapKeyDecoder(mapKeyType);
+        JsoniterSpi.addNewMapDecoder(cacheKey, mapKeyDecoder);
+        return mapKeyDecoder;
+    }
+
+    private static Decoder createMapKeyDecoder(Type mapKeyType) {
+        if (String.class == mapKeyType) {
+            return new StringKeyDecoder();
+        }
+        Decoder decoder = CodegenImplNative.NATIVE_DECODERS.get(mapKeyType);
+        if (decoder != null) {
+            return new NumberKeyDecoder(decoder);
+        }
+        throw new JsonException("can not encode map key type: " + mapKeyType);
+    }
+
+    private static class StringKeyDecoder implements Decoder {
+
+        @Override
+        public Object decode(JsonIterator iter) throws IOException {
+            return iter.readString();
+        }
+    }
+
+    private static class NumberKeyDecoder implements Decoder {
+
+        private final Decoder decoder;
+
+        private NumberKeyDecoder(Decoder decoder) {
+            this.decoder = decoder;
+        }
+
+        @Override
+        public Object decode(JsonIterator iter) throws IOException {
+            if (IterImpl.nextToken(iter) != '"') {
+                throw iter.reportError("decode number map key", "expect \"");
+            }
+            Object key = decoder.decode(iter);
+            if (IterImpl.nextToken(iter) != '"') {
+                throw iter.reportError("decode number map key", "expect \"");
+            }
+            return key;
+        }
+    }
+}
diff --git a/src/main/java/com/jsoniter/ReflectionMapDecoder.java b/src/main/java/com/jsoniter/ReflectionMapDecoder.java
@@ -11,7 +11,7 @@ class ReflectionMapDecoder implements Decoder {
 
     private final Constructor ctor;
     private final Decoder valueTypeDecoder;
-    private final MapKeyDecoder mapKeyDecoder;
+    private final Decoder mapKeyDecoder;
 
     public ReflectionMapDecoder(Class clazz, Type[] typeArgs) {
         try {
@@ -20,11 +20,7 @@ public ReflectionMapDecoder(Class clazz, Type[] typeArgs) {
             throw new JsonException(e);
         }
         Type keyType = typeArgs[0];
-        if (keyType == String.class) {
-            mapKeyDecoder = null;
-        } else {
-            mapKeyDecoder = DefaultMapKeyDecoder.registerOrGetExisting(keyType);
-        }
+        mapKeyDecoder = MapKeyDecoders.registerOrGetExisting(keyType);
         TypeLiteral valueTypeLiteral = TypeLiteral.create(typeArgs[1]);
         valueTypeDecoder = Codegen.getDecoder(valueTypeLiteral.getDecoderCacheKey(), typeArgs[1]);
     }
@@ -59,11 +55,10 @@ private Object decode_(JsonIterator iter) throws Exception {
     }
 
     private Object readMapKey(JsonIterator iter) throws IOException {
-        if (mapKeyDecoder == null) {
-            return CodegenAccess.readObjectFieldAsString(iter);
-        } else {
-            Slice mapKey = CodegenAccess.readObjectFieldAsSlice(iter);
-            return mapKeyDecoder.decode(mapKey);
+        Object key = mapKeyDecoder.decode(iter);
+        if (':' != IterImpl.nextToken(iter)) {
+            throw iter.reportError("readMapKey", "expect :");
         }
+        return key;
     }
 }
diff --git a/src/main/java/com/jsoniter/output/MapKeyEncoders.java b/src/main/java/com/jsoniter/output/MapKeyEncoders.java
@@ -25,10 +25,9 @@ private static Encoder createDefaultEncoder(Type mapKeyType) {
         if (mapKeyType == Object.class) {
             return new DynamicKeyEncoder();
         }
-        if (mapKeyType instanceof Class) {
-            if (Number.class.isAssignableFrom((Class<?>) mapKeyType)) {
-                return new NumberKeyEncoder();
-            }
+        Encoder.ReflectionEncoder encoder = CodegenImplNative.NATIVE_ENCODERS.get(mapKeyType);
+        if (encoder != null) {
+            return new NumberKeyEncoder(encoder);
         }
         throw new JsonException("can not encode map key type: " + mapKeyType);
     }
@@ -43,10 +42,16 @@ public void encode(Object obj, JsonStream stream) throws IOException {
 
     private static class NumberKeyEncoder implements Encoder {
 
+        private final Encoder encoder;
+
+        private NumberKeyEncoder(Encoder encoder) {
+            this.encoder = encoder;
+        }
+
         @Override
         public void encode(Object obj, JsonStream stream) throws IOException {
             stream.write('"');
-            stream.writeVal(obj);
+            encoder.encode(obj, stream);
             stream.write('"');
         }
     }
diff --git a/src/main/java/com/jsoniter/spi/JsoniterSpi.java b/src/main/java/com/jsoniter/spi/JsoniterSpi.java
@@ -12,7 +12,7 @@ public class JsoniterSpi {
     private static Config defaultConfig;
     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, Decoder> globalMapKeyDecoders = new HashMap<Type, Decoder>();
     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>();
@@ -28,7 +28,7 @@ protected Config initialValue() {
     };
     private static volatile Map<Object, String> configNames = new HashMap<Object, String>();
     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, Decoder> mapKeyDecoders = new HashMap<String, Decoder>();
     private static volatile Map<String, Encoder> encoders = new HashMap<String, Encoder>();
     private static volatile Map<String, Decoder> decoders = new HashMap<String, Decoder>();
     private static volatile Map<Class, Extension> objectFactories = new HashMap<Class, Extension>();
@@ -98,7 +98,7 @@ public static List<Extension> getExtensions() {
         return combined;
     }
 
-    public static void registerMapKeyDecoder(Type mapKeyType, MapKeyDecoder mapKeyDecoder) {
+    public static void registerMapKeyDecoder(Type mapKeyType, Decoder mapKeyDecoder) {
         globalMapKeyDecoders.put(mapKeyType, mapKeyDecoder);
         copyGlobalMapKeyDecoder(getCurrentConfig().configName(), mapKeyType, mapKeyDecoder);
     }
@@ -159,7 +159,7 @@ public static void registerPropertyEncoder(TypeLiteral typeLiteral, String prope
     // === copy from global to current ===
 
     private static void copyGlobalSettings(String configName) {
-        for (Map.Entry<Type, MapKeyDecoder> entry : globalMapKeyDecoders.entrySet()) {
+        for (Map.Entry<Type, Decoder> entry : globalMapKeyDecoders.entrySet()) {
             copyGlobalMapKeyDecoder(configName, entry.getKey(), entry.getValue());
         }
         for (Map.Entry<Type, Encoder> entry : globalMapKeyEncoders.entrySet()) {
@@ -196,7 +196,7 @@ private static void copyGlobalTypeDecoder(String configName, Type type, Decoder
         addNewDecoder(TypeLiteral.create(type).getDecoderCacheKey(configName), typeDecoder);
     }
 
-    private static void copyGlobalMapKeyDecoder(String configName, Type mapKeyType, MapKeyDecoder mapKeyDecoder) {
+    private static void copyGlobalMapKeyDecoder(String configName, Type mapKeyType, Decoder mapKeyDecoder) {
         addNewMapDecoder(TypeLiteral.create(mapKeyType).getDecoderCacheKey(configName), mapKeyDecoder);
     }
 
@@ -216,13 +216,13 @@ public static String getMapKeyDecoderCacheKey(Type mapKeyType) {
 
     // === current ===
 
-    public synchronized static void addNewMapDecoder(String cacheKey, MapKeyDecoder mapKeyDecoder) {
-        HashMap<String, MapKeyDecoder> newCache = new HashMap<String, MapKeyDecoder>(mapKeyDecoders);
+    public synchronized static void addNewMapDecoder(String cacheKey, Decoder mapKeyDecoder) {
+        HashMap<String, Decoder> newCache = new HashMap<String, Decoder>(mapKeyDecoders);
         newCache.put(cacheKey, mapKeyDecoder);
         mapKeyDecoders = newCache;
     }
 
-    public static MapKeyDecoder getMapKeyDecoder(String cacheKey) {
+    public static Decoder getMapKeyDecoder(String cacheKey) {
         return mapKeyDecoders.get(cacheKey);
     }
 
diff --git a/src/main/java/com/jsoniter/spi/MapKeyDecoder.java b/src/main/java/com/jsoniter/spi/MapKeyDecoder.java
diff --git a/src/test/java/com/jsoniter/TestMap.java b/src/test/java/com/jsoniter/TestMap.java
@@ -44,12 +44,11 @@ public static class TestObject1 {
     }
 
     public void test_MapKeyCodec() {
-        JsoniterSpi.registerMapKeyDecoder(TestObject1.class, new MapKeyDecoder() {
+        JsoniterSpi.registerMapKeyDecoder(TestObject1.class, new Decoder() {
             @Override
-            public Object decode(Slice encodedMapKey) {
-                Integer field = Integer.valueOf(encodedMapKey.toString());
+            public Object decode(JsonIterator iter) throws IOException {
                 TestObject1 obj = new TestObject1();
-                obj.Field = field;
+                obj.Field = Integer.valueOf(iter.readString());
                 return obj;
             }
         });

Original file line number	Diff line number	Diff line change
`@@ -171,7 +171,7 @@ private static Type chooseImpl(Type type) {`
`171`	`171`	`if (keyType == Object.class) {`
`172`	`172`	`keyType = String.class;`
`173`	`173`	`}`
`174`		`- DefaultMapKeyDecoder.registerOrGetExisting(keyType);`
	`174`	`+ MapKeyDecoders.registerOrGetExisting(keyType);`
`175`	`175`	`return GenericsHelper.createParameterizedType(new Type[]{keyType, valueType}, null, clazz);`
`176`	`176`	`}`
`177`	`177`	`if (implClazz != null) {`
Original file line number	Diff line number	Diff line change
`@@ -142,9 +142,8 @@ public static final Slice readSlice(JsonIterator iter) throws IOException {`
`142`	`142`	`}`
`143`	`143`
`144`	`144`	`public static final Object readMapKey(String cacheKey, JsonIterator iter) throws IOException {`
`145`		`- Slice encodedMapKey = readObjectFieldAsSlice(iter);`
`146`		`- MapKeyDecoder mapKeyDecoder = JsoniterSpi.getMapKeyDecoder(cacheKey);`
`147`		`- return mapKeyDecoder.decode(encodedMapKey);`
	`145`	`+ Decoder mapKeyDecoder = JsoniterSpi.getMapKeyDecoder(cacheKey);`
	`146`	`+ return mapKeyDecoder.decode(iter);`
`148`	`147`	`}`
`149`	`148`
`150`	`149`	`final static boolean skipWhitespacesWithoutLoadMore(JsonIterator iter) throws IOException {`
Original file line number	Diff line number	Diff line change
`@@ -11,7 +11,7 @@ class ReflectionMapDecoder implements Decoder {`
`11`	`11`
`12`	`12`	`private final Constructor ctor;`
`13`	`13`	`private final Decoder valueTypeDecoder;`
`14`		`- private final MapKeyDecoder mapKeyDecoder;`
	`14`	`+ private final Decoder mapKeyDecoder;`
`15`	`15`
`16`	`16`	`public ReflectionMapDecoder(Class clazz, Type[] typeArgs) {`
`17`	`17`	`try {`
`@@ -20,11 +20,7 @@ public ReflectionMapDecoder(Class clazz, Type[] typeArgs) {`
`20`	`20`	`throw new JsonException(e);`
`21`	`21`	`}`
`22`	`22`	`Type keyType = typeArgs[0];`
`23`		`- if (keyType == String.class) {`
`24`		`- mapKeyDecoder = null;`
`25`		`- } else {`
`26`		`- mapKeyDecoder = DefaultMapKeyDecoder.registerOrGetExisting(keyType);`
`27`		`- }`
	`23`	`+ mapKeyDecoder = MapKeyDecoders.registerOrGetExisting(keyType);`
`28`	`24`	`TypeLiteral valueTypeLiteral = TypeLiteral.create(typeArgs[1]);`
`29`	`25`	`valueTypeDecoder = Codegen.getDecoder(valueTypeLiteral.getDecoderCacheKey(), typeArgs[1]);`
`30`	`26`	`}`
`@@ -59,11 +55,10 @@ private Object decode_(JsonIterator iter) throws Exception {`
`59`	`55`	`}`
`60`	`56`
`61`	`57`	`private Object readMapKey(JsonIterator iter) throws IOException {`
`62`		`- if (mapKeyDecoder == null) {`
`63`		`- return CodegenAccess.readObjectFieldAsString(iter);`
`64`		`- } else {`
`65`		`- Slice mapKey = CodegenAccess.readObjectFieldAsSlice(iter);`
`66`		`- return mapKeyDecoder.decode(mapKey);`
	`58`	`+ Object key = mapKeyDecoder.decode(iter);`
	`59`	`+ if (':' != IterImpl.nextToken(iter)) {`
	`60`	`+ throw iter.reportError("readMapKey", "expect :");`
`67`	`61`	`}`
	`62`	`+ return key;`
`68`	`63`	`}`
`69`	`64`	`}`
Original file line number	Diff line number	Diff line change
`@@ -25,10 +25,9 @@ private static Encoder createDefaultEncoder(Type mapKeyType) {`
`25`	`25`	`if (mapKeyType == Object.class) {`
`26`	`26`	`return new DynamicKeyEncoder();`
`27`	`27`	`}`
`28`		`- if (mapKeyType instanceof Class) {`
`29`		`- if (Number.class.isAssignableFrom((Class<?>) mapKeyType)) {`
`30`		`- return new NumberKeyEncoder();`
`31`		`- }`
	`28`	`+ Encoder.ReflectionEncoder encoder = CodegenImplNative.NATIVE_ENCODERS.get(mapKeyType);`
	`29`	`+ if (encoder != null) {`
	`30`	`+ return new NumberKeyEncoder(encoder);`
`32`	`31`	`}`
`33`	`32`	`throw new JsonException("can not encode map key type: " + mapKeyType);`
`34`	`33`	`}`
`@@ -43,10 +42,16 @@ public void encode(Object obj, JsonStream stream) throws IOException {`
`43`	`42`
`44`	`43`	`private static class NumberKeyEncoder implements Encoder {`
`45`	`44`
	`45`	`+ private final Encoder encoder;`
	`46`	`+`
	`47`	`+ private NumberKeyEncoder(Encoder encoder) {`
	`48`	`+ this.encoder = encoder;`
	`49`	`+ }`
	`50`	`+`
`46`	`51`	`@Override`
`47`	`52`	`public void encode(Object obj, JsonStream stream) throws IOException {`
`48`	`53`	`stream.write('"');`
`49`		`- stream.writeVal(obj);`
	`54`	`+ encoder.encode(obj, stream);`
`50`	`55`	`stream.write('"');`
`51`	`56`	`}`
`52`	`57`	`}`