More work with DeserializationProblemHandler; now allow handling of "weird number value"

Author: cowtowncoder

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

@@ -840,10 +840,12 @@ public boolean handleUnknownProperty(JsonParser p, JsonDeserializer<?> deser,
     }
 
     /**
-     * Method that deserializers should call if they encounter an unrecognized
-     * property (and once that is not explicitly designed as ignorable), to
-     * inform possibly configured {@link DeserializationProblemHandler}s and
-     * let it handle the problem.
+     * Method that deserializers should call if they encounter a String value
+     * that can not be converted to expected key of a {@link java.util.Map}
+     * valued property.
+     * Default implementation will try to call {@link DeserializationProblemHandler#handleWeirdNumberValue}
+     * on configured handlers, if any, to allow for recovery; if recovery does not
+     * succeed, will throw {@link InvalidFormatException} with given message.
      *
      * @param keyClass Expected type for key
      * @param keyValue String value from which to deserialize key
@@ -852,7 +854,7 @@ public boolean handleUnknownProperty(JsonParser p, JsonDeserializer<?> deser,
      *
      * @return Key value to use
      *
-     * @throws IOException
+     * @throws IOException To indicate unrecoverable problem, usually based on <code>msg</code>
      * 
      * @since 2.8
      */
@@ -876,6 +878,46 @@ public Object handleWeirdKey(Class<?> keyClass, String keyValue,
         throw weirdKeyException(keyClass, keyValue, msg);
     }
 
+    /**
+     * Method that deserializers should call if they encounter a numeric value
+     * that can not be converted to target property type, in cases where some
+     * numeric values could be acceptable (either with different settings,
+     * or different numeric value).
+     * Default implementation will try to call {@link DeserializationProblemHandler#handleWeirdNumberValue}
+     * on configured handlers, if any, to allow for recovery; if recovery does not
+     * succeed, will throw {@link InvalidFormatException} with given message.
+     *
+     * @param targetClass Type of property into which incoming number should be converted
+     * @param value Number value from which to deserialize property value
+     * @param msg Error message template caller wants to use if exception is to be thrown
+     * @param msgArgs Optional arguments to use for message, if any
+     *
+     * @return Property value to use
+     *
+     * @throws IOException To indicate unrecoverable problem, usually based on <code>msg</code>
+     * 
+     * @since 2.8
+     */
+    public Object handleWeirdNumberValue(Class<?> targetClass, Number value,
+            String msg, Object... msgArgs)
+        throws IOException
+    {
+        // but if not handled, just throw exception
+        if (msgArgs.length > 0) {
+            msg = String.format(msg, msgArgs);
+        }
+        LinkedNode<DeserializationProblemHandler> h = _config.getProblemHandlers();
+        while (h != null) {
+            // Can bail out if it's handled
+            Object key = h.value().handleWeirdNumberValue(this, targetClass, value, msg);
+            if (key != DeserializationProblemHandler.NOT_HANDLED) {
+                return key;
+            }
+            h = h.next();
+        }
+        throw weirdNumberException(value, targetClass, msg);
+    }
+    
     /**
      * @since 2.8
      */
@@ -968,19 +1010,6 @@ public void reportWeirdStringException(String value, Class<?> instClass,
         throw weirdStringException(value, instClass, msg);
     }
 
-    /**
-     * @since 2.8
-     */
-    public void reportWeirdNumberException(Number value, Class<?> instClass,
-            String msg, Object... msgArgs)
-        throws JsonMappingException
-    {
-        if (msgArgs.length > 0) {
-            msg = String.format(msg, msgArgs);
-        }
-        throw weirdNumberException(value, instClass, msg);
-    }
-
     /**
      * @since 2.8
      */
@@ -1081,6 +1110,9 @@ public JsonMappingException mappingException(String msgTemplate, Object... args)
      * Helper method for constructing exception to indicate that given JSON
      * Object field name was not in format to be able to deserialize specified
      * key type.
