Class DeserializationContext

java.lang.Object
com.fasterxml.jackson.databind.DatabindContext
com.fasterxml.jackson.databind.DeserializationContext
All Implemented Interfaces:
Serializable
Direct Known Subclasses:
DefaultDeserializationContext

public abstract class DeserializationContext extends DatabindContext implements Serializable
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 ObjectMapper (and 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 (DefaultDeserializationContext.createInstance(com.fasterxml.jackson.databind.DeserializationConfig, com.fasterxml.jackson.core.JsonParser, com.fasterxml.jackson.databind.InjectableValues)). 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.

See Also:
  • Field Details

    • _cache

      protected final DeserializerCache _cache
      Object that handle details of JsonDeserializer caching.
    • _factory

      protected final DeserializerFactory _factory
      Read-only factory instance; exposed to let owners (ObjectMapper, ObjectReader) access it.
    • _config

      protected final DeserializationConfig _config
      Generic deserialization processing configuration
    • _featureFlags

      protected final int _featureFlags
      Bitmap of DeserializationFeatures that are enabled
    • _readCapabilities

      protected final com.fasterxml.jackson.core.util.JacksonFeatureSet<com.fasterxml.jackson.core.StreamReadCapability> _readCapabilities
      Capabilities of the input format.
      Since:
      2.12
    • _view

      protected final Class<?> _view
      Currently active view, if any.
    • _parser

      protected transient com.fasterxml.jackson.core.JsonParser _parser
      Currently active parser used for deserialization. May be different from the outermost parser when content is buffered.
    • _injectableValues

      protected final InjectableValues _injectableValues
      Object used for resolving references to injectable values.
    • _arrayBuilders

      protected transient ArrayBuilders _arrayBuilders
    • _objectBuffer

      protected transient ObjectBuffer _objectBuffer
    • _dateFormat

      protected transient DateFormat _dateFormat
    • _attributes

      protected transient ContextAttributes _attributes
      Lazily-constructed holder for per-call attributes.
      Since:
      2.3
    • _currentType

      protected LinkedNode<JavaType> _currentType
      Type of JsonDeserializer (or, more specifically, ContextualDeserializer) that is being contextualized currently.
      Since:
      2.5
  • Constructor Details

  • Method Details

    • getConfig

      public DeserializationConfig getConfig()
      Description copied from class: DatabindContext
      Accessor to currently active configuration (both per-request configs and per-mapper config).
      Specified by:
      getConfig in class DatabindContext
    • getActiveView

      public final Class<?> getActiveView()
      Description copied from class: DatabindContext
      Accessor for locating currently active view, if any; returns null if no view has been set.
      Specified by:
      getActiveView in class DatabindContext
    • canOverrideAccessModifiers

      public final boolean canOverrideAccessModifiers()
      Description copied from class: DatabindContext
      Convenience method for accessing serialization view in use (if any); equivalent to:
         getConfig().canOverrideAccessModifiers();
      
      Specified by:
      canOverrideAccessModifiers in class DatabindContext
    • isEnabled

      public final boolean isEnabled(MapperFeature feature)
      Description copied from class: DatabindContext
      Convenience method for checking whether specified Mapper feature is enabled or not. Shortcut for:
        getConfig().isEnabled(feature);
      
      Specified by:
      isEnabled in class DatabindContext
    • isEnabled

      public final boolean isEnabled(DatatypeFeature feature)
      Description copied from class: DatabindContext
      Method for checking whether specified datatype feature is enabled or not.
      Specified by:
      isEnabled in class DatabindContext
    • getDatatypeFeatures

      public final DatatypeFeatures getDatatypeFeatures()
      Specified by:
      getDatatypeFeatures in class DatabindContext
    • getDefaultPropertyFormat

      public final com.fasterxml.jackson.annotation.JsonFormat.Value getDefaultPropertyFormat(Class<?> baseType)
      Specified by:
      getDefaultPropertyFormat in class DatabindContext
    • getAnnotationIntrospector

      public final AnnotationIntrospector getAnnotationIntrospector()
      Description copied from class: DatabindContext
      Convenience method for accessing serialization view in use (if any); equivalent to:
         getConfig().getAnnotationIntrospector();
      
      Specified by:
      getAnnotationIntrospector in class DatabindContext
    • getTypeFactory

      public final TypeFactory getTypeFactory()
      Specified by:
      getTypeFactory in class DatabindContext
    • constructSpecializedType

      public JavaType constructSpecializedType(JavaType baseType, Class<?> subclass) throws IllegalArgumentException
      Description copied from class: DatabindContext
      Convenience method for constructing subtypes, retaining generic type parameter (if any).

      Note: since 2.11 handling has varied a bit across serialization, deserialization.

      Specified by:
      constructSpecializedType in class DatabindContext
      Throws:
      IllegalArgumentException
    • getLocale

      public Locale getLocale()
      Method for accessing default Locale to use: convenience method for
         getConfig().getLocale();
      
      Specified by:
      getLocale in class DatabindContext
    • getTimeZone

      public TimeZone getTimeZone()
      Method for accessing default TimeZone to use: convenience method for
         getConfig().getTimeZone();
      
      Specified by:
      getTimeZone in class DatabindContext
    • getAttribute

      public Object getAttribute(Object key)
      Description copied from class: DatabindContext
      Method for accessing attributes available in this context. Per-call attributes have highest precedence; attributes set via ObjectReader or ObjectWriter have lower precedence.
      Specified by:
      getAttribute in class DatabindContext
      Parameters:
      key - Key of the attribute to get
      Returns:
      Value of the attribute, if any; null otherwise
    • setAttribute

      public DeserializationContext setAttribute(Object key, Object value)
      Description copied from class: DatabindContext
      Method for setting per-call value of given attribute. This will override any previously defined value for the attribute within this context.
      Specified by:
      setAttribute in class DatabindContext
      Parameters:
      key - Key of the attribute to set
      value - Value to set attribute to
      Returns:
      This context object, to allow chaining
    • getContextualType

      public JavaType getContextualType()
      Accessor to JavaType of currently contextualized ContextualDeserializer, if any. This is sometimes useful for generic JsonDeserializers that do not get passed (or do not retain) type information when being constructed: happens for example for deserializers constructed from annotations.
      Returns:
      Type of ContextualDeserializer being contextualized, if process is on-going; null if not.
      Since:
      2.5
    • getFactory

      public DeserializerFactory getFactory()
      Method for getting current DeserializerFactory.
    • isEnabled

      public final boolean isEnabled(DeserializationFeature feat)
      Convenience method for checking whether specified on/off feature is enabled
    • isEnabled

      public final boolean isEnabled(com.fasterxml.jackson.core.StreamReadCapability cap)
      Accessor for checking whether input format has specified capability or not.
      Returns:
      True if input format has specified capability; false if not
      Since:
      2.12
    • getDeserializationFeatures

      public final int getDeserializationFeatures()
      Bulk access method for getting the bit mask of all DeserializationFeatures that are enabled.
      Since:
      2.6
    • hasDeserializationFeatures

      public final boolean hasDeserializationFeatures(int featureMask)
      Bulk access method for checking that all features specified by mask are enabled.
      Since:
      2.3
    • hasSomeOfFeatures

      public final boolean hasSomeOfFeatures(int featureMask)
      Bulk access method for checking that at least one of features specified by mask is enabled.
      Since:
      2.6
    • getParser

      public final com.fasterxml.jackson.core.JsonParser getParser()
      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.

    • findInjectableValue

      public final Object findInjectableValue(Object valueId, BeanProperty forProperty, Object beanInstance) throws JsonMappingException
      Throws:
      JsonMappingException
    • getBase64Variant

      public final com.fasterxml.jackson.core.Base64Variant getBase64Variant()
      Convenience method for accessing the default Base64 encoding used for decoding base64 encoded binary content. Same as calling:
        getConfig().getBase64Variant();
      
    • getNodeFactory

      public final JsonNodeFactory getNodeFactory()
      Convenience method, functionally equivalent to:
        getConfig().getNodeFactory();
       
    • findCoercionAction

      public CoercionAction findCoercionAction(LogicalType targetType, Class<?> targetClass, CoercionInputShape inputShape)
      General-purpose accessor for finding what to do when specified coercion from shape that is now always allowed to be coerced from is requested.
      Parameters:
      targetType - Logical target type of coercion
      targetClass - Physical target type of coercion
      inputShape - Input shape to coerce from
      Returns:
      CoercionAction configured for specific coercion
      Since:
      2.12
    • findCoercionFromBlankString

      public CoercionAction findCoercionFromBlankString(LogicalType targetType, Class<?> targetClass, CoercionAction actionIfBlankNotAllowed)
      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 actionIfBlankNotAllowed, otherwise returns action for CoercionInputShape.EmptyString.
      Parameters:
      targetType - Logical target type of coercion
      targetClass - Physical target type of coercion
      actionIfBlankNotAllowed - Return value to use in case "blanks as empty" is not allowed
      Returns:
      CoercionAction configured for specified coercion from blank string
      Since:
      2.12
    • bufferForInputBuffering

      public TokenBuffer bufferForInputBuffering(com.fasterxml.jackson.core.JsonParser p)
      Factory method used for creating TokenBuffer to temporarily contain copy of content read from specified parser; usually for purpose of reading contents later on (possibly augmeneted with injected additional content)
      Since:
      2.13
    • bufferForInputBuffering

      public final TokenBuffer bufferForInputBuffering()
      Convenience method that is equivalent to:
         ctxt.bufferForInputBuffering(ctxt.getParser());
      
    • bufferAsCopyOfValue

      public TokenBuffer bufferAsCopyOfValue(com.fasterxml.jackson.core.JsonParser p) throws IOException
      Convenience method, equivalent to:
       TokenBuffer buffer = ctxt.bufferForInputBuffering(parser);
       buffer.copyCurrentStructure(parser);
       return buffer;
      

      NOTE: the whole "current value" that parser points to is read and buffered, including Object and Array values (if parser pointing to start marker).

      Throws:
      IOException
      Since:
      2.9
    • hasValueDeserializerFor

      public boolean hasValueDeserializerFor(JavaType type, AtomicReference<Throwable> cause)
      Method for checking whether we could find a deserializer for given type.
      Parameters:
      type - Type to check
      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
    • findContextualValueDeserializer

      public final JsonDeserializer<Object> findContextualValueDeserializer(JavaType type, BeanProperty prop) throws JsonMappingException
      Method for finding a value deserializer, and creating a contextual version if necessary, for value reached via specified property.
      Throws:
      JsonMappingException
    • findNonContextualValueDeserializer

      public final JsonDeserializer<Object> findNonContextualValueDeserializer(JavaType type) throws JsonMappingException
      Variant that will try to locate deserializer for current type, but without performing any contextualization (unlike findContextualValueDeserializer(com.fasterxml.jackson.databind.JavaType, com.fasterxml.jackson.databind.BeanProperty)) or checking for need to create a TypeDeserializer (unlike findRootValueDeserializer(JavaType). This method is usually called from within ResolvableDeserializer.resolve(com.fasterxml.jackson.databind.DeserializationContext), and expectation is that caller then calls either handlePrimaryContextualization(JsonDeserializer, BeanProperty, JavaType) or handleSecondaryContextualization(JsonDeserializer, BeanProperty, JavaType) at a later point, as necessary.
      Throws:
      JsonMappingException
      Since:
      2.5
    • findRootValueDeserializer

      public final JsonDeserializer<Object> findRootValueDeserializer(JavaType type) throws JsonMappingException
      Method for finding a deserializer for root-level value.
      Throws:
      JsonMappingException
    • findKeyDeserializer

      public final KeyDeserializer findKeyDeserializer(JavaType keyType, BeanProperty prop) throws JsonMappingException
      Convenience method, functionally same as:
        getDeserializerProvider().findKeyDeserializer(getConfig(), prop.getType(), prop);
      
      Throws:
      JsonMappingException
    • findObjectId

      public abstract ReadableObjectId findObjectId(Object id, com.fasterxml.jackson.annotation.ObjectIdGenerator<?> generator, com.fasterxml.jackson.annotation.ObjectIdResolver resolver)
      Method called to find and return entry corresponding to given Object Id: will add an entry if necessary, and never returns null
    • checkUnresolvedObjectId

      public abstract void checkUnresolvedObjectId() throws UnresolvedForwardReference
      Method called to ensure that every object id encounter during processing are resolved.
      Throws:
      UnresolvedForwardReference
    • constructType

      public final JavaType constructType(Class<?> cls)
      Convenience method, functionally equivalent to:
        getConfig().constructType(cls);
       
    • findClass

      public Class<?> findClass(String className) throws ClassNotFoundException
      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.
      Throws:
      ClassNotFoundException
      Since:
      2.6
    • leaseObjectBuffer

      public final ObjectBuffer leaseObjectBuffer()
      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.
    • returnObjectBuffer

      public final void returnObjectBuffer(ObjectBuffer buf)
      Method to call to return object buffer previously leased with leaseObjectBuffer().
      Parameters:
      buf - Returned object buffer
    • getArrayBuilders

      public final ArrayBuilders getArrayBuilders()
      Method for accessing object useful for building arrays of primitive types (such as int[]).
    • deserializerInstance

      public abstract JsonDeserializer<Object> deserializerInstance(Annotated annotated, Object deserDef) throws JsonMappingException
      Throws:
      JsonMappingException
    • keyDeserializerInstance

      public abstract KeyDeserializer keyDeserializerInstance(Annotated annotated, Object deserDef) throws JsonMappingException
      Throws:
      JsonMappingException
    • handlePrimaryContextualization

      public JsonDeserializer<?> handlePrimaryContextualization(JsonDeserializer<?> deser, BeanProperty prop, JavaType type) throws JsonMappingException
      Method called for primary property deserializers (ones directly created to deserialize values of a POJO property), to handle details of resolving ContextualDeserializer with given property context.
      Parameters:
      prop - Property for which the given primary deserializer is used; never null.
      Throws:
      JsonMappingException
      Since:
      2.5
    • handleSecondaryContextualization

      public JsonDeserializer<?> handleSecondaryContextualization(JsonDeserializer<?> deser, BeanProperty prop, JavaType type) throws JsonMappingException
      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 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.
      Parameters:
      prop - Property for which deserializer is used, if any; null when deserializing root values
      Throws:
      JsonMappingException
      Since:
      2.5
    • parseDate

      public Date parseDate(String dateStr) throws IllegalArgumentException
      Convenience method for parsing a Date from given String, using currently configured date format (accessed using MapperConfig.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.

      Throws:
      IllegalArgumentException
    • constructCalendar

      public Calendar constructCalendar(Date d)
      Convenience method for constructing Calendar instance set to specified time, to be modified and used by caller.
    • extractScalarFromObject

      public String extractScalarFromObject(com.fasterxml.jackson.core.JsonParser p, JsonDeserializer<?> deser, Class<?> scalarType) throws IOException
      Method to call in case incoming shape is Object Value (and parser thereby points to 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.
      Parameters:
      p - Actual parser to read content from
      deser - Deserializer that needs extracted String value
      scalarType - Immediate type of scalar to extract; usually type deserializer handles but not always (for example, deserializer for int[] would pass scalar type of int)
      Returns:
      String value found; not 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
    • readValue

      public <T> T readValue(com.fasterxml.jackson.core.JsonParser p, Class<T> type) throws IOException
      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 readPropertyValue(JsonParser, BeanProperty, Class); this method does not allow use of contextual annotations.

      Throws:
      IOException
      Since:
      2.4
    • readValue

      public <T> T readValue(com.fasterxml.jackson.core.JsonParser p, JavaType type) throws IOException
      Throws:
      IOException
      Since:
      2.4
    • readPropertyValue

      public <T> T readPropertyValue(com.fasterxml.jackson.core.JsonParser p, BeanProperty prop, Class<T> type) throws IOException
      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.
      Parameters:
      p - Parser that points to the first token of the value to read
      prop - Logical property of a POJO being type
      Returns:
      Value of type type that was read
      Throws:
      IOException
      Since:
      2.4
    • readPropertyValue

      public <T> T readPropertyValue(com.fasterxml.jackson.core.JsonParser p, BeanProperty prop, JavaType type) throws IOException
      Same as readPropertyValue(JsonParser, BeanProperty, Class) but with fully resolved JavaType as target: needs to be used for generic types, for example.
      Throws:
      IOException
      Since:
      2.4
    • readTree

      public JsonNode readTree(com.fasterxml.jackson.core.JsonParser p) throws IOException
      Convenience method for reading the value that passed JsonParser points to as a JsonNode.
      Parameters:
      p - Parser that points to the first token of the value to read
      Returns:
      Value read as JsonNode
      Throws:
      IOException
      Since:
      2.10
    • readTreeAsValue

      public <T> T readTreeAsValue(JsonNode n, Class<T> targetType) throws IOException
      Helper method similar to ObjectReader.treeToValue(TreeNode, Class) which will read contents of given tree (JsonNode) and bind them into specified target type. This is often used in two-phase deserialization in which content is first read as a tree, then manipulated (adding and/or removing properties of Object values, for example), and finally converted into actual target type using default deserialization logic for the type.

      NOTE: deserializer implementations should be careful not to try to recursively deserialize into target type deserializer has registered itself to handle.

      Parameters:
      n - Tree value to convert, if not null: if null, will simply return null
      targetType - Type to deserialize contents of n into (if n not null)
      Returns:
      Either null (if n was null or a value of type type that was read from non-null n argument
      Throws:
      IOException
      Since:
      2.13
    • readTreeAsValue

      public <T> T readTreeAsValue(JsonNode n, JavaType targetType) throws IOException
      Same as readTreeAsValue(JsonNode, Class) but will fully resolved JavaType as targetType

      NOTE: deserializer implementations should be careful not to try to recursively deserialize into target type deserializer has registered itself to handle.

      Parameters:
      n - Tree value to convert
      targetType - Type to deserialize contents of n into
      Returns:
      Value of type type that was read
      Throws:
      IOException
      Since:
      2.13
    • handleUnknownProperty

      public boolean handleUnknownProperty(com.fasterxml.jackson.core.JsonParser p, JsonDeserializer<?> deser, Object instanceOrClass, String propName) throws IOException
      Method that deserializers should call if they encounter an unrecognized property (and once that is not explicitly designed as ignorable), to inform possibly configured DeserializationProblemHandlers and let it handle the problem.
      Returns:
      True if there was a configured problem handler that was able to handle the problem
      Throws:
      IOException
    • handleWeirdKey

      public Object handleWeirdKey(Class<?> keyClass, String keyValue, String msg, Object... msgArgs) throws IOException
      Method that deserializers should call if they encounter a String value that cannot be converted to expected key of a Map valued property. Default implementation will try to call DeserializationProblemHandler.handleWeirdNumberValue(com.fasterxml.jackson.databind.DeserializationContext, java.lang.Class<?>, java.lang.Number, java.lang.String) on configured handlers, if any, to allow for recovery; if recovery does not succeed, will throw InvalidFormatException with given message.
      Parameters:
      keyClass - Expected type for key
      keyValue - String value from which to deserialize key
      msg - Error message template caller wants to use if exception is to be thrown
      msgArgs - Optional arguments to use for message, if any
      Returns:
      Key value to use
      Throws:
      IOException - To indicate unrecoverable problem, usually based on msg
      Since:
      2.8
    • handleWeirdStringValue

      public Object handleWeirdStringValue(Class<?> targetClass, String value, String msg, Object... msgArgs) throws IOException
      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 DeserializationProblemHandler.handleWeirdStringValue(com.fasterxml.jackson.databind.DeserializationContext, java.lang.Class<?>, java.lang.String, java.lang.String) on configured handlers, if any, to allow for recovery; if recovery does not succeed, will throw InvalidFormatException with given message.
      Parameters:
      targetClass - Type of property into which incoming number should be converted
      value - String value from which to deserialize property value
      msg - Error message template caller wants to use if exception is to be thrown
      msgArgs - Optional arguments to use for message, if any
      Returns:
      Property value to use
      Throws:
      IOException - To indicate unrecoverable problem, usually based on msg
      Since:
      2.8
    • handleWeirdNumberValue

      public Object handleWeirdNumberValue(Class<?> targetClass, Number value, String msg, Object... msgArgs) throws IOException
      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 DeserializationProblemHandler.handleWeirdNumberValue(com.fasterxml.jackson.databind.DeserializationContext, java.lang.Class<?>, java.lang.Number, java.lang.String) on configured handlers, if any, to allow for recovery; if recovery does not succeed, will throw InvalidFormatException with given message.
      Parameters:
      targetClass - Type of property into which incoming number should be converted
      value - Number value from which to deserialize property value
      msg - Error message template caller wants to use if exception is to be thrown
      msgArgs - Optional arguments to use for message, if any
      Returns:
      Property value to use
      Throws:
      IOException - To indicate unrecoverable problem, usually based on msg
      Since:
      2.8
    • handleWeirdNativeValue

      public Object handleWeirdNativeValue(JavaType targetType, Object badValue, com.fasterxml.jackson.core.JsonParser p) throws IOException
      Throws:
      IOException
    • handleMissingInstantiator

      public Object handleMissingInstantiator(Class<?> instClass, ValueInstantiator valueInst, com.fasterxml.jackson.core.JsonParser p, String msg, Object... msgArgs) throws IOException
      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
      Parameters:
      instClass - Type that was to be instantiated
      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)
      p - Parser that points to the JSON value to decode
      Returns:
      Object that should be constructed, if any; has to be of type instClass
      Throws:
      IOException
      Since:
      2.9 (2.8 had alternate that did not take ValueInstantiator)
    • handleInstantiationProblem

      public Object handleInstantiationProblem(Class<?> instClass, Object argument, Throwable t) throws IOException
      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 DeserializationProblemHandler.handleInstantiationProblem(com.fasterxml.jackson.databind.DeserializationContext, java.lang.Class<?>, java.lang.Object, java.lang.Throwable) on configured handlers, if any, to allow for recovery; if recovery does not succeed, will throw exception constructed with instantiationException(java.lang.Class<?>, java.lang.Throwable).
      Parameters:
      instClass - Type that was to be instantiated
      argument - (optional) Argument that was passed to constructor or equivalent instantiator; often a String.
      t - Exception that caused failure
      Returns:
      Object that should be constructed, if any; has to be of type instClass
      Throws:
      IOException
      Since:
      2.8
    • handleUnexpectedToken

      public Object handleUnexpectedToken(Class<?> instClass, com.fasterxml.jackson.core.JsonParser p) throws IOException
      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 JsonToken.START_ARRAY instead of JsonToken.VALUE_NUMBER_INT or JsonToken.VALUE_NUMBER_FLOAT.
      Parameters:
      instClass - Type that was to be instantiated
      p - Parser that points to the JSON value to decode
      Returns:
      Object that should be constructed, if any; has to be of type instClass
      Throws:
      IOException
      Since:
      2.8
    • handleUnexpectedToken

      public Object handleUnexpectedToken(Class<?> instClass, com.fasterxml.jackson.core.JsonToken t, com.fasterxml.jackson.core.JsonParser p, String msg, Object... msgArgs) throws IOException
      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 JsonToken.START_ARRAY instead of JsonToken.VALUE_NUMBER_INT or JsonToken.VALUE_NUMBER_FLOAT.
      Parameters:
      instClass - Type that was to be instantiated
      t - Token encountered that does match expected
      p - Parser that points to the JSON value to decode
      Returns:
      Object that should be constructed, if any; has to be of type instClass
      Throws:
      IOException
      Since:
      2.8
    • handleUnexpectedToken

      public Object handleUnexpectedToken(JavaType targetType, com.fasterxml.jackson.core.JsonParser p) throws IOException
      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 JsonToken.START_ARRAY instead of JsonToken.VALUE_NUMBER_INT or JsonToken.VALUE_NUMBER_FLOAT.
      Parameters:
      targetType - Type that was to be instantiated
      p - Parser that points to the JSON value to decode
      Returns:
      Object that should be constructed, if any; has to be of type instClass
      Throws:
      IOException
      Since:
      2.10
    • handleUnexpectedToken

      public Object handleUnexpectedToken(JavaType targetType, com.fasterxml.jackson.core.JsonToken t, com.fasterxml.jackson.core.JsonParser p, String msg, Object... msgArgs) throws IOException
      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 JsonToken.START_ARRAY instead of JsonToken.VALUE_NUMBER_INT or JsonToken.VALUE_NUMBER_FLOAT.
      Parameters:
      targetType - Type that was to be instantiated
      t - Token encountered that does not match expected
      p - Parser that points to the JSON value to decode
      Returns:
      Object that should be constructed, if any; has to be of type instClass
      Throws:
      IOException
      Since:
      2.10
    • handleUnknownTypeId

      public JavaType handleUnknownTypeId(JavaType baseType, String id, TypeIdResolver idResolver, String extraDesc) throws IOException
      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 DeserializationProblemHandler.handleUnknownTypeId(com.fasterxml.jackson.databind.DeserializationContext, com.fasterxml.jackson.databind.JavaType, java.lang.String, com.fasterxml.jackson.databind.jsontype.TypeIdResolver, java.lang.String) on configured handlers, if any, to allow for recovery; if recovery does not succeed, will throw exception constructed with invalidTypeIdException(com.fasterxml.jackson.databind.JavaType, java.lang.String, java.lang.String).
      Parameters:
      baseType - Base type from which resolution starts
      id - Type id that could not be converted
      extraDesc - Additional problem description to add to default exception message, if resolution fails.
      Returns:
      JavaType that id resolves to
      Throws:
      IOException - To indicate unrecoverable problem, if resolution cannot be made to work
      Since:
      2.8
    • handleMissingTypeId

      public JavaType handleMissingTypeId(JavaType baseType, TypeIdResolver idResolver, String extraDesc) throws IOException
      Throws:
      IOException
      Since:
      2.9
    • handleBadMerge

      public void handleBadMerge(JsonDeserializer<?> deser) throws JsonMappingException
      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 MapperFeature.IGNORE_MERGE_FOR_UNMERGEABLE is enabled, this method will simply return null; otherwise InvalidDefinitionException will be thrown.
      Throws:
      JsonMappingException
      Since:
      2.10
    • _isCompatible

      protected boolean _isCompatible(Class<?> target, Object value)
      Since:
      2.9.2
    • reportWrongTokenException

      public void reportWrongTokenException(JsonDeserializer<?> deser, com.fasterxml.jackson.core.JsonToken expToken, String msg, Object... msgArgs) throws JsonMappingException
      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 JsonMappingException and no recovery is attempted (via DeserializationProblemHandler, as problem is considered to be difficult to recover from, in general.
      Throws:
      JsonMappingException
      Since:
      2.9
    • reportWrongTokenException

      public void reportWrongTokenException(JavaType targetType, com.fasterxml.jackson.core.JsonToken expToken, String msg, Object... msgArgs) throws JsonMappingException
      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 JsonMappingException and no recovery is attempted (via DeserializationProblemHandler, as problem is considered to be difficult to recover from, in general.
      Throws:
      JsonMappingException
      Since:
      2.9
    • reportWrongTokenException

      public void reportWrongTokenException(Class<?> targetType, com.fasterxml.jackson.core.JsonToken expToken, String msg, Object... msgArgs) throws JsonMappingException
      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 JsonMappingException and no recovery is attempted (via DeserializationProblemHandler, as problem is considered to be difficult to recover from, in general.
      Throws:
      JsonMappingException
      Since:
      2.9
    • reportUnresolvedObjectId

      public <T> T reportUnresolvedObjectId(ObjectIdReader oidReader, Object bean) throws JsonMappingException
      Throws:
      JsonMappingException
      Since:
      2.8
    • reportInputMismatch

      public <T> T reportInputMismatch(JsonDeserializer<?> src, String msg, Object... msgArgs) throws JsonMappingException
      Helper method used to indicate a problem with input in cases where more specific reportXxx() method was not available.
      Throws:
      JsonMappingException
      Since:
      2.9
    • reportInputMismatch

      public <T> T reportInputMismatch(Class<?> targetType, String msg, Object... msgArgs) throws JsonMappingException
      Helper method used to indicate a problem with input in cases where more specific reportXxx() method was not available.
      Throws:
      JsonMappingException
      Since:
      2.9
    • reportInputMismatch

      public <T> T reportInputMismatch(JavaType targetType, String msg, Object... msgArgs) throws JsonMappingException
      Helper method used to indicate a problem with input in cases where more specific reportXxx() method was not available.
      Throws:
      JsonMappingException
      Since:
      2.9
    • reportInputMismatch

      public <T> T reportInputMismatch(BeanProperty prop, String msg, Object... msgArgs) throws JsonMappingException
      Helper method used to indicate a problem with input in cases where more specific reportXxx() method was not available.
      Throws:
      JsonMappingException
      Since:
      2.9
    • reportPropertyInputMismatch

      public <T> T reportPropertyInputMismatch(Class<?> targetType, String propertyName, String msg, Object... msgArgs) throws JsonMappingException
      Helper method used to indicate a problem with input in cases where more specific reportXxx() method was not available.
      Throws:
      JsonMappingException
      Since:
      2.10
    • reportPropertyInputMismatch

      public <T> T reportPropertyInputMismatch(JavaType targetType, String propertyName, String msg, Object... msgArgs) throws JsonMappingException
      Helper method used to indicate a problem with input in cases where more specific reportXxx() method was not available.
      Throws:
      JsonMappingException
      Since:
      2.10
    • reportBadCoercion

      public <T> T reportBadCoercion(JsonDeserializer<?> src, Class<?> targetType, Object inputValue, String msg, Object... msgArgs) throws JsonMappingException
      Helper method used to indicate a problem with input in cases where specific input coercion was not allowed.
      Throws:
      JsonMappingException
      Since:
      2.12
    • reportTrailingTokens

      public <T> T reportTrailingTokens(Class<?> targetType, com.fasterxml.jackson.core.JsonParser p, com.fasterxml.jackson.core.JsonToken trailingToken) throws JsonMappingException
      Throws:
      JsonMappingException
    • reportBadTypeDefinition

      public <T> T reportBadTypeDefinition(BeanDescription bean, String msg, Object... msgArgs) throws JsonMappingException
      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 JsonMappingException.
      Throws:
      JsonMappingException
      Since:
      2.9
    • reportBadPropertyDefinition

      public <T> T reportBadPropertyDefinition(BeanDescription bean, BeanPropertyDefinition prop, String msg, Object... msgArgs) throws JsonMappingException
      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 JsonMappingException.
      Throws:
      JsonMappingException
      Since:
      2.9
    • reportBadDefinition

      public <T> T reportBadDefinition(JavaType type, String msg) throws JsonMappingException
      Description copied from class: DatabindContext
      Helper method called to indicate a generic problem that stems from type definition(s), not input data, or input/output state; typically this means throwing a InvalidDefinitionException.
      Specified by:
      reportBadDefinition in class DatabindContext
      Throws:
      JsonMappingException
    • wrongTokenException

      public JsonMappingException wrongTokenException(com.fasterxml.jackson.core.JsonParser p, JavaType targetType, com.fasterxml.jackson.core.JsonToken expToken, String extra)
      Helper method for constructing 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, reportWrongTokenException(com.fasterxml.jackson.databind.JsonDeserializer<?>, com.fasterxml.jackson.core.JsonToken, java.lang.String, java.lang.Object...) should be called and will call this method as necessary.
      Since:
      2.9
    • wrongTokenException

      public JsonMappingException wrongTokenException(com.fasterxml.jackson.core.JsonParser p, Class<?> targetType, com.fasterxml.jackson.core.JsonToken expToken, String extra)
    • weirdKeyException

      public JsonMappingException weirdKeyException(Class<?> keyClass, String keyValue, String 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, handleWeirdKey(java.lang.Class<?>, java.lang.String, java.lang.String, java.lang.Object...) should be called which will call this method if necessary.
    • weirdStringException

      public JsonMappingException weirdStringException(String value, Class<?> instClass, String msgBase)
      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, handleWeirdStringValue(java.lang.Class<?>, java.lang.String, java.lang.String, java.lang.Object...) should be called which will call this method if necessary.
      Parameters:
      value - String value from input being deserialized
      instClass - Type that String should be deserialized into
      msgBase - Message that describes specific problem
      Since:
      2.1
    • weirdNumberException

      public JsonMappingException weirdNumberException(Number value, Class<?> instClass, String msg)
      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, handleWeirdNumberValue(java.lang.Class<?>, java.lang.Number, java.lang.String, java.lang.Object...) should be called which will call this method if necessary.
    • weirdNativeValueException

      public JsonMappingException weirdNativeValueException(Object value, Class<?> instClass)
      Helper method for constructing exception to indicate that input JSON token of type "native value" (see 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, handleWeirdNativeValue(com.fasterxml.jackson.databind.JavaType, java.lang.Object, com.fasterxml.jackson.core.JsonParser) should be called which will call this method
      Since:
      2.9
    • instantiationException

      public JsonMappingException instantiationException(Class<?> instClass, Throwable cause)
      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, handleInstantiationProblem(java.lang.Class<?>, java.lang.Object, java.lang.Throwable) should be called which will call this method if necessary.

    • instantiationException

      public JsonMappingException instantiationException(Class<?> instClass, String msg0)
      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, handleMissingInstantiator(java.lang.Class<?>, com.fasterxml.jackson.databind.deser.ValueInstantiator, com.fasterxml.jackson.core.JsonParser, java.lang.String, java.lang.Object...) should be called which will call this method if necessary.

    • invalidTypeIdException

      public JsonMappingException invalidTypeIdException(JavaType baseType, String typeId, String extraDesc)
      Description copied from class: DatabindContext
      Helper method for constructing exception to indicate that given type id could not be resolved to a valid subtype of specified base type. Most commonly called during polymorphic deserialization.

      Note that most of the time this method should NOT be called directly: instead, method handleUnknownTypeId() should be called which will call this method if necessary.

      Specified by:
      invalidTypeIdException in class DatabindContext
    • missingTypeIdException

      public JsonMappingException missingTypeIdException(JavaType baseType, String extraDesc)
      Since:
      2.9
    • _getDateFormat

      protected DateFormat _getDateFormat()
    • _shapeForToken

      protected String _shapeForToken(com.fasterxml.jackson.core.JsonToken t)
      Helper method for constructing description like "Object value" given JsonToken encountered.
      Since:
      2.12