Add DeserializationProblemHandler.handleWeirdStringValue(...) to allow recovering from JSON String value problems

Author: cowtowncoder

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

@@ -878,6 +878,46 @@ public Object handleWeirdKey(Class<?> keyClass, String keyValue,
         throw weirdKeyException(keyClass, keyValue, msg);
     }
 
+    /**
+     * Method that deserializers should call if they encounter a String value
+     * that can not be converted to target property type, in cases where some
+     * String values could be acceptable (either with different settings,
+     * or different value).
+     * Default implementation will try to call {@link DeserializationProblemHandler#handleWeirdStringValue}
+     * 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 String 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 handleWeirdStringValue(Class<?> targetClass, String 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().handleWeirdStringValue(this, targetClass, value, msg);
+            if (key != DeserializationProblemHandler.NOT_HANDLED) {
+                return key;
+            }
+            h = h.next();
+        }
+        throw weirdStringException(value, targetClass, 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
@@ -917,7 +957,7 @@ public Object handleWeirdNumberValue(Class<?> targetClass, Number value,
         }
         throw weirdNumberException(value, targetClass, msg);
     }
-    
+
     /**
      * @since 2.8
      */
@@ -997,19 +1037,6 @@ public void reportInstantiationException(Class<?> instClass,
         throw instantiationException(instClass, msg);
     }
 
-    /**
-     * @since 2.8
-     */
-    public void reportWeirdStringException(String value, Class<?> instClass,
-            String msg, Object... msgArgs)
-        throws JsonMappingException
-    {
-        if (msgArgs.length > 0) {
-            msg = String.format(msg, msgArgs);
-        }
-        throw weirdStringException(value, instClass, msg);
-    }
-
     /**
      * @since 2.8
      */
@@ -1112,7 +1139,7 @@ public JsonMappingException mappingException(String msgTemplate, Object... args)
      * 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.
+     * if necessary.
      */
     public JsonMappingException weirdKeyException(Class<?> keyClass, String keyValue,
             String msg) {
@@ -1122,9 +1149,33 @@ public JsonMappingException weirdKeyException(Class<?> keyClass, String keyValue
                 keyValue, keyClass);
     }
 
+    /**
+     * Helper method for constructing exception to indicate that input JSON
+     * String was not suitable for deserializing into given target type.
+     * Note that most of the time this method should NOT be called; instead,
+     * {@link #handleWeirdStringValue} should be called which will call this method
+     * if necessary.
+     * 
+     * @param value String value from input being deserialized
+     * @param instClass Type that String should be deserialized into
+     * @param msg Message that describes specific problem
+     * 
+     * @since 2.1
+     */
+    public JsonMappingException weirdStringException(String value, Class<?> instClass,
+            String msg) {
+        return InvalidFormatException.from(_parser,
+                String.format("Can not deserialize value of type %s from String %s: %s",
+                        instClass.getName(), _quotedString(value), msg),
+                value, instClass);
+    }
+
     /**
      * Helper method for constructing exception to indicate that input JSON
      * Number was not suitable for deserializing into given target type.
+     * Note that most of the time this method should NOT be called; instead,
+     * {@link #handleWeirdNumberValue} should be called which will call this method
+     * if necessary.
      */
     public JsonMappingException weirdNumberException(Number value, Class<?> instClass,
             String msg) {
@@ -1135,9 +1186,12 @@ public JsonMappingException weirdNumberException(Number value, Class<?> instClas
     }
 
     /**
-     * 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.
+     * Helper method for constructing exception to indicate that given type id
+     * could not be resolved to a valid subtype of specified base type, during
+     * polymorphic deserialization.
+     * Note that most of the time this method should NOT be called; instead,
+     * {@link #handleUnknownTypeId} should be called which will call this method
+     * if necessary.
      */
     public JsonMappingException unknownTypeIdException(JavaType baseType, String typeId,
             String extraDesc) {
@@ -1180,27 +1234,6 @@ public JsonMappingException instantiationException(Class<?> instClass, String ms
                         instClass.getName(), msg));
     }
 