+     * Note that most of the time this method should NOT be called; instead,
+     * {@link #handleWeirdKey} should be called which will call this method
+     * if necessary, but may also use overrides.
      */
     public JsonMappingException weirdKeyException(Class<?> keyClass, String keyValue,
             String msg) {
@@ -1090,6 +1122,18 @@ public JsonMappingException weirdKeyException(Class<?> keyClass, String keyValue
                 keyValue, keyClass);
     }
 
+    /**
+     * Helper method for constructing exception to indicate that input JSON
+     * Number was not suitable for deserializing into given target type.
+     */
+    public JsonMappingException weirdNumberException(Number value, Class<?> instClass,
+            String msg) {
+        return InvalidFormatException.from(_parser,
+                String.format("Can not deserialize value of type %s from number %s: %s",
+                        instClass.getName(), String.valueOf(value), msg),
+                value, instClass);
+    }
+    
     /**
      * Helper method for constructing exception to indicate that given JSON
      * Object field name was not in format to be able to deserialize specified
@@ -1157,21 +1201,6 @@ public JsonMappingException weirdStringException(String value, Class<?> instClas
                 value, instClass);
     }
 
-    /**
-     * Helper method for constructing exception to indicate that input JSON
-     * Number was not suitable for deserializing into given target type.
-     *
-     * @deprecated Since 2.8 use {@link #reportWeirdNumberException} instead
-     */
-    @Deprecated
-    public JsonMappingException weirdNumberException(Number value, Class<?> instClass,
-            String msg) {
-        return InvalidFormatException.from(_parser,
-                String.format("Can not deserialize value of type %s from number %s: %s",
-                        instClass.getName(), String.valueOf(value), msg),
-                value, instClass);
-    }
-
     /**
      * Helper method for indicating that the current token was expected to be another
      * token.

src/main/java/com/fasterxml/jackson/databind/deser/DeserializationProblemHandler.java

@@ -104,6 +104,40 @@ public Object handleWeirdKey(DeserializationContext ctxt,
         return NOT_HANDLED;
     }
 
+    /**
+     * Method called when a number value (integral or floating-point from input
+     * can not be converted to a non-numeric value type due to specific problem
+     * (as opposed to numeric values never being usable).
+     * Handler may choose to do one of 3 things:
+     *<ul>
+     * <li>Indicate it does not know what to do by returning {@link #NOT_HANDLED}
+     *  </li>
+     * <li>Throw a {@link IOException} to indicate specific fail message (instead of
+     *    standard exception caller would throw
+     *  </li>
+     * <li>Return actual converted value (of type <code>targetType</code> to use as
+     *    replacement, and continue processing.
+     *  </li>
+     * </ul>
+     *
+     * @param failureMsg Message that will be used by caller (by calling
+     *    {@link DeserializationContext#weirdNumberException})
+     *    to indicate type of failure unless handler produces key to use
+     *
+     * @return Either {@link #NOT_HANDLED} to indicate that handler does not know
+     *    what to do (and exception may be thrown), or value to use as key (possibly
+     *    <code>null</code>
+     *
+     * @since 2.8
+     */
+    public Object handleWeirdNumberValue(DeserializationContext ctxt,
+            Class<?> targetType, Number valueToConvert,
+            String failureMsg)
+        throws IOException
+    {
+        return NOT_HANDLED;
+    }
+    
     /**
      * Handler method called if resolution of type id from given String failed
      * to produce a subtype; usually because logical id is not mapped to actual

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

@@ -132,8 +132,9 @@ public Object deserialize(JsonParser p, DeserializationContext ctxt) throws IOEx
             // ... unless told not to do that
             int index = p.getIntValue();
             if (ctxt.isEnabled(DeserializationFeature.FAIL_ON_NUMBERS_FOR_ENUMS)) {
-                _failOnNumber(ctxt, p, index);
-                return null;
+                return ctxt.handleWeirdNumberValue(_enumClass(), index,
+                        "not allowed to deserialize Enum value out of number: disable DeserializationConfig.DeserializationFeature.FAIL_ON_NUMBERS_FOR_ENUMS to allow"
+                        );
             }
             if (index >= 0 && index <= _enumsByIndex.length) {
                 return _enumsByIndex[index];
@@ -143,10 +144,9 @@ public Object deserialize(JsonParser p, DeserializationContext ctxt) throws IOEx
                 return _enumDefaultValue;
             }
             if (!ctxt.isEnabled(DeserializationFeature.READ_UNKNOWN_ENUM_VALUES_AS_NULL)) {
-                ctxt.reportWeirdNumberException(index, _enumClass(),
+                return ctxt.handleWeirdNumberValue(_enumClass(), index,
                         "index value outside legal index range [0..%s]",
                         _enumsByIndex.length-1);
-                // fall through, if nothing thrown immediately
             }
             return null;
         }
@@ -172,13 +172,14 @@ private final Object _deserializeAltString(JsonParser p, DeserializationContext
             char c = name.charAt(0);
             if (c >= '0' && c <= '9') {
                 try {
-                    int ix = Integer.parseInt(name);
+                    int index = Integer.parseInt(name);
                     if (ctxt.isEnabled(DeserializationFeature.FAIL_ON_NUMBERS_FOR_ENUMS)) {
-                        _failOnNumber(ctxt, p, ix);
-                        return null;
+                        return ctxt.handleWeirdNumberValue(_enumClass(), index,
+                                "not allowed to deserialize Enum value out of number: disable DeserializationConfig.DeserializationFeature.FAIL_ON_NUMBERS_FOR_ENUMS to allow"
+                                );
                     }
-                    if (ix >= 0 && ix <= _enumsByIndex.length) {
-                        return _enumsByIndex[ix];
+                    if (index >= 0 && index <= _enumsByIndex.length) {
+                        return _enumsByIndex[index];
                     }
                 } catch (NumberFormatException e) {
                     // fine, ignore, was not an integer
@@ -215,14 +216,6 @@ protected Object _deserializeOther(JsonParser p, DeserializationContext ctxt) th
         return null;
     }
 
-    protected void _failOnNumber(DeserializationContext ctxt, JsonParser p, int index)
-        throws IOException
-    {
-        ctxt.reportWeirdNumberException(index, _enumClass(),
-                "not allowed to deserialize Enum value out of number: disable DeserializationConfig.DeserializationFeature.FAIL_ON_NUMBERS_FOR_ENUMS to allow"
-                );
-    }
-
     protected Class<?> _enumClass() {
         return handledType();
     }

src/test/java/com/fasterxml/jackson/databind/BaseTest.java

@@ -290,22 +290,21 @@ protected JsonParser createParserUsingReader(String input)
     }
 
     protected JsonParser createParserUsingReader(JsonFactory f, String input)
-        throws IOException, JsonParseException
+        throws IOException
     {
         return f.createParser(new StringReader(input));
     }
 
     protected JsonParser createParserUsingStream(String input, String encoding)
-        throws IOException, JsonParseException
+        throws IOException
     {
         return createParserUsingStream(new JsonFactory(), input, encoding);
     }
 
     protected JsonParser createParserUsingStream(JsonFactory f,
-                                                 String input, String encoding)
-        throws IOException, JsonParseException
+            String input, String encoding)
+        throws IOException
     {
-
         /* 23-Apr-2008, tatus: UTF-32 is not supported by JDK, have to
          *   use our own codec too (which is not optimal since there's
          *   a chance both encoder and decoder might have bugs, but ones

src/test/java/com/fasterxml/jackson/databind/TestFormatSchema.java

@@ -122,11 +122,6 @@ public ObjectCodec getCodec() {
         @Override
         public void setCodec(ObjectCodec c) { }
 
-        @Override
-        protected boolean loadMore() throws IOException {
-            return false;
-        }
-
         @Override
         protected void _closeInput() throws IOException {
         }

src/test/java/com/fasterxml/jackson/databind/filter/ProblemHandlerTest.java

@@ -34,6 +34,25 @@ public Object handleWeirdKey(DeserializationContext ctxt,
         }
     }
 
+    static class WeirdNumberHandler
+        extends DeserializationProblemHandler
+    {
+        protected final Object value;
+
+        public WeirdNumberHandler(Object v0) {
+            value = v0;
+        }
+
+        @Override
+        public Object handleWeirdNumberValue(DeserializationContext ctxt,
+                Class<?> targetType, Number n,
+                String failureMsg)
+            throws IOException
+        {
+            return value;
+        }
+    }
+    
     static class IntKeyMapWrapper {
         public Map<Integer,String> stuff;
     }
@@ -61,6 +80,10 @@ static class BaseWrapper {
         public Base value;
     }
 
+    enum SingleValuedEnum {
+        A;
+    }
+
     /*
     /**********************************************************
     /* Test methods
@@ -81,6 +104,15 @@ public void testWeirdKeyHandling() throws Exception
         assertEquals(Integer.valueOf(7), map.keySet().iterator().next());
     }
 
+    public void testWeirdNumberHandling() throws Exception
+    {
+        ObjectMapper mapper = new ObjectMapper()
+            .addHandler(new WeirdNumberHandler(SingleValuedEnum.A))
+            ;
+        SingleValuedEnum result = mapper.readValue("3", SingleValuedEnum.class);
+        assertEquals(SingleValuedEnum.A, result);
+    }
+
     public void testInvalidTypeId() throws Exception
     {
         ObjectMapper mapper = new ObjectMapper()