Replace EnumResolver usage for deserialization with specialized map

Author: cowtowncoder

src/main/java/com/fasterxml/jackson/databind/deser/std/EnumDeserializer.java

@@ -10,6 +10,7 @@
 import com.fasterxml.jackson.databind.introspect.AnnotatedMethod;
 import com.fasterxml.jackson.databind.jsontype.TypeDeserializer;
 import com.fasterxml.jackson.databind.util.ClassUtil;
+import com.fasterxml.jackson.databind.util.CompactStringObjectMap;
 import com.fasterxml.jackson.databind.util.EnumResolver;
 
 /**
@@ -22,12 +23,21 @@ public class EnumDeserializer
 {
     private static final long serialVersionUID = 1L;
 
-    protected final EnumResolver _resolver;
-    
+    /**
+     * @since 2.6
+     */
+    protected final CompactStringObjectMap _enumLookup;
+
+    /**
+     * @since 2.6
+     */
+    protected Object[] _enumsByIndex;
+
     public EnumDeserializer(EnumResolver res)
     {
-        super(Enum.class);
-        _resolver = res;
+        super(res.getEnumClass());
+        _enumLookup = res.constructLookup();
+        _enumsByIndex = res.getRawEnums();
     }
 
     /**
@@ -69,7 +79,7 @@ public Object deserialize(JsonParser p, DeserializationContext ctxt) throws IOEx
         // Usually should just get string value:
         if (curr == JsonToken.VALUE_STRING || curr == JsonToken.FIELD_NAME) {
             String name = p.getText();
-            Enum<?> result = _resolver.findEnum(name);
+            Object result = _enumLookup.find(name);
             if (result == null) {
                 return _deserializeAltString(p, ctxt, name);
             }
@@ -81,17 +91,19 @@ public Object deserialize(JsonParser p, DeserializationContext ctxt) throws IOEx
             _checkFailOnNumber(ctxt);
 
             int index = p.getIntValue();
-            Enum<?> result = _resolver.getEnum(index);
-            if (result == null && !ctxt.isEnabled(DeserializationFeature.READ_UNKNOWN_ENUM_VALUES_AS_NULL)) {
-                throw ctxt.weirdNumberException(Integer.valueOf(index), _resolver.getEnumClass(),
-                        "index value outside legal index range [0.."+_resolver.lastValidIndex()+"]");
+            if (index >= 0 && index <= _enumsByIndex.length) {
+                return _enumsByIndex[index];
             }
-            return result;
+            if (!ctxt.isEnabled(DeserializationFeature.READ_UNKNOWN_ENUM_VALUES_AS_NULL)) {
+                throw ctxt.weirdNumberException(Integer.valueOf(index), _enumClass(),
+                        "index value outside legal index range [0.."+(_enumsByIndex.length-1)+"]");
+            }
+            return null;
         }
         return _deserializeOther(p, ctxt);
     }
 
-    private final Enum<?> _deserializeAltString(JsonParser p, DeserializationContext ctxt,
+    private final Object _deserializeAltString(JsonParser p, DeserializationContext ctxt,
             String name) throws IOException
     {
         name = name.trim();
@@ -106,18 +118,17 @@ private final Enum<?> _deserializeAltString(JsonParser p, DeserializationContext
                 try {
                     int ix = Integer.parseInt(name);
                     _checkFailOnNumber(ctxt);
-                    Enum<?> result = _resolver.getEnum(ix);
-                    if (result != null) {
-                        return result;
+                    if (ix >= 0 && ix <= _enumsByIndex.length) {
+                        return _enumsByIndex[ix];
                     }
                 } catch (NumberFormatException e) {
                     // fine, ignore, was not an integer
                 }
             }
         }
         if (!ctxt.isEnabled(DeserializationFeature.READ_UNKNOWN_ENUM_VALUES_AS_NULL)) {
-            throw ctxt.weirdStringException(name, _resolver.getEnumClass(),
-                    "value not one of declared Enum instance names: "+_resolver.getEnums());
+            throw ctxt.weirdStringException(name, _enumClass(),
+                    "value not one of declared Enum instance names: "+_enumLookup.keys());
         }
         return null;
     }
@@ -132,11 +143,11 @@ protected Object _deserializeOther(JsonParser p, DeserializationContext ctxt) th
             curr = p.nextToken();
             if (curr != JsonToken.END_ARRAY) {
                 throw ctxt.wrongTokenException(p, JsonToken.END_ARRAY,
-                        "Attempted to unwrap single value array for single '" + _resolver.getEnumClass().getName() + "' value but there was more than a single value in the array");
+                        "Attempted to unwrap single value array for single '" + _enumClass().getName() + "' value but there was more than a single value in the array");
             }
             return parsed;
         }
-        throw ctxt.mappingException(_resolver.getEnumClass());
+        throw ctxt.mappingException(_enumClass());
     }
 
     protected void _checkFailOnNumber(DeserializationContext ctxt) throws IOException
@@ -146,6 +157,10 @@ protected void _checkFailOnNumber(DeserializationContext ctxt) throws IOExceptio
         }
     }
 
+    protected Class<?> _enumClass() {
+        return handledType();
+    }
+
     /*
     /**********************************************************
     /* Additional helper classes

src/main/java/com/fasterxml/jackson/databind/util/CompactStringObjectMap.java

@@ -17,74 +17,57 @@
 public abstract class CompactStringObjectMap
 {
     public static CompactStringObjectMap empty() {
-        return Empty.instance;
+        return Small.EMPTY;
     }
 
     public static <T> CompactStringObjectMap construct(Map<String,T> contents)
     {
         if (contents.size() == 0) { // can this occur?
-            return Empty.instance;
+            return empty();
         }
         Iterator<Map.Entry<String,T>> it = contents.entrySet().iterator();
         switch (contents.size()) {
         case 1:
-            return new Small1(it.next());
+            return new Small(it.next(), null);
         case 2:
-            return new Small2(it.next(), it.next());
+            return new Small(it.next(), it.next());
         }
         // General-purpose "big" one needed:
         return Big.construct(contents);
     }
 
-    public abstract Object findField(String key);
+    public abstract Object find(String key);
 
-    static class Empty extends CompactStringObjectMap {
-        public final static Empty instance = new Empty();
-
-        private Empty() {
-            super();
-        }
-
-        @Override
-        public Object findField(String key) {
-            return null;
-        }
-    }
-
-    static class Small1 extends CompactStringObjectMap
-    {
-        protected final String key1;
-        protected final Object value1;
-
-        private Small1(Map.Entry<String,?> entry) {
-            key1 = entry.getKey();
-            value1 = entry.getValue();
-        }
-
-        @Override
-        public Object findField(String key) {
-            if (key == key1 || key.equals(key1)) {
-                return value1;
-            }
-            return null;
-        }
-    }
-
-    final static class Small2 extends CompactStringObjectMap
+    public abstract List<String> keys();
+    
+    final static class Small extends CompactStringObjectMap
     {
+        public final static Small EMPTY = new Small(null, null);
+        
         protected final String key1, key2;
         protected final Object value1, value2;
 
-        private Small2(Map.Entry<String,?> e1, Map.Entry<String,?> e2)
+        private Small(Map.Entry<String,?> e1, Map.Entry<String,?> e2)
         {
-            key1 = e1.getKey();
-            value1 = e1.getValue();
-            key2 = e2.getKey();
-            value2 = e2.getValue();
+            if (e1 == null) {
+                key1 = null;
+                value1 = null;
+            } else {
+                key1 = e1.getKey();
+                value1 = e1.getValue();
+            }
+            if (e2 == null) {
+                key2 = null;
+                value2 = null;
+            } else {
+                key2 = e2.getKey();
+                value2 = e2.getValue();
+            }
         }
 
         @Override
-        public Object findField(String key) {
+        public Object find(String key) {
+            // no assumption of key being intern()ed:
             if (key.equals(key1)) {
                 return value1;
             }
@@ -93,7 +76,19 @@ public Object findField(String key) {
             }
             return null;
         }
-    }
+
+        @Override
+        public List<String> keys() {
+            ArrayList<String> keys = new ArrayList<String>(2);
+            if (key1 != null) {
+                keys.add(key1);
+            }
+            if (key2 != null) {
+                keys.add(key2);
+            }
+            return keys;
+        }
+}
 
     /**
      * Raw mapping from keys to indices, optimized for fast access via
@@ -151,8 +146,24 @@ public static <T> Big construct(Map<String,T> all)
             return new Big(mask, spills, keys, fieldHash);
         }
 
+        private final static int findSize(int size)
+        {
+            if (size <= 5) {
+                return 8;
+            }
+            if (size <= 12) {
+                return 16;
+            }
+            int needed = size + (size >> 2); // at most 80% full
+            int result = 32;
+            while (result < needed) {
+                result += result;
+            }
+            return result;
+        }
+        
         @Override
-        public Object findField(String key) {
+        public Object find(String key) {
             int slot = key.hashCode() & _hashMask;
             String match = _keys[slot];
             if ((match == key) || key.equals(match)) {
@@ -171,22 +182,6 @@ public Object findField(String key) {
             return _findFromSpill(key);
         }
 
-        private final static int findSize(int size)
-        {
-            if (size <= 5) {
-                return 8;
-            }
-            if (size <= 12) {
-                return 16;
-            }
-            int needed = size + (size >> 2); // at most 80% full
-            int result = 32;
-            while (result < needed) {
-                result += result;
-            }
-            return result;
-        }
-
         private Object _findFromSpill(String key) {
             int hashSize = _hashMask+1;
             int i = hashSize + (hashSize>>1);
@@ -197,5 +192,16 @@ private Object _findFromSpill(String key) {
             }
             return null;
         }
-    }    
+
+        @Override
+        public List<String> keys() {
+            List<String> keys = new ArrayList<String>(_keys.length >> 1);
+            for (String key : _keys) {
+                if (key != null) {
+                    keys.add(key);
+                }
+            }
+            return keys;
+        }
+}    
 }

src/main/java/com/fasterxml/jackson/databind/util/EnumResolver.java

@@ -116,6 +116,10 @@ public static EnumResolver constructUnsafeUsingMethod(Class<?> rawEnumCls, Metho
         Class<Enum<?>> enumCls = (Class<Enum<?>>) rawEnumCls;
         return constructUsingMethod(enumCls, accessor);
     }
+
+    public CompactStringObjectMap constructLookup() {
+        return CompactStringObjectMap.construct(_enumsById);
+    }
 
     public Enum<?> findEnum(String key) { return _enumsById.get(key); }
 
@@ -126,6 +130,10 @@ public Enum<?> getEnum(int index) {
         return _enums[index];
     }
 
+    public Enum<?>[] getRawEnums() {
+        return _enums;
+    }
+    
     public List<Enum<?>> getEnums() {
         ArrayList<Enum<?>> enums = new ArrayList<Enum<?>>(_enums.length);
         for (Enum<?> e : _enums) {