package com.fasterxml.jackson.databind; import java.io.IOException; import java.text.DateFormat; import java.text.ParseException; import java.util.*; import java.util.concurrent.atomic.AtomicReference; import com.fasterxml.jackson.annotation.JsonFormat; import com.fasterxml.jackson.annotation.ObjectIdGenerator; import com.fasterxml.jackson.annotation.ObjectIdResolver; import com.fasterxml.jackson.core.*; import com.fasterxml.jackson.core.util.JacksonFeatureSet; import com.fasterxml.jackson.databind.cfg.CoercionAction; import com.fasterxml.jackson.databind.cfg.CoercionInputShape; import com.fasterxml.jackson.databind.cfg.ContextAttributes; import com.fasterxml.jackson.databind.deser.*; import com.fasterxml.jackson.databind.deser.impl.ObjectIdReader; import com.fasterxml.jackson.databind.deser.impl.ReadableObjectId; import com.fasterxml.jackson.databind.deser.impl.TypeWrappedDeserializer; import com.fasterxml.jackson.databind.exc.MismatchedInputException; import com.fasterxml.jackson.databind.exc.InvalidDefinitionException; import com.fasterxml.jackson.databind.exc.InvalidFormatException; import com.fasterxml.jackson.databind.exc.InvalidTypeIdException; import com.fasterxml.jackson.databind.exc.UnrecognizedPropertyException; import com.fasterxml.jackson.databind.exc.ValueInstantiationException; import com.fasterxml.jackson.databind.introspect.Annotated; import com.fasterxml.jackson.databind.introspect.AnnotatedMember; import com.fasterxml.jackson.databind.introspect.BeanPropertyDefinition; import com.fasterxml.jackson.databind.jsontype.TypeDeserializer; import com.fasterxml.jackson.databind.jsontype.TypeIdResolver; import com.fasterxml.jackson.databind.node.JsonNodeFactory; import com.fasterxml.jackson.databind.type.LogicalType; import com.fasterxml.jackson.databind.type.TypeFactory; import com.fasterxml.jackson.databind.util.*; /** * Context for the process of deserialization a single root-level value. * Used to allow passing in configuration settings and reusable temporary * objects (scrap arrays, containers). *

* Instance life-cycle is such that a partially configured "blueprint" object * is registered with {@link ObjectMapper} (and {@link ObjectReader}, * and when actual instance is needed for deserialization, * a fully configured instance will be created using a method in extended internal * API of sub-class * ({@link com.fasterxml.jackson.databind.deser.DefaultDeserializationContext#createInstance}). * Each instance is guaranteed to only be used from single-threaded context; * instances may be reused if (and only if) no configuration has changed. *

* Defined as abstract class so that implementations must define methods * for reconfiguring blueprints and creating instances. */ public abstract class DeserializationContext extends DatabindContext implements java.io.Serializable { private static final long serialVersionUID = 1L; // 2.6 /* /********************************************************** /* Configuration, immutable /********************************************************** */ /** * Object that handle details of {@link JsonDeserializer} caching. */ protected final DeserializerCache _cache; /* /********************************************************** /* Configuration, changeable via fluent factories /********************************************************** */ /** * Read-only factory instance; exposed to let * owners (ObjectMapper, ObjectReader) * access it. */ protected final DeserializerFactory _factory; /* /********************************************************** /* Configuration that gets set for instances (not blueprints) /* (partly denormalized for performance) /********************************************************** */ /** * Generic deserialization processing configuration */ protected final DeserializationConfig _config; /** * Bitmap of {@link DeserializationFeature}s that are enabled */ protected final int _featureFlags; /** * Capabilities of the input format. * * @since 2.12 */ protected final JacksonFeatureSet _readCapabilities; /** * Currently active view, if any. */ protected final Class _view; /** * Currently active parser used for deserialization. * May be different from the outermost parser * when content is buffered. */ protected transient JsonParser _parser; /** * Object used for resolving references to injectable * values. */ protected final InjectableValues _injectableValues; /* /********************************************************** /* Per-operation reusable helper objects (not for blueprints) /********************************************************** */ protected transient ArrayBuilders _arrayBuilders; protected transient ObjectBuffer _objectBuffer; protected transient DateFormat _dateFormat; /** * Lazily-constructed holder for per-call attributes. * * @since 2.3 */ protected transient ContextAttributes _attributes; /** * Type of {@link JsonDeserializer} (or, more specifically, * {@link ContextualDeserializer}) that is being * contextualized currently. * * @since 2.5 */ protected LinkedNode _currentType; /* /********************************************************** /* Life-cycle /********************************************************** */ protected DeserializationContext(DeserializerFactory df) { this(df, null); } protected DeserializationContext(DeserializerFactory df, DeserializerCache cache) { if (df == null) { throw new NullPointerException("Cannot pass null DeserializerFactory"); } _factory = df; if (cache == null) { cache = new DeserializerCache(); } _cache = cache; _featureFlags = 0; _readCapabilities = null; _config = null; _injectableValues = null; _view = null; _attributes = null; } protected DeserializationContext(DeserializationContext src, DeserializerFactory factory) { _cache = src._cache; _factory = factory; _config = src._config; _featureFlags = src._featureFlags; _readCapabilities = src._readCapabilities; _view = src._view; _parser = src._parser; _injectableValues = src._injectableValues; _attributes = src._attributes; } /** * Constructor used for creating actual per-call instances. */ protected DeserializationContext(DeserializationContext src, DeserializationConfig config, JsonParser p, InjectableValues injectableValues) { _cache = src._cache; _factory = src._factory; // 08-Jun-2020. tatu: Called only for `ObjectMapper.canDeserialize()` // (see [databind#2749]), not sure what's the best work-around but // start with this: _readCapabilities = (p == null) ? null : p.getReadCapabilities(); _config = config; _featureFlags = config.getDeserializationFeatures(); _view = config.getActiveView(); _parser = p; _injectableValues = injectableValues; _attributes = config.getAttributes(); } /** * Constructor used for creating bogus per-call style instance, but * without underlying parser: needed for deserializer pre-fetching * * @since 2.12 */ protected DeserializationContext(DeserializationContext src, DeserializationConfig config) { _cache = src._cache; _factory = src._factory; _readCapabilities = null; _config = config; _featureFlags = config.getDeserializationFeatures(); _view = null; _parser = null; _injectableValues = null; _attributes = null; } /** * Copy-constructor for use with copy() by {@link ObjectMapper#copy()} */ protected DeserializationContext(DeserializationContext src) { _cache = new DeserializerCache(); _factory = src._factory; _config = src._config; _featureFlags = src._featureFlags; _readCapabilities = src._readCapabilities; _view = src._view; _injectableValues = null; } /* /********************************************************** /* DatabindContext implementation /********************************************************** */ @Override public DeserializationConfig getConfig() { return _config; } @Override public final Class getActiveView() { return _view; } @Override public final boolean canOverrideAccessModifiers() { return _config.canOverrideAccessModifiers(); } @Override public final boolean isEnabled(MapperFeature feature) { return _config.isEnabled(feature); } @Override public final JsonFormat.Value getDefaultPropertyFormat(Class baseType) { return _config.getDefaultPropertyFormat(baseType); } @Override public final AnnotationIntrospector getAnnotationIntrospector() { return _config.getAnnotationIntrospector(); } @Override public final TypeFactory getTypeFactory() { return _config.getTypeFactory(); } @Override // since 2.11 public JavaType constructSpecializedType(JavaType baseType, Class subclass) throws IllegalArgumentException { if (baseType.hasRawClass(subclass)) { return baseType; } // On deserialization side, still uses "strict" type-compatibility checking; // see [databind#2632] about serialization side return getConfig().getTypeFactory().constructSpecializedType(baseType, subclass, false); } /** * Method for accessing default Locale to use: convenience method for *

     *   getConfig().getLocale();
     *
*/ @Override public Locale getLocale() { return _config.getLocale(); } /** * Method for accessing default TimeZone to use: convenience method for *
     *   getConfig().getTimeZone();
     *
*/ @Override public TimeZone getTimeZone() { return _config.getTimeZone(); } /* /********************************************************** /* Access to per-call state, like generic attributes (2.3+) /********************************************************** */ @Override public Object getAttribute(Object key) { return _attributes.getAttribute(key); } @Override public DeserializationContext setAttribute(Object key, Object value) { _attributes = _attributes.withPerCallAttribute(key, value); return this; } /** * Accessor to {@link JavaType} of currently contextualized * {@link ContextualDeserializer}, if any. * This is sometimes useful for generic {@link JsonDeserializer}s that * do not get passed (or do not retain) type information when being * constructed: happens for example for deserializers constructed * from annotations. * * @since 2.5 * * @return Type of {@link ContextualDeserializer} being contextualized, * if process is on-going; null if not. */ public JavaType getContextualType() { return (_currentType == null) ? null : _currentType.value(); } /* /********************************************************** /* Public API, config accessors /********************************************************** */ /** * Method for getting current {@link DeserializerFactory}. */ public DeserializerFactory getFactory() { return _factory; } /** * Convenience method for checking whether specified on/off * feature is enabled */ public final boolean isEnabled(DeserializationFeature feat) { /* 03-Dec-2010, tatu: minor shortcut; since this is called quite often, * let's use a local copy of feature settings: */ return (_featureFlags & feat.getMask()) != 0; } /** * Accessor for checking whether input format has specified capability * or not. * * @return True if input format has specified capability; false if not * * @since 2.12 */ public final boolean isEnabled(StreamReadCapability cap) { return _readCapabilities.isEnabled(cap); } /** * Bulk access method for getting the bit mask of all {@link DeserializationFeature}s * that are enabled. * * @since 2.6 */ public final int getDeserializationFeatures() { return _featureFlags; } /** * Bulk access method for checking that all features specified by * mask are enabled. * * @since 2.3 */ public final boolean hasDeserializationFeatures(int featureMask) { return (_featureFlags & featureMask) == featureMask; } /** * Bulk access method for checking that at least one of features specified by * mask is enabled. * * @since 2.6 */ public final boolean hasSomeOfFeatures(int featureMask) { return (_featureFlags & featureMask) != 0; } /** * Method for accessing the currently active parser. * May be different from the outermost parser * when content is buffered. *

* Use of this method is discouraged: if code has direct access * to the active parser, that should be used instead. */ public final JsonParser getParser() { return _parser; } public final Object findInjectableValue(Object valueId, BeanProperty forProperty, Object beanInstance) throws JsonMappingException { if (_injectableValues == null) { reportBadDefinition(ClassUtil.classOf(valueId), String.format( "No 'injectableValues' configured, cannot inject value with id [%s]", valueId)); } return _injectableValues.findInjectableValue(valueId, this, forProperty, beanInstance); } /** * Convenience method for accessing the default Base64 encoding * used for decoding base64 encoded binary content. * Same as calling: *

     *  getConfig().getBase64Variant();
     *
*/ public final Base64Variant getBase64Variant() { return _config.getBase64Variant(); } /** * Convenience method, functionally equivalent to: *
     *  getConfig().getNodeFactory();
     * 
*/ public final JsonNodeFactory getNodeFactory() { return _config.getNodeFactory(); } /* /********************************************************************** /* Public API, CoercionConfig access (2.12+) /********************************************************************** */ /** * General-purpose accessor for finding what to do when specified coercion * from shape that is now always allowed to be coerced from is requested. * * @param targetType Logical target type of coercion * @param targetClass Physical target type of coercion * @param inputShape Input shape to coerce from * * @return CoercionAction configured for specific coercion * * @since 2.12 */ public CoercionAction findCoercionAction(LogicalType targetType, Class targetClass, CoercionInputShape inputShape) { return _config.findCoercionAction(targetType, targetClass, inputShape); } /** * More specialized accessor called in case of input being a blank * String (one consisting of only white space characters with length of at least one). * Will basically first determine if "blank as empty" is allowed: if not, * returns {@code actionIfBlankNotAllowed}, otherwise returns action for * {@link CoercionInputShape#EmptyString}. * * @param targetType Logical target type of coercion * @param targetClass Physical target type of coercion * @param actionIfBlankNotAllowed Return value to use in case "blanks as empty" * is not allowed * * @return CoercionAction configured for specified coercion from blank string * * @since 2.12 */ public CoercionAction findCoercionFromBlankString(LogicalType targetType, Class targetClass, CoercionAction actionIfBlankNotAllowed) { return _config.findCoercionFromBlankString(targetType, targetClass, actionIfBlankNotAllowed); } /* /********************************************************** /* Public API, pass-through to DeserializerCache /********************************************************** */ /** * Method for checking whether we could find a deserializer * for given type. * * @param type Type to check * @param cause (optional) Reference set to root cause if no deserializer * could be found due to exception (to find the reason for failure) * * @since 2.3 */ public boolean hasValueDeserializerFor(JavaType type, AtomicReference cause) { try { return _cache.hasValueDeserializerFor(this, _factory, type); } catch (JsonMappingException e) { if (cause != null) { cause.set(e); } } catch (RuntimeException e) { if (cause == null) { // earlier behavior throw e; } cause.set(e); } return false; } /** * Method for finding a value deserializer, and creating a contextual * version if necessary, for value reached via specified property. */ @SuppressWarnings("unchecked") public final JsonDeserializer findContextualValueDeserializer(JavaType type, BeanProperty prop) throws JsonMappingException { JsonDeserializer deser = _cache.findValueDeserializer(this, _factory, type); if (deser != null) { deser = (JsonDeserializer) handleSecondaryContextualization(deser, prop, type); } return deser; } /** * Variant that will try to locate deserializer for current type, but without * performing any contextualization (unlike {@link #findContextualValueDeserializer}) * or checking for need to create a {@link TypeDeserializer} (unlike * {@link #findRootValueDeserializer(JavaType)}. * This method is usually called from within {@link ResolvableDeserializer#resolve}, * and expectation is that caller then calls either * {@link #handlePrimaryContextualization(JsonDeserializer, BeanProperty, JavaType)} or * {@link #handleSecondaryContextualization(JsonDeserializer, BeanProperty, JavaType)} at a * later point, as necessary. * * @since 2.5 */ public final JsonDeserializer findNonContextualValueDeserializer(JavaType type) throws JsonMappingException { return _cache.findValueDeserializer(this, _factory, type); } /** * Method for finding a deserializer for root-level value. */ @SuppressWarnings("unchecked") public final JsonDeserializer findRootValueDeserializer(JavaType type) throws JsonMappingException { JsonDeserializer deser = _cache.findValueDeserializer(this, _factory, type); if (deser == null) { // can this occur? return null; } deser = (JsonDeserializer) handleSecondaryContextualization(deser, null, type); TypeDeserializer typeDeser = _factory.findTypeDeserializer(_config, type); if (typeDeser != null) { // important: contextualize to indicate this is for root value typeDeser = typeDeser.forProperty(null); return new TypeWrappedDeserializer(typeDeser, deser); } return deser; } /** * Convenience method, functionally same as: *
     *  getDeserializerProvider().findKeyDeserializer(getConfig(), prop.getType(), prop);
     *
*/ public final KeyDeserializer findKeyDeserializer(JavaType keyType, BeanProperty prop) throws JsonMappingException { KeyDeserializer kd = _cache.findKeyDeserializer(this, _factory, keyType); // Second: contextualize? if (kd instanceof ContextualKeyDeserializer) { kd = ((ContextualKeyDeserializer) kd).createContextual(this, prop); } return kd; } /* /********************************************************** /* Public API, ObjectId handling /********************************************************** */ /** * Method called to find and return entry corresponding to given * Object Id: will add an entry if necessary, and never returns null */ public abstract ReadableObjectId findObjectId(Object id, ObjectIdGenerator generator, ObjectIdResolver resolver); /** * Method called to ensure that every object id encounter during processing * are resolved. * * @throws UnresolvedForwardReference */ public abstract void checkUnresolvedObjectId() throws UnresolvedForwardReference; /* /********************************************************** /* Public API, type handling /********************************************************** */ /** * Convenience method, functionally equivalent to: *
     *  getConfig().constructType(cls);
     * 
*/ public final JavaType constructType(Class cls) { return (cls == null) ? null : _config.constructType(cls); } /** * Helper method that is to be used when resolving basic class name into * Class instance, the reason being that it may be necessary to work around * various ClassLoader limitations, as well as to handle primitive type * signatures. * * @since 2.6 */ public Class findClass(String className) throws ClassNotFoundException { // By default, delegate to ClassUtil: can be overridden with custom handling return getTypeFactory().findClass(className); } /* /********************************************************** /* Public API, helper object recycling /********************************************************** */ /** * Method that can be used to get access to a reusable ObjectBuffer, * useful for efficiently constructing Object arrays and Lists. * Note that leased buffers should be returned once deserializer * is done, to allow for reuse during same round of deserialization. */ public final ObjectBuffer leaseObjectBuffer() { ObjectBuffer buf = _objectBuffer; if (buf == null) { buf = new ObjectBuffer(); } else { _objectBuffer = null; } return buf; } /** * Method to call to return object buffer previously leased with * {@link #leaseObjectBuffer}. * * @param buf Returned object buffer */ public final void returnObjectBuffer(ObjectBuffer buf) { /* Already have a reusable buffer? Let's retain bigger one * (or if equal, favor newer one, shorter life-cycle) */ if (_objectBuffer == null || buf.initialCapacity() >= _objectBuffer.initialCapacity()) { _objectBuffer = buf; } } /** * Method for accessing object useful for building arrays of * primitive types (such as int[]). */ public final ArrayBuilders getArrayBuilders() { if (_arrayBuilders == null) { _arrayBuilders = new ArrayBuilders(); } return _arrayBuilders; } /* /********************************************************** /* Extended API: handler instantiation /********************************************************** */ public abstract JsonDeserializer deserializerInstance(Annotated annotated, Object deserDef) throws JsonMappingException; public abstract KeyDeserializer keyDeserializerInstance(Annotated annotated, Object deserDef) throws JsonMappingException; /* /********************************************************** /* Extended API: resolving contextual deserializers; called /* by structured deserializers for their value/component /* deserializers /********************************************************** */ /** * Method called for primary property deserializers (ones * directly created to deserialize values of a POJO property), * to handle details of resolving * {@link ContextualDeserializer} with given property context. * * @param prop Property for which the given primary deserializer is used; never null. * * @since 2.5 */ public JsonDeserializer handlePrimaryContextualization(JsonDeserializer deser, BeanProperty prop, JavaType type) throws JsonMappingException { if (deser instanceof ContextualDeserializer) { _currentType = new LinkedNode(type, _currentType); try { deser = ((ContextualDeserializer) deser).createContextual(this, prop); } finally { _currentType = _currentType.next(); } } return deser; } /** * Method called for secondary property deserializers (ones * NOT directly created to deal with an annotatable POJO property, * but instead created as a component -- such as value deserializers * for structured types, or deserializers for root values) * to handle details of resolving * {@link ContextualDeserializer} with given property context. * Given that these deserializers are not directly related to given property * (or, in case of root value property, to any property), annotations * accessible may or may not be relevant. * * @param prop Property for which deserializer is used, if any; null * when deserializing root values * * @since 2.5 */ public JsonDeserializer handleSecondaryContextualization(JsonDeserializer deser, BeanProperty prop, JavaType type) throws JsonMappingException { if (deser instanceof ContextualDeserializer) { _currentType = new LinkedNode(type, _currentType); try { deser = ((ContextualDeserializer) deser).createContextual(this, prop); } finally { _currentType = _currentType.next(); } } return deser; } /* /********************************************************** /* Parsing methods that may use reusable/-cyclable objects /********************************************************** */ /** * Convenience method for parsing a Date from given String, using * currently configured date format (accessed using * {@link DeserializationConfig#getDateFormat()}). *

* Implementation will handle thread-safety issues related to * date formats such that first time this method is called, * date format is cloned, and cloned instance will be retained * for use during this deserialization round. */ public Date parseDate(String dateStr) throws IllegalArgumentException { try { DateFormat df = _getDateFormat(); return df.parse(dateStr); } catch (ParseException e) { throw new IllegalArgumentException(String.format( "Failed to parse Date value '%s': %s", dateStr, ClassUtil.exceptionMessage(e))); } } /** * Convenience method for constructing Calendar instance set * to specified time, to be modified and used by caller. */ public Calendar constructCalendar(Date d) { // 08-Jan-2008, tatu: not optimal, but should work for the most part; let's revise as needed. Calendar c = Calendar.getInstance(getTimeZone()); c.setTime(d); return c; } /* /********************************************************** /* Extension points for more esoteric data coercion (2.12) /********************************************************** */ /** * Method to call in case incoming shape is Object Value (and parser thereby * points to {@link com.fasterxml.jackson.core.JsonToken#START_OBJECT} token), * but a Scalar value (potentially coercible from String value) is expected. * This would typically be used to deserializer a Number, Boolean value or some other * "simple" unstructured value type. * * @param p Actual parser to read content from * @param deser Deserializer that needs extracted String value * @param scalarType Immediate type of scalar to extract; usually type deserializer * handles but not always (for example, deserializer for {@code int[]} would pass * scalar type of {@code int}) * * @return String value found; not {@code null} (exception should be thrown if no suitable * value found) * * @throws IOException If there are problems either reading content (underlying parser * problem) or finding expected scalar value */ public String extractScalarFromObject(JsonParser p, JsonDeserializer deser, Class scalarType) throws IOException { return reportInputMismatch(scalarType, String.format( "Cannot deserialize value of type %s from %s (token `JsonToken.START_OBJECT`)", ClassUtil.getClassDescription(scalarType), _shapeForToken(JsonToken.START_OBJECT))); } /* /********************************************************** /* Convenience methods for reading parsed values /********************************************************** */ /** * Convenience method that may be used by composite or container deserializers, * for reading one-off values contained (for sequences, it is more efficient * to actually fetch deserializer once for the whole collection). *

* NOTE: when deserializing values of properties contained in composite types, * rather use {@link #readPropertyValue(JsonParser, BeanProperty, Class)}; * this method does not allow use of contextual annotations. * * @since 2.4 */ public T readValue(JsonParser p, Class type) throws IOException { return readValue(p, getTypeFactory().constructType(type)); } /** * @since 2.4 */ @SuppressWarnings("unchecked") public T readValue(JsonParser p, JavaType type) throws IOException { JsonDeserializer deser = findRootValueDeserializer(type); if (deser == null) { reportBadDefinition(type, "Could not find JsonDeserializer for type "+ClassUtil.getTypeDescription(type)); } return (T) deser.deserialize(p, this); } /** * Convenience method that may be used by composite or container deserializers, * for reading one-off values for the composite type, taking into account * annotations that the property (passed to this method -- usually property that * has custom serializer that called this method) has. * * @since 2.4 */ public T readPropertyValue(JsonParser p, BeanProperty prop, Class type) throws IOException { return readPropertyValue(p, prop, getTypeFactory().constructType(type)); } /** * @since 2.4 */ @SuppressWarnings("unchecked") public T readPropertyValue(JsonParser p, BeanProperty prop, JavaType type) throws IOException { JsonDeserializer deser = findContextualValueDeserializer(type, prop); if (deser == null) { return reportBadDefinition(type, String.format( "Could not find JsonDeserializer for type %s (via property %s)", ClassUtil.getTypeDescription(type), ClassUtil.nameOf(prop))); } return (T) deser.deserialize(p, this); } /** * @since 2.10 */ public JsonNode readTree(JsonParser p) throws IOException { JsonToken t = p.currentToken(); if (t == null) { t = p.nextToken(); if (t == null) { return getNodeFactory().missingNode(); } } if (t == JsonToken.VALUE_NULL) { return getNodeFactory().nullNode(); } return (JsonNode) findRootValueDeserializer(_config.constructType(JsonNode.class)) .deserialize(p, this); } /* /********************************************************** /* Methods for problem handling /********************************************************** */ /** * 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. * * @return True if there was a configured problem handler that was able to handle the * problem */ public boolean handleUnknownProperty(JsonParser p, JsonDeserializer deser, Object instanceOrClass, String propName) throws IOException { LinkedNode h = _config.getProblemHandlers(); while (h != null) { // Can bail out if it's handled if (h.value().handleUnknownProperty(this, p, deser, instanceOrClass, propName)) { return true; } h = h.next(); } // Nope, not handled. Potentially that's a problem... if (!isEnabled(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES)) { p.skipChildren(); return true; } // Do we know properties that are expected instead? Collection propIds = (deser == null) ? null : deser.getKnownPropertyNames(); throw UnrecognizedPropertyException.from(_parser, instanceOrClass, propName, propIds); } /** * Method that deserializers should call if they encounter a String value * that cannot 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 * @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 Key value to use * * @throws IOException To indicate unrecoverable problem, usually based on msg * * @since 2.8 */ public Object handleWeirdKey(Class keyClass, String keyValue, String msg, Object... msgArgs) throws IOException { // but if not handled, just throw exception msg = _format(msg, msgArgs); LinkedNode h = _config.getProblemHandlers(); while (h != null) { // Can bail out if it's handled Object key = h.value().handleWeirdKey(this, keyClass, keyValue, msg); if (key != DeserializationProblemHandler.NOT_HANDLED) { // Sanity check for broken handlers, otherwise nasty to debug: if ((key == null) || keyClass.isInstance(key)) { return key; } throw weirdStringException(keyValue, keyClass, String.format( "DeserializationProblemHandler.handleWeirdStringValue() for type %s returned value of type %s", ClassUtil.getClassDescription(keyClass), ClassUtil.getClassDescription(key) )); } h = h.next(); } throw weirdKeyException(keyClass, keyValue, msg); } /** * Method that deserializers should call if they encounter a String value * that cannot 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 msg * * @since 2.8 */ public Object handleWeirdStringValue(Class targetClass, String value, String msg, Object... msgArgs) throws IOException { // but if not handled, just throw exception msg = _format(msg, msgArgs); LinkedNode h = _config.getProblemHandlers(); while (h != null) { // Can bail out if it's handled Object instance = h.value().handleWeirdStringValue(this, targetClass, value, msg); if (instance != DeserializationProblemHandler.NOT_HANDLED) { // Sanity check for broken handlers, otherwise nasty to debug: if (_isCompatible(targetClass, instance)) { return instance; } throw weirdStringException(value, targetClass, String.format( "DeserializationProblemHandler.handleWeirdStringValue() for type %s returned value of type %s", ClassUtil.getClassDescription(targetClass), ClassUtil.getClassDescription(instance) )); } h = h.next(); } throw weirdStringException(value, targetClass, msg); } /** * Method that deserializers should call if they encounter a numeric value * that cannot 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 msg * * @since 2.8 */ public Object handleWeirdNumberValue(Class targetClass, Number value, String msg, Object... msgArgs) throws IOException { msg = _format(msg, msgArgs); LinkedNode 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) { // Sanity check for broken handlers, otherwise nasty to debug: if (_isCompatible(targetClass, key)) { return key; } throw weirdNumberException(value, targetClass, _format( "DeserializationProblemHandler.handleWeirdNumberValue() for type %s returned value of type %s", ClassUtil.getClassDescription(targetClass), ClassUtil.getClassDescription(key) )); } h = h.next(); } throw weirdNumberException(value, targetClass, msg); } public Object handleWeirdNativeValue(JavaType targetType, Object badValue, JsonParser p) throws IOException { LinkedNode h = _config.getProblemHandlers(); final Class raw = targetType.getRawClass(); for (; h != null; h = h.next()) { // Can bail out if it's handled Object goodValue = h.value().handleWeirdNativeValue(this, targetType, badValue, p); if (goodValue != DeserializationProblemHandler.NOT_HANDLED) { // Sanity check for broken handlers, otherwise nasty to debug: if ((goodValue == null) || raw.isInstance(goodValue)) { return goodValue; } throw JsonMappingException.from(p, _format( "DeserializationProblemHandler.handleWeirdNativeValue() for type %s returned value of type %s", ClassUtil.getClassDescription(targetType), ClassUtil.getClassDescription(goodValue) )); } } throw weirdNativeValueException(badValue, raw); } /** * Method that deserializers should call if they fail to instantiate value * due to lack of viable instantiator (usually creator, that is, constructor * or static factory method). Method should be called at point where value * has not been decoded, so that handler has a chance to handle decoding * using alternate mechanism, and handle underlying content (possibly by * just skipping it) to keep input state valid * * @param instClass Type that was to be instantiated * @param valueInst (optional) Value instantiator to be used, if any; null if type does not * use one for instantiation (custom deserialiers don't; standard POJO deserializer does) * @param p Parser that points to the JSON value to decode * * @return Object that should be constructed, if any; has to be of type instClass * * @since 2.9 (2.8 had alternate that did not take ValueInstantiator) */ @SuppressWarnings("resource") public Object handleMissingInstantiator(Class instClass, ValueInstantiator valueInst, JsonParser p, String msg, Object... msgArgs) throws IOException { if (p == null) { p = getParser(); } msg = _format(msg, msgArgs); LinkedNode h = _config.getProblemHandlers(); while (h != null) { // Can bail out if it's handled Object instance = h.value().handleMissingInstantiator(this, instClass, valueInst, p, msg); if (instance != DeserializationProblemHandler.NOT_HANDLED) { // Sanity check for broken handlers, otherwise nasty to debug: if (_isCompatible(instClass, instance)) { return instance; } reportBadDefinition(constructType(instClass), String.format( "DeserializationProblemHandler.handleMissingInstantiator() for type %s returned value of type %s", ClassUtil.getClassDescription(instClass), ClassUtil.getClassDescription((instance) ))); } h = h.next(); } // 16-Oct-2016, tatu: This is either a definition problem (if no applicable creator // exists), or input mismatch problem (otherwise) since none of existing creators // match with token. // 24-Oct-2019, tatu: Further, as per [databind#2522], passing `null` ValueInstantiator // should simply trigger definition problem if (valueInst == null ) { msg = String.format("Cannot construct instance of %s: %s", ClassUtil.nameOf(instClass), msg); return reportBadDefinition(instClass, msg); } if (!valueInst.canInstantiate()) { msg = String.format("Cannot construct instance of %s (no Creators, like default constructor, exist): %s", ClassUtil.nameOf(instClass), msg); return reportBadDefinition(instClass, msg); } msg = String.format("Cannot construct instance of %s (although at least one Creator exists): %s", ClassUtil.nameOf(instClass), msg); return reportInputMismatch(instClass, msg); } /** * Method that deserializers should call if they fail to instantiate value * due to an exception that was thrown by constructor (or other mechanism used * to create instances). * Default implementation will try to call {@link DeserializationProblemHandler#handleInstantiationProblem} * on configured handlers, if any, to allow for recovery; if recovery does not * succeed, will throw exception constructed with {@link #instantiationException}. * * @param instClass Type that was to be instantiated * @param argument (optional) Argument that was passed to constructor or equivalent * instantiator; often a {@link java.lang.String}. * @param t Exception that caused failure * * @return Object that should be constructed, if any; has to be of type instClass * * @since 2.8 */ public Object handleInstantiationProblem(Class instClass, Object argument, Throwable t) throws IOException { LinkedNode h = _config.getProblemHandlers(); while (h != null) { // Can bail out if it's handled Object instance = h.value().handleInstantiationProblem(this, instClass, argument, t); if (instance != DeserializationProblemHandler.NOT_HANDLED) { // Sanity check for broken handlers, otherwise nasty to debug: if (_isCompatible(instClass, instance)) { return instance; } reportBadDefinition(constructType(instClass), String.format( "DeserializationProblemHandler.handleInstantiationProblem() for type %s returned value of type %s", ClassUtil.getClassDescription(instClass), ClassUtil.classNameOf(instance) )); } h = h.next(); } // 18-May-2016, tatu: Only wrap if not already a valid type to throw ClassUtil.throwIfIOE(t); // [databind#2164]: but see if wrapping is desired if (!isEnabled(DeserializationFeature.WRAP_EXCEPTIONS)) { ClassUtil.throwIfRTE(t); } throw instantiationException(instClass, t); } /** * Method that deserializers should call if the first token of the value to * deserialize is of unexpected type (that is, type of token that deserializer * cannot handle). This could occur, for example, if a Number deserializer * encounter {@link JsonToken#START_ARRAY} instead of * {@link JsonToken#VALUE_NUMBER_INT} or {@link JsonToken#VALUE_NUMBER_FLOAT}. * * @param instClass Type that was to be instantiated * @param p Parser that points to the JSON value to decode * * @return Object that should be constructed, if any; has to be of type instClass * * @since 2.8 */ public Object handleUnexpectedToken(Class instClass, JsonParser p) throws IOException { return handleUnexpectedToken(constructType(instClass), p.currentToken(), p, null); } /** * Method that deserializers should call if the first token of the value to * deserialize is of unexpected type (that is, type of token that deserializer * cannot handle). This could occur, for example, if a Number deserializer * encounter {@link JsonToken#START_ARRAY} instead of * {@link JsonToken#VALUE_NUMBER_INT} or {@link JsonToken#VALUE_NUMBER_FLOAT}. * * @param instClass Type that was to be instantiated * @param t Token encountered that does match expected * @param p Parser that points to the JSON value to decode * * @return Object that should be constructed, if any; has to be of type instClass * * @since 2.8 */ public Object handleUnexpectedToken(Class instClass, JsonToken t, JsonParser p, String msg, Object... msgArgs) throws IOException { return handleUnexpectedToken(constructType(instClass), t, p, msg, msgArgs); } /** * Method that deserializers should call if the first token of the value to * deserialize is of unexpected type (that is, type of token that deserializer * cannot handle). This could occur, for example, if a Number deserializer * encounter {@link JsonToken#START_ARRAY} instead of * {@link JsonToken#VALUE_NUMBER_INT} or {@link JsonToken#VALUE_NUMBER_FLOAT}. * * @param targetType Type that was to be instantiated * @param p Parser that points to the JSON value to decode * * @return Object that should be constructed, if any; has to be of type instClass * * @since 2.10 */ public Object handleUnexpectedToken(JavaType targetType, JsonParser p) throws IOException { return handleUnexpectedToken(targetType, p.currentToken(), p, null); } /** * Method that deserializers should call if the first token of the value to * deserialize is of unexpected type (that is, type of token that deserializer * cannot handle). This could occur, for example, if a Number deserializer * encounter {@link JsonToken#START_ARRAY} instead of * {@link JsonToken#VALUE_NUMBER_INT} or {@link JsonToken#VALUE_NUMBER_FLOAT}. * * @param targetType Type that was to be instantiated * @param t Token encountered that does not match expected * @param p Parser that points to the JSON value to decode * * @return Object that should be constructed, if any; has to be of type instClass * * @since 2.10 */ public Object handleUnexpectedToken(JavaType targetType, JsonToken t, JsonParser p, String msg, Object... msgArgs) throws IOException { msg = _format(msg, msgArgs); LinkedNode h = _config.getProblemHandlers(); while (h != null) { Object instance = h.value().handleUnexpectedToken(this, targetType, t, p, msg); if (instance != DeserializationProblemHandler.NOT_HANDLED) { if (_isCompatible(targetType.getRawClass(), instance)) { return instance; } reportBadDefinition(targetType, String.format( "DeserializationProblemHandler.handleUnexpectedToken() for type %s returned value of type %s", ClassUtil.getTypeDescription(targetType), ClassUtil.classNameOf(instance) )); } h = h.next(); } if (msg == null) { final String targetDesc = ClassUtil.getTypeDescription(targetType); if (t == null) { msg = String.format("Unexpected end-of-input when trying read value of type %s", targetDesc); } else { msg = String.format("Cannot deserialize value of type %s from %s (token `JsonToken.%s`)", targetDesc, _shapeForToken(t), t); } } // 18-Jun-2020, tatu: to resolve [databind#2770], force access to `getText()` for scalars if ((t != null) && t.isScalarValue()) { p.getText(); } reportInputMismatch(targetType, msg); return null; // never gets here } /** * Method that deserializers should call if they encounter a type id * (for polymorphic deserialization) that cannot be resolved to an * actual type; usually since there is no mapping defined. * Default implementation will try to call {@link DeserializationProblemHandler#handleUnknownTypeId} * on configured handlers, if any, to allow for recovery; if recovery does not * succeed, will throw exception constructed with {@link #invalidTypeIdException}. * * @param baseType Base type from which resolution starts * @param id Type id that could not be converted * @param extraDesc Additional problem description to add to default exception message, * if resolution fails. * * @return {@link JavaType} that id resolves to * * @throws IOException To indicate unrecoverable problem, if resolution cannot * be made to work * * @since 2.8 */ public JavaType handleUnknownTypeId(JavaType baseType, String id, TypeIdResolver idResolver, String extraDesc) throws IOException { LinkedNode h = _config.getProblemHandlers(); while (h != null) { // Can bail out if it's handled JavaType type = h.value().handleUnknownTypeId(this, baseType, id, idResolver, extraDesc); if (type != null) { if (type.hasRawClass(Void.class)) { return null; } // But ensure there's type compatibility if (type.isTypeOrSubTypeOf(baseType.getRawClass())) { return type; } throw invalidTypeIdException(baseType, id, "problem handler tried to resolve into non-subtype: "+ ClassUtil.getTypeDescription(type)); } h = h.next(); } // 24-May-2016, tatu: Actually we may still not want to fail quite yet if (!isEnabled(DeserializationFeature.FAIL_ON_INVALID_SUBTYPE)) { return null; } throw invalidTypeIdException(baseType, id, extraDesc); } /** * @since 2.9 */ public JavaType handleMissingTypeId(JavaType baseType, TypeIdResolver idResolver, String extraDesc) throws IOException { LinkedNode h = _config.getProblemHandlers(); while (h != null) { // Can bail out if it's handled JavaType type = h.value().handleMissingTypeId(this, baseType, idResolver, extraDesc); if (type != null) { if (type.hasRawClass(Void.class)) { return null; } // But ensure there's type compatibility if (type.isTypeOrSubTypeOf(baseType.getRawClass())) { return type; } throw invalidTypeIdException(baseType, null, "problem handler tried to resolve into non-subtype: "+ ClassUtil.getTypeDescription(type)); } h = h.next(); } // 09-Mar-2017, tatu: We may want to consider yet another feature at some // point to allow returning `null`... but that seems bit risky for now // if (!isEnabled(DeserializationFeature.FAIL_ON_INVALID_SUBTYPE)) { // return null; // } throw missingTypeIdException(baseType, extraDesc); } /** * Method that deserializer may call if it is called to do an update ("merge") * but deserializer operates on a non-mergeable type. Although this should * usually be caught earlier, sometimes it may only be caught during operation * and if so this is the method to call. * Note that if {@link MapperFeature#IGNORE_MERGE_FOR_UNMERGEABLE} is enabled, * this method will simply return null; otherwise {@link InvalidDefinitionException} * will be thrown. * * @since 2.10 */ public void handleBadMerge(JsonDeserializer deser) throws JsonMappingException { if (!isEnabled(MapperFeature.IGNORE_MERGE_FOR_UNMERGEABLE)) { JavaType type = constructType(deser.handledType()); String msg = String.format("Invalid configuration: values of type %s cannot be merged", ClassUtil.getTypeDescription(type)); throw InvalidDefinitionException.from(getParser(), msg, type); } } /** * @since 2.9.2 */ protected boolean _isCompatible(Class target, Object value) { if ((value == null) || target.isInstance(value)) { return true; } // [databind#1767]: Make sure to allow wrappers for primitive fields return target.isPrimitive() && ClassUtil.wrapperType(target).isInstance(value); } /* /********************************************************** /* Methods for problem reporting, in cases where recovery /* is not considered possible: input problem /********************************************************** */ /** * Method for deserializers to call * when the token encountered was of type different than what should * be seen at that position, usually within a sequence of expected tokens. * Note that this method will throw a {@link JsonMappingException} and no * recovery is attempted (via {@link DeserializationProblemHandler}, as * problem is considered to be difficult to recover from, in general. * * @since 2.9 */ public void reportWrongTokenException(JsonDeserializer deser, JsonToken expToken, String msg, Object... msgArgs) throws JsonMappingException { msg = _format(msg, msgArgs); throw wrongTokenException(getParser(), deser.handledType(), expToken, msg); } /** * Method for deserializers to call * when the token encountered was of type different than what should * be seen at that position, usually within a sequence of expected tokens. * Note that this method will throw a {@link JsonMappingException} and no * recovery is attempted (via {@link DeserializationProblemHandler}, as * problem is considered to be difficult to recover from, in general. * * @since 2.9 */ public void reportWrongTokenException(JavaType targetType, JsonToken expToken, String msg, Object... msgArgs) throws JsonMappingException { msg = _format(msg, msgArgs); throw wrongTokenException(getParser(), targetType, expToken, msg); } /** * Method for deserializers to call * when the token encountered was of type different than what should * be seen at that position, usually within a sequence of expected tokens. * Note that this method will throw a {@link JsonMappingException} and no * recovery is attempted (via {@link DeserializationProblemHandler}, as * problem is considered to be difficult to recover from, in general. * * @since 2.9 */ public void reportWrongTokenException(Class targetType, JsonToken expToken, String msg, Object... msgArgs) throws JsonMappingException { msg = _format(msg, msgArgs); throw wrongTokenException(getParser(), targetType, expToken, msg); } /** * @since 2.8 */ public T reportUnresolvedObjectId(ObjectIdReader oidReader, Object bean) throws JsonMappingException { String msg = String.format("No Object Id found for an instance of %s, to assign to property '%s'", ClassUtil.classNameOf(bean), oidReader.propertyName); return reportInputMismatch(oidReader.idProperty, msg); } /** * Helper method used to indicate a problem with input in cases where more * specific reportXxx() method was not available. * * @since 2.9 */ public T reportInputMismatch(JsonDeserializer src, String msg, Object... msgArgs) throws JsonMappingException { msg = _format(msg, msgArgs); throw MismatchedInputException.from(getParser(), src.handledType(), msg); } /** * Helper method used to indicate a problem with input in cases where more * specific reportXxx() method was not available. * * @since 2.9 */ public T reportInputMismatch(Class targetType, String msg, Object... msgArgs) throws JsonMappingException { msg = _format(msg, msgArgs); throw MismatchedInputException.from(getParser(), targetType, msg); } /** * Helper method used to indicate a problem with input in cases where more * specific reportXxx() method was not available. * * @since 2.9 */ public T reportInputMismatch(JavaType targetType, String msg, Object... msgArgs) throws JsonMappingException { msg = _format(msg, msgArgs); throw MismatchedInputException.from(getParser(), targetType, msg); } /** * Helper method used to indicate a problem with input in cases where more * specific reportXxx() method was not available. * * @since 2.9 */ public T reportInputMismatch(BeanProperty prop, String msg, Object... msgArgs) throws JsonMappingException { msg = _format(msg, msgArgs); JavaType type = (prop == null) ? null : prop.getType(); final MismatchedInputException e = MismatchedInputException.from(getParser(), type, msg); // [databind#2357]: Include property name, if we have it if (prop != null) { AnnotatedMember member = prop.getMember(); if (member != null) { e.prependPath(member.getDeclaringClass(), prop.getName()); } } throw e; } /** * Helper method used to indicate a problem with input in cases where more * specific reportXxx() method was not available. * * @since 2.10 */ public T reportPropertyInputMismatch(Class targetType, String propertyName, String msg, Object... msgArgs) throws JsonMappingException { msg = _format(msg, msgArgs); MismatchedInputException e = MismatchedInputException.from(getParser(), targetType, msg); if (propertyName != null) { e.prependPath(targetType, propertyName); } throw e; } /** * Helper method used to indicate a problem with input in cases where more * specific reportXxx() method was not available. * * @since 2.10 */ public T reportPropertyInputMismatch(JavaType targetType, String propertyName, String msg, Object... msgArgs) throws JsonMappingException { return reportPropertyInputMismatch(targetType.getRawClass(), propertyName, msg, msgArgs); } public T reportTrailingTokens(Class targetType, JsonParser p, JsonToken trailingToken) throws JsonMappingException { throw MismatchedInputException.from(p, targetType, String.format( "Trailing token (of type %s) found after value (bound as %s): not allowed as per `DeserializationFeature.FAIL_ON_TRAILING_TOKENS`", trailingToken, ClassUtil.nameOf(targetType) )); } @Deprecated // since 2.9 public void reportWrongTokenException(JsonParser p, JsonToken expToken, String msg, Object... msgArgs) throws JsonMappingException { msg = _format(msg, msgArgs); throw wrongTokenException(p, expToken, msg); } /** * Helper method for reporting a problem with unhandled unknown property. * * @param instanceOrClass Either value being populated (if one has been * instantiated), or Class that indicates type that would be (or * have been) instantiated * @param deser Deserializer that had the problem, if called by deserializer * (or on behalf of one) * * @deprecated Since 2.8 call {@link #handleUnknownProperty} instead */ @Deprecated public void reportUnknownProperty(Object instanceOrClass, String fieldName, JsonDeserializer deser) throws JsonMappingException { if (isEnabled(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES)) { // Do we know properties that are expected instead? Collection propIds = (deser == null) ? null : deser.getKnownPropertyNames(); throw UnrecognizedPropertyException.from(_parser, instanceOrClass, fieldName, propIds); } } /** * @since 2.8 * * @deprecated Since 2.9: not clear this ever occurs */ @Deprecated // since 2.9 public void reportMissingContent(String msg, Object... msgArgs) throws JsonMappingException { throw MismatchedInputException.from(getParser(), (JavaType) null, "No content to map due to end-of-input"); } /* /********************************************************** /* Methods for problem reporting, in cases where recovery /* is not considered possible: POJO definition problems /********************************************************** */ /** * Helper method called to indicate problem in POJO (serialization) definitions or settings * regarding specific Java type, unrelated to actual JSON content to map. * Default behavior is to construct and throw a {@link JsonMappingException}. * * @since 2.9 */ public T reportBadTypeDefinition(BeanDescription bean, String msg, Object... msgArgs) throws JsonMappingException { msg = _format(msg, msgArgs); String beanDesc = ClassUtil.nameOf(bean.getBeanClass()); msg = String.format("Invalid type definition for type %s: %s", beanDesc, msg); throw InvalidDefinitionException.from(_parser, msg, bean, null); } /** * Helper method called to indicate problem in POJO (serialization) definitions or settings * regarding specific property (of a type), unrelated to actual JSON content to map. * Default behavior is to construct and throw a {@link JsonMappingException}. * * @since 2.9 */ public T reportBadPropertyDefinition(BeanDescription bean, BeanPropertyDefinition prop, String msg, Object... msgArgs) throws JsonMappingException { msg = _format(msg, msgArgs); String propName = ClassUtil.nameOf(prop); String beanDesc = ClassUtil.nameOf(bean.getBeanClass()); msg = String.format("Invalid definition for property %s (of type %s): %s", propName, beanDesc, msg); throw InvalidDefinitionException.from(_parser, msg, bean, prop); } @Override public T reportBadDefinition(JavaType type, String msg) throws JsonMappingException { throw InvalidDefinitionException.from(_parser, msg, type); } /** * @deprecated Since 2.10 use {@link #handleBadMerge} instead */ @Deprecated // since 2.10 public T reportBadMerge(JsonDeserializer deser) throws JsonMappingException { handleBadMerge(deser); return null; } /* /********************************************************** /* Methods for constructing semantic exceptions; usually not /* to be called directly, call `handleXxx()` instead /********************************************************** */ /** * Helper method for constructing {@link JsonMappingException} to indicate * that the token encountered was of type different than what should * be seen at that position, usually within a sequence of expected tokens. * Note that most of the time this method should NOT be directly called; * instead, {@link #reportWrongTokenException} should be called and will * call this method as necessary. * * @since 2.9 */ public JsonMappingException wrongTokenException(JsonParser p, JavaType targetType, JsonToken expToken, String extra) { String msg = String.format("Unexpected token (%s), expected %s", p.currentToken(), expToken); msg = _colonConcat(msg, extra); return MismatchedInputException.from(p, targetType, msg); } public JsonMappingException wrongTokenException(JsonParser p, Class targetType, JsonToken expToken, String extra) { String msg = String.format("Unexpected token (%s), expected %s", p.currentToken(), expToken); msg = _colonConcat(msg, extra); return MismatchedInputException.from(p, targetType, msg); } @Deprecated // since 2.9 public JsonMappingException wrongTokenException(JsonParser p, JsonToken expToken, String msg) { return wrongTokenException(p, (JavaType) null, expToken, msg); } /** * 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. */ public JsonMappingException weirdKeyException(Class keyClass, String keyValue, String msg) { return InvalidFormatException.from(_parser, String.format("Cannot deserialize Map key of type %s from String %s: %s", ClassUtil.nameOf(keyClass), _quotedString(keyValue), msg), 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 msgBase Message that describes specific problem * * @since 2.1 */ public JsonMappingException weirdStringException(String value, Class instClass, String msgBase) { final String msg = String.format("Cannot deserialize value of type %s from String %s: %s", ClassUtil.nameOf(instClass), _quotedString(value), msgBase); return InvalidFormatException.from(_parser, 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) { return InvalidFormatException.from(_parser, String.format("Cannot deserialize value of type %s from number %s: %s", ClassUtil.nameOf(instClass), String.valueOf(value), msg), value, instClass); } /** * Helper method for constructing exception to indicate that input JSON * token of type "native value" (see {@link JsonToken#VALUE_EMBEDDED_OBJECT}) * is of incompatible type (and there is no delegating creator or such to use) * and can not be used to construct value of specified type (usually POJO). * Note that most of the time this method should NOT be called; instead, * {@link #handleWeirdNativeValue} should be called which will call this method * * @since 2.9 */ public JsonMappingException weirdNativeValueException(Object value, Class instClass) { return InvalidFormatException.from(_parser, String.format( "Cannot deserialize value of type %s from native value (`JsonToken.VALUE_EMBEDDED_OBJECT`) of type %s: incompatible types", ClassUtil.nameOf(instClass), ClassUtil.classNameOf(value)), value, instClass); } /** * Helper method for constructing instantiation exception for specified type, * to indicate problem with physically constructing instance of * specified class (missing constructor, exception from constructor) *

* Note that most of the time this method should NOT be called directly; instead, * {@link #handleInstantiationProblem} should be called which will call this method * if necessary. */ public JsonMappingException instantiationException(Class instClass, Throwable cause) { String excMsg; if (cause == null) { excMsg = "N/A"; } else if ((excMsg = ClassUtil.exceptionMessage(cause)) == null) { excMsg = ClassUtil.nameOf(cause.getClass()); } String msg = String.format("Cannot construct instance of %s, problem: %s", ClassUtil.nameOf(instClass), excMsg); // [databind#2162]: use specific exception type as we don't know if it's // due to type definition, input, or neither return ValueInstantiationException.from(_parser, msg, constructType(instClass), cause); } /** * Helper method for constructing instantiation exception for specified type, * to indicate that instantiation failed due to missing instantiator * (creator; constructor or factory method). *

* Note that most of the time this method should NOT be called; instead, * {@link #handleMissingInstantiator} should be called which will call this method * if necessary. */ public JsonMappingException instantiationException(Class instClass, String msg0) { // [databind#2162]: use specific exception type as we don't know if it's // due to type definition, input, or neither return ValueInstantiationException.from(_parser, String.format("Cannot construct instance of %s: %s", ClassUtil.nameOf(instClass), msg0), constructType(instClass)); } @Override public JsonMappingException invalidTypeIdException(JavaType baseType, String typeId, String extraDesc) { String msg = String.format("Could not resolve type id '%s' as a subtype of %s", typeId, ClassUtil.getTypeDescription(baseType)); return InvalidTypeIdException.from(_parser, _colonConcat(msg, extraDesc), baseType, typeId); } /** * @since 2.9 */ public JsonMappingException missingTypeIdException(JavaType baseType, String extraDesc) { String msg = String.format("Missing type id when trying to resolve subtype of %s", baseType); return InvalidTypeIdException.from(_parser, _colonConcat(msg, extraDesc), baseType, null); } /* /********************************************************** /* Deprecated exception factory methods /********************************************************** */ /** * @since 2.5 * * @deprecated Since 2.8 use {@link #handleUnknownTypeId} instead */ @Deprecated public JsonMappingException unknownTypeException(JavaType type, String id, String extraDesc) { String msg = String.format("Could not resolve type id '%s' into a subtype of %s", id, ClassUtil.getTypeDescription(type)); msg = _colonConcat(msg, extraDesc); return MismatchedInputException.from(_parser, type, msg); } /** * Helper method for constructing exception to indicate that end-of-input was * reached while still expecting more tokens to deserialize value of specified type. * * @deprecated Since 2.8; currently no way to catch EOF at databind level */ @Deprecated public JsonMappingException endOfInputException(Class instClass) { return MismatchedInputException.from(_parser, instClass, "Unexpected end-of-input when trying to deserialize a "+instClass.getName()); } /* /********************************************************** /* Deprecated methods for constructing, throwing non-specific /* JsonMappingExceptions: as of 2.9, should use more specific /* ones. /********************************************************** */ /** * Fallback method that may be called if no other reportXxx * is applicable -- but only in that case. * * @since 2.8 * * @deprecated Since 2.9: use a more specific method, or {@link #reportBadDefinition(JavaType, String)}, * or {@link #reportInputMismatch} instead */ @Deprecated // since 2.9 public void reportMappingException(String msg, Object... msgArgs) throws JsonMappingException { throw JsonMappingException.from(getParser(), _format(msg, msgArgs)); } /** * Helper method for constructing generic mapping exception with specified * message and current location information. * Note that application code should almost always call * one of handleXxx methods, or {@link #reportMappingException(String, Object...)} * instead. * * @since 2.6 * * @deprecated Since 2.9 use more specific error reporting methods instead */ @Deprecated public JsonMappingException mappingException(String message) { return JsonMappingException.from(getParser(), message); } /** * Helper method for constructing generic mapping exception with specified * message and current location information * Note that application code should almost always call * one of handleXxx methods, or {@link #reportMappingException(String, Object...)} * instead. * * @since 2.6 * * @deprecated Since 2.9 use more specific error reporting methods instead */ @Deprecated public JsonMappingException mappingException(String msg, Object... msgArgs) { return JsonMappingException.from(getParser(), _format(msg, msgArgs)); } /** * Helper method for constructing generic mapping exception for specified type * * @deprecated Since 2.8 use {@link #handleUnexpectedToken(Class, JsonParser)} instead */ @Deprecated public JsonMappingException mappingException(Class targetClass) { return mappingException(targetClass, _parser.currentToken()); } /** * @deprecated Since 2.8 use {@link #handleUnexpectedToken(Class, JsonParser)} instead */ @Deprecated public JsonMappingException mappingException(Class targetClass, JsonToken token) { return JsonMappingException.from(_parser, String.format("Cannot deserialize instance of %s out of %s token", ClassUtil.nameOf(targetClass), token)); } /* /********************************************************** /* Other internal methods /********************************************************** */ @Deprecated // since 2.12, remove from 2.13 or later protected DateFormat getDateFormat() { return _getDateFormat(); } protected DateFormat _getDateFormat() { if (_dateFormat != null) { return _dateFormat; } /* 24-Feb-2012, tatu: At this point, all timezone configuration * should have occurred, with respect to default dateformat * and timezone configuration. But we still better clone * an instance as formatters may be stateful. */ DateFormat df = _config.getDateFormat(); _dateFormat = df = (DateFormat) df.clone(); return df; } // @since 2.12 /** * Helper method for constructing description like "Object value" given * {@link JsonToken} encountered. */ protected String _shapeForToken(JsonToken t) { if (t != null) { switch (t) { // Likely Object values case START_OBJECT: case END_OBJECT: case FIELD_NAME: return "Object value"; // Likely Array values case START_ARRAY: case END_ARRAY: return "Array value"; case VALUE_FALSE: case VALUE_TRUE: return "Boolean value"; case VALUE_EMBEDDED_OBJECT: return "Embedded Object"; case VALUE_NUMBER_FLOAT: return "Floating-point value"; case VALUE_NUMBER_INT: return "Integer value"; case VALUE_STRING: return "String value"; case VALUE_NULL: return "Null value"; case NOT_AVAILABLE: default: return "[Unavailable value]"; } } return ""; } }