-    /**
-     * Method that will construct an exception suitable for throwing when
-     * some String values are acceptable, but the one encountered is not.
-     * 
-     * @param value String value from input being deserialized
-     * @param instClass Type that String should be deserialized into
-     * @param msg Message that describes specific problem
-     * 
-     * @since 2.1
-     *
-     * @deprecated Since 2.8 use {@link #reportWeirdStringException} instead
-     */
-    @Deprecated
-    public JsonMappingException weirdStringException(String value, Class<?> instClass,
-            String msg) {
-        return InvalidFormatException.from(_parser,
-                String.format("Can not deserialize value of type %s from String %s: %s",
-                        instClass.getName(), _quotedString(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

@@ -105,7 +105,41 @@ public Object handleWeirdKey(DeserializationContext ctxt,
     }
 
     /**
-     * Method called when a number value (integral or floating-point from input
+     * Method called when a String value
+     * can not be converted to a non-String value type due to specific problem
+     * (as opposed to String 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 handleWeirdStringValue(DeserializationContext ctxt,
+            Class<?> targetType, String valueToConvert,
+            String failureMsg)
+        throws IOException
+    {
+        return NOT_HANDLED;
+    }
+    
+    /**
+     * Method called when a numeric 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:
@@ -115,7 +149,7 @@ public Object handleWeirdKey(DeserializationContext ctxt,
      * <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
+     * <li>Return actual converted value (of type <code>targetType</code>) to use as
      *    replacement, and continue processing.
      *  </li>
      * </ul>

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

@@ -153,9 +153,8 @@ protected java.util.Date _parseDate(JsonParser p, DeserializationContext ctxt)
                         try {
                             return _customFormat.parse(str);
                         } catch (ParseException e) {
-                            ctxt.reportWeirdStringException(str, handledType(),
+                            return (java.util.Date) ctxt.handleWeirdStringValue(handledType(), str,
                                     "expected format \"%s\"", _formatString);
-                            return null;
                         }
                     }
                 }

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

@@ -191,9 +191,8 @@ private final Object _deserializeAltString(JsonParser p, DeserializationContext
             return _enumDefaultValue;
         }
         if (!ctxt.isEnabled(DeserializationFeature.READ_UNKNOWN_ENUM_VALUES_AS_NULL)) {
-            ctxt.reportWeirdStringException(name, _enumClass(),
+            return ctxt.handleWeirdStringValue(_enumClass(), name,
                     "value not one of declared Enum instance names: %s", lookup.keys());
-            // fall-through if not immediately thrown
         }
         return null;
     }

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

@@ -122,35 +122,36 @@ public JsonDeserializer<Object> getContentDeserializer() {
      */
 
     @Override
-    public EnumMap<?,?> deserialize(JsonParser jp, DeserializationContext ctxt)
+    public EnumMap<?,?> deserialize(JsonParser p, DeserializationContext ctxt)
         throws IOException
     {
         // Ok: must point to START_OBJECT
-        if (jp.getCurrentToken() != JsonToken.START_OBJECT) {
-            return _deserializeFromEmpty(jp, ctxt);
+        if (p.getCurrentToken() != JsonToken.START_OBJECT) {
+            return _deserializeFromEmpty(p, ctxt);
         }
         EnumMap result = constructMap();
         final JsonDeserializer<Object> valueDes = _valueDeserializer;
         final TypeDeserializer typeDeser = _valueTypeDeserializer;
 
-        while ((jp.nextToken()) == JsonToken.FIELD_NAME) {
-            String keyName = jp.getCurrentName(); // just for error message
+        while ((p.nextToken()) == JsonToken.FIELD_NAME) {
+            String keyName = p.getCurrentName(); // just for error message
             // but we need to let key deserializer handle it separately, nonetheless
             Enum<?> key = (Enum<?>) _keyDeserializer.deserializeKey(keyName, ctxt);
             if (key == null) {
                 if (!ctxt.isEnabled(DeserializationFeature.READ_UNKNOWN_ENUM_VALUES_AS_NULL)) {
-                    ctxt.reportWeirdStringException(keyName, _enumClass, "value not one of declared Enum instance names for %s",
+                    return (EnumMap<?,?>) ctxt.handleWeirdStringValue(_enumClass, keyName,
+                            "value not one of declared Enum instance names for %s",
                             _mapType.getKeyType());
                 }
                 /* 24-Mar-2012, tatu: Null won't work as a key anyway, so let's
                  *  just skip the entry then. But we must skip the value as well, if so.
                  */
-                jp.nextToken();
-                jp.skipChildren();
+                p.nextToken();
+                p.skipChildren();
                 continue;
             }
             // And then the value...
-            JsonToken t = jp.nextToken();
+            JsonToken t = p.nextToken();
             /* note: MUST check for nulls separately: deserializers will
              * not handle them (and maybe fail or return bogus data)
              */
@@ -160,9 +161,9 @@ public EnumMap<?,?> deserialize(JsonParser jp, DeserializationContext ctxt)
                 if (t == JsonToken.VALUE_NULL) {
                     value = valueDes.getNullValue(ctxt);
                 } else if (typeDeser == null) {
-                    value =  valueDes.deserialize(jp, ctxt);
+                    value =  valueDes.deserialize(p, ctxt);
                 } else {
-                    value = valueDes.deserializeWithType(jp, ctxt, typeDeser);
+                    value = valueDes.deserializeWithType(p, ctxt, typeDeser);
                 }
             } catch (Exception e) {
                 wrapAndThrow(e, result, keyName);

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

@@ -476,8 +476,8 @@ public Object deserialize(JsonParser p, DeserializationContext ctxt) throws IOEx
                     }
                     return Long.valueOf(value);
                 } catch (IllegalArgumentException iae) {
-                    ctxt.reportWeirdStringException(text, _valueClass, "not a valid number");
-                    return null;
+                    return ctxt.handleWeirdStringValue(_valueClass, text,
+                            "not a valid number");
                 }
             case JsonTokenId.ID_START_ARRAY:
                 if (ctxt.isEnabled(DeserializationFeature.UNWRAP_SINGLE_VALUE_ARRAYS)) {
@@ -573,8 +573,8 @@ public BigInteger deserialize(JsonParser p, DeserializationContext ctxt) throws
                 try {
                     return new BigInteger(text);
                 } catch (IllegalArgumentException iae) {
-                    ctxt.reportWeirdStringException(text, _valueClass, "not a valid representation");
-                    return null;
+                    return (BigInteger) ctxt.handleWeirdStringValue(_valueClass, text,
+                            "not a valid representation");
                 }
             }
             // String is ok too, can easily convert; otherwise, no can do:
@@ -608,8 +608,8 @@ public BigDecimal deserialize(JsonParser p, DeserializationContext ctxt)
                 try {
                     return new BigDecimal(text);
                 } catch (IllegalArgumentException iae) {
-                    ctxt.reportWeirdStringException(text, _valueClass, "not a valid representation");
-                    return null;
+                    return (BigDecimal) ctxt.handleWeirdStringValue(_valueClass, text,
+                            "not a valid representation");
                 }
             case JsonTokenId.ID_START_ARRAY:
                 if (ctxt.isEnabled(DeserializationFeature.UNWRAP_SINGLE_VALUE_ARRAYS)) {