com.fasterxml.jackson.databind

## Class DeserializationContext

- java.lang.Object
- - com.fasterxml.jackson.databind.DatabindContext
  - - com.fasterxml.jackson.databind.DeserializationContext

- All Implemented Interfaces:
    java.io.Serializable
  Direct Known Subclasses:
    DefaultDeserializationContext

      public abstract class DeserializationContext
      extends DatabindContext
      implements java.io.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 an partially configured "blueprint" object is registered with `ObjectMapper` (and `ObjectReader`, and when an actual instance is needed for deserialization, a fully configured instance will be created using a method in excented 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 iff no configuration has changed.

  Defined as abstract class so that implementations must define methods for reconfiguring blueprints and creating instances.

  See Also:
    Serialized Form

- - ### Field Summary

    Fields
    Modifier and Type | Field and Description
    --- | ---
    `protected ArrayBuilders` | `_arrayBuilders`
    `protected ContextAttributes` | `_attributes` Lazily-constructed holder for per-call attributes.
    `protected DeserializerCache` | `_cache` Object that handle details of `JsonDeserializer` caching.
    `protected DeserializationConfig` | `_config` Generic deserialization processing configuration
    `protected LinkedNode<JavaType>` | `_currentType` Type of `JsonDeserializer` (or, more specifically, `ContextualDeserializer`) that is being contextualized currently.
    `protected java.text.DateFormat` | `_dateFormat`
    `protected DeserializerFactory` | `_factory` Read-only factory instance; exposed to let owners (`ObjectMapper`, `ObjectReader`) access it.
    `protected int` | `_featureFlags` Bitmap of `DeserializationFeature`s that are enabled
    `protected InjectableValues` | `_injectableValues` Object used for resolving references to injectable values.
    `protected ObjectBuffer` | `_objectBuffer`
    `protected com.fasterxml.jackson.core.JsonParser` | `_parser` Currently active parser used for deserialization.
    `protected java.lang.Class<?>` | `_view` Currently active view, if any.

  - ### Constructor Summary

    Constructors
    Modifier | Constructor and Description
    --- | ---
    `protected` | `DeserializationContext(DeserializationContext src)` Copy-constructor for use with `copy()` by `ObjectMapper.copy()`
    `protected` | `DeserializationContext(DeserializationContext src, DeserializationConfig config, com.fasterxml.jackson.core.JsonParser p, InjectableValues injectableValues)` Constructor used for creating actual per-call instances.
    `protected` | `DeserializationContext(DeserializationContext src, DeserializerFactory factory)`
    `protected` | `DeserializationContext(DeserializerFactory df)`
    `protected` | `DeserializationContext(DeserializerFactory df, DeserializerCache cache)`

  - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `protected java.lang.String` | `_calcName(java.lang.Class<?> cls)`
    `protected java.lang.String` | `_desc(java.lang.String desc)`
    `protected java.lang.String` | `_quotedString(java.lang.String desc)`
    `protected java.lang.String` | `_valueDesc()`
    `boolean` | `canOverrideAccessModifiers()` Convenience method for accessing serialization view in use (if any); equivalent to:
    `abstract void` | `checkUnresolvedObjectId()` Method called to ensure that every object id encounter during processing are resolved.
    `java.util.Calendar` | `constructCalendar(java.util.Date d)` Convenience method for constructing Calendar instance set to specified time, to be modified and used by caller.
    `JavaType` | `constructType(java.lang.Class<?> cls)` Convenience method, functionally equivalent to:
    `abstract JsonDeserializer<java.lang.Object>` | `deserializerInstance(Annotated annotated, java.lang.Object deserDef)`
    `protected java.lang.String` | `determineClassName(java.lang.Object instance)`
    `JsonMappingException` | `endOfInputException(java.lang.Class<?> instClass)` Deprecated. Since 2.8; currently no way to catch EOF at databind level
    `java.lang.Class<?>` | `findClass(java.lang.String className)` 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.
    `JsonDeserializer<java.lang.Object>` | `findContextualValueDeserializer(JavaType type, BeanProperty prop)` Method for finding a value deserializer, and creating a contextual version if necessary, for value reached via specified property.
    `java.lang.Object` | `findInjectableValue(java.lang.Object valueId, BeanProperty forProperty, java.lang.Object beanInstance)`
    `KeyDeserializer` | `findKeyDeserializer(JavaType keyType, BeanProperty prop)` Convenience method, functionally same as:
    `JsonDeserializer<java.lang.Object>` | `findNonContextualValueDeserializer(JavaType type)` 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)`.
    `abstract ReadableObjectId` | `findObjectId(java.lang.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
    `JsonDeserializer<java.lang.Object>` | `findRootValueDeserializer(JavaType type)` Method for finding a deserializer for root-level value.
    `java.lang.Class<?>` | `getActiveView()` Accessor for locating currently active view, if any; returns null if no view has been set.
    `AnnotationIntrospector` | `getAnnotationIntrospector()` Convenience method for accessing serialization view in use (if any); equivalent to:
    `ArrayBuilders` | `getArrayBuilders()` Method for accessing object useful for building arrays of primitive types (such as int[]).
    `java.lang.Object` | `getAttribute(java.lang.Object key)` Method for accessing attributes available in this context.
    `com.fasterxml.jackson.core.Base64Variant` | `getBase64Variant()` Convenience method for accessing the default Base64 encoding used for decoding base64 encoded binary content.
    `DeserializationConfig` | `getConfig()` Accessor to currently active configuration (both per-request configs and per-mapper config).
    `JavaType` | `getContextualType()` Accessor to `JavaType` of currently contextualized `ContextualDeserializer`, if any.
    `protected java.text.DateFormat` | `getDateFormat()`
    `com.fasterxml.jackson.annotation.JsonFormat.Value` | `getDefaultPropertyFormat(java.lang.Class<?> baseType)`
    `int` | `getDeserializationFeatures()` Bulk access method for getting the bit mask of all `DeserializationFeature`s that are enabled.
    `DeserializerFactory` | `getFactory()` Method for getting current `DeserializerFactory`.
    `java.util.Locale` | `getLocale()` Method for accessing default Locale to use: convenience method for
    `JsonNodeFactory` | `getNodeFactory()` Convenience method, functionally equivalent to:
    `com.fasterxml.jackson.core.JsonParser` | `getParser()` Method for accessing the currently active parser.
    `java.util.TimeZone` | `getTimeZone()` Method for accessing default TimeZone to use: convenience method for
    `TypeFactory` | `getTypeFactory()`
    `java.lang.Object` | `handleInstantiationProblem(java.lang.Class<?> instClass, java.lang.Object argument, java.lang.Throwable t)` 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).
    `java.lang.Object` | `handleMissingInstantiator(java.lang.Class<?> instClass, com.fasterxml.jackson.core.JsonParser p, java.lang.String msg, java.lang.Object... msgArgs)` 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).
    `JsonDeserializer<?>` | `handlePrimaryContextualization(JsonDeserializer<?> deser, BeanProperty prop)` Deprecated.
    `JsonDeserializer<?>` | `handlePrimaryContextualization(JsonDeserializer<?> deser, BeanProperty prop, JavaType type)` 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.
    `JsonDeserializer<?>` | `handleSecondaryContextualization(JsonDeserializer<?> deser, BeanProperty prop)` Deprecated.
    `JsonDeserializer<?>` | `handleSecondaryContextualization(JsonDeserializer<?> deser, BeanProperty prop, JavaType type)` 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.
    `java.lang.Object` | `handleUnexpectedToken(java.lang.Class<?> instClass, com.fasterxml.jackson.core.JsonParser p)` 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 can not handle).
    `java.lang.Object` | `handleUnexpectedToken(java.lang.Class<?> instClass, com.fasterxml.jackson.core.JsonToken t, com.fasterxml.jackson.core.JsonParser p, java.lang.String msg, java.lang.Object... 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 can not handle).
    `boolean` | `handleUnknownProperty(com.fasterxml.jackson.core.JsonParser p, JsonDeserializer<?> deser, java.lang.Object instanceOrClass, java.lang.String propName)` Method that deserializers should call if they encounter an unrecognized property (and once that is not explicitly designed as ignorable), to inform possibly configured `DeserializationProblemHandler`s and let it handle the problem.
    `JavaType` | `handleUnknownTypeId(JavaType baseType, java.lang.String id, TypeIdResolver idResolver, java.lang.String extraDesc)` Method that deserializers should call if they encounter a type id (for polymorphic deserialization) that can not be resolved to an actual type; usually since there is no mapping defined.
    `java.lang.Object` | `handleWeirdKey(java.lang.Class<?> keyClass, java.lang.String keyValue, java.lang.String msg, java.lang.Object... msgArgs)` Method that deserializers should call if they encounter a String value that can not be converted to expected key of a `Map` valued property.
    `java.lang.Object` | `handleWeirdNumberValue(java.lang.Class<?> targetClass, java.lang.Number value, java.lang.String msg, java.lang.Object... msgArgs)` Method that deserializers should call if they encounter a numeric value that can not be converted to target property type, in cases where some numeric values could be acceptable (either with different settings, or different numeric value).
    `java.lang.Object` | `handleWeirdStringValue(java.lang.Class<?> targetClass, java.lang.String value, java.lang.String msg, java.lang.Object... msgArgs)` Method that deserializers should call if they encounter a String value that can not be converted to target property type, in cases where some String values could be acceptable (either with different settings, or different value).
    `boolean` | `hasDeserializationFeatures(int featureMask)` Bulk access method for checking that all features specified by mask are enabled.
    `boolean` | `hasSomeOfFeatures(int featureMask)` Bulk access method for checking that at least one of features specified by mask is enabled.
    `boolean` | `hasValueDeserializerFor(JavaType type, java.util.concurrent.atomic.AtomicReference<java.lang.Throwable> cause)` Method for checking whether we could find a deserializer for given type.
    `JsonMappingException` | `instantiationException(java.lang.Class<?> instClass, java.lang.String msg)` Helper method for constructing instantiation exception for specified type, to indicate that instantiation failed due to missing instantiator (creator; constructor or factory method).
    `JsonMappingException` | `instantiationException(java.lang.Class<?> instClass, java.lang.Throwable t)` Helper method for constructing instantiation exception for specified type, to indicate problem with physically constructing instance of specified class (missing constructor, exception from constructor)
    `boolean` | `isEnabled(DeserializationFeature feat)` Convenience method for checking whether specified on/off feature is enabled
    `boolean` | `isEnabled(MapperFeature feature)` Convenience method for checking whether specified serialization feature is enabled or not.
    `abstract KeyDeserializer` | `keyDeserializerInstance(Annotated annotated, java.lang.Object deserDef)`
    `ObjectBuffer` | `leaseObjectBuffer()` Method that can be used to get access to a reusable ObjectBuffer, useful for efficiently constructing Object arrays and Lists.
    `JsonMappingException` | `mappingException(java.lang.Class<?> targetClass)` Deprecated. Since 2.8 use `handleUnexpectedToken(Class, JsonParser)` instead
    `JsonMappingException` | `mappingException(java.lang.Class<?> targetClass, com.fasterxml.jackson.core.JsonToken token)` Deprecated. Since 2.8 use `handleUnexpectedToken(Class, JsonParser)` instead
    `JsonMappingException` | `mappingException(java.lang.String message)` Helper method for constructing generic mapping exception with specified message and current location information.
    `JsonMappingException` | `mappingException(java.lang.String msgTemplate, java.lang.Object... args)` 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 `reportMappingException(String, Object...)` instead.
    `java.util.Date` | `parseDate(java.lang.String dateStr)` Convenience method for parsing a Date from given String, using currently configured date format (accessed using `MapperConfig.getDateFormat()`).
    `<T> T` | `readPropertyValue(com.fasterxml.jackson.core.JsonParser p, BeanProperty prop, java.lang.Class<T> type)` 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.
    `<T> T` | `readPropertyValue(com.fasterxml.jackson.core.JsonParser p, BeanProperty prop, JavaType type)`
    `<T> T` | `readValue(com.fasterxml.jackson.core.JsonParser p, java.lang.Class<T> type)` 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).
    `<T> T` | `readValue(com.fasterxml.jackson.core.JsonParser p, JavaType type)`
    `<T> T` | `reportBadPropertyDefinition(BeanDescription bean, BeanPropertyDefinition prop, java.lang.String message, java.lang.Object... args)` 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.
    `<T> T` | `reportBadTypeDefinition(BeanDescription bean, java.lang.String message, java.lang.Object... args)` Helper method called to indicate problem in POJO (serialization) definitions or settings regarding specific Java type, unrelated to actual JSON content to map.
    `void` | `reportMappingException(java.lang.String msg, java.lang.Object... msgArgs)`
    `void` | `reportMissingContent(java.lang.String msg, java.lang.Object... msgArgs)`
    `void` | `reportUnknownProperty(java.lang.Object instanceOrClass, java.lang.String fieldName, JsonDeserializer<?> deser)` Deprecated. Since 2.8 call `handleUnknownProperty(com.fasterxml.jackson.core.JsonParser, com.fasterxml.jackson.databind.JsonDeserializer<?>, java.lang.Object, java.lang.String)` instead
    `void` | `reportUnresolvedObjectId(ObjectIdReader oidReader, java.lang.Object bean)`
    `void` | `reportWrongTokenException(com.fasterxml.jackson.core.JsonParser p, com.fasterxml.jackson.core.JsonToken expToken, java.lang.String msg, java.lang.Object... msgArgs)` 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.
    `void` | `returnObjectBuffer(ObjectBuffer buf)` Method to call to return object buffer previously leased with `leaseObjectBuffer()`.
    `DeserializationContext` | `setAttribute(java.lang.Object key, java.lang.Object value)` Method for setting per-call value of given attribute.
    `JsonMappingException` | `unknownTypeException(JavaType type, java.lang.String id, java.lang.String extraDesc)` Deprecated. Since 2.8 use `handleUnknownTypeId(com.fasterxml.jackson.databind.JavaType, java.lang.String, com.fasterxml.jackson.databind.jsontype.TypeIdResolver, java.lang.String)` instead
    `JsonMappingException` | `unknownTypeIdException(JavaType baseType, java.lang.String typeId, java.lang.String extraDesc)` Helper method for constructing exception to indicate that given type id could not be resolved to a valid subtype of specified base type, during polymorphic deserialization.
    `JsonMappingException` | `weirdKeyException(java.lang.Class<?> keyClass, java.lang.String keyValue, java.lang.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.
    `JsonMappingException` | `weirdNumberException(java.lang.Number value, java.lang.Class<?> instClass, java.lang.String msg)` Helper method for constructing exception to indicate that input JSON Number was not suitable for deserializing into given target type.
    `JsonMappingException` | `weirdStringException(java.lang.String value, java.lang.Class<?> instClass, java.lang.String msg)` Helper method for constructing exception to indicate that input JSON String was not suitable for deserializing into given target type.
    `JsonMappingException` | `wrongTokenException(com.fasterxml.jackson.core.JsonParser p, com.fasterxml.jackson.core.JsonToken expToken, java.lang.String msg0)` 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.

    - ### Methods inherited from class com.fasterxml.jackson.databind.DatabindContext

      `constructSpecializedType, constructType, converterInstance, objectIdGeneratorInstance, objectIdResolverInstance`

    - ### Methods inherited from class java.lang.Object

      `clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

- - ### Field Detail

    - #### _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 `DeserializationFeature`s that are enabled

    - #### _view

          protected final java.lang.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 java.text.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 Detail

    - #### DeserializationContext

          protected DeserializationContext(DeserializerFactory df)

    - #### DeserializationContext

          protected DeserializationContext(DeserializerFactory df,
                                DeserializerCache cache)

    - #### DeserializationContext

          protected DeserializationContext(DeserializationContext src,
                                DeserializerFactory factory)

    - #### DeserializationContext

          protected DeserializationContext(DeserializationContext src,
                                DeserializationConfig config,
                                com.fasterxml.jackson.core.JsonParser p,
                                InjectableValues injectableValues)

      Constructor used for creating actual per-call instances.

    - #### DeserializationContext

          protected DeserializationContext(DeserializationContext src)

      Copy-constructor for use with `copy()` by `ObjectMapper.copy()`

  - ### Method Detail

    - #### 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 java.lang.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 serialization feature is enabled or not. Shortcut for:

            getConfig().isEnabled(feature);

      Specified by:
        `isEnabled` in class `DatabindContext`

    - #### getDefaultPropertyFormat

          public final com.fasterxml.jackson.annotation.JsonFormat.Value getDefaultPropertyFormat(java.lang.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`

    - #### getLocale

          public java.util.Locale getLocale()

      Method for accessing default Locale to use: convenience method for

             getConfig().getLocale();

      Specified by:
        `getLocale` in class `DatabindContext`

    - #### getTimeZone

          public java.util.TimeZone getTimeZone()

      Method for accessing default TimeZone to use: convenience method for

             getConfig().getTimeZone();

      Specified by:
        `getTimeZone` in class `DatabindContext`

    - #### getAttribute

          public java.lang.Object getAttribute(java.lang.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(java.lang.Object key,
                                            java.lang.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 `JsonDeserializer`s 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

    - #### getDeserializationFeatures

          public final int getDeserializationFeatures()

      Bulk access method for getting the bit mask of all `DeserializationFeature`s 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 java.lang.Object findInjectableValue(java.lang.Object valueId,
                                             BeanProperty forProperty,
                                             java.lang.Object beanInstance)

    - #### 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();

    - #### hasValueDeserializerFor

          public boolean hasValueDeserializerFor(JavaType type,
                                        java.util.concurrent.atomic.AtomicReference<java.lang.Throwable> cause)

      Method for checking whether we could find a deserializer for given type.
      Parameters:
        `type` -
      Since:
        2.3

    - #### findContextualValueDeserializer

          public final JsonDeserializer<java.lang.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<java.lang.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<java.lang.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(java.lang.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(java.lang.Class<?> cls)

      Convenience method, functionally equivalent to:

            getConfig().constructType(cls);

    - #### findClass

          public java.lang.Class<?> findClass(java.lang.String className)
                                       throws java.lang.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:
        `java.lang.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<java.lang.Object> deserializerInstance(Annotated annotated,
                                                                java.lang.Object deserDef)
                                                                           throws JsonMappingException

      Throws:
        `JsonMappingException`

    - #### keyDeserializerInstance

          public abstract KeyDeserializer keyDeserializerInstance(Annotated annotated,
                                                java.lang.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

    - #### handlePrimaryContextualization

          @Deprecated
          public JsonDeserializer<?> handlePrimaryContextualization(JsonDeserializer<?> deser,
                                                                      BeanProperty prop)
                                                             throws JsonMappingException

      Deprecated.
      Throws:
        `JsonMappingException`

    - #### handleSecondaryContextualization

          @Deprecated
          public JsonDeserializer<?> handleSecondaryContextualization(JsonDeserializer<?> deser,
                                                                        BeanProperty prop)
                                                               throws JsonMappingException

      Deprecated.
      Throws:
        `JsonMappingException`

    - #### parseDate

          public java.util.Date parseDate(java.lang.String dateStr)
                                   throws java.lang.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:
        `java.lang.IllegalArgumentException`

    - #### constructCalendar

          public java.util.Calendar constructCalendar(java.util.Date d)

      Convenience method for constructing Calendar instance set to specified time, to be modified and used by caller.

    - #### readValue

          public <T> T readValue(com.fasterxml.jackson.core.JsonParser p,
                        java.lang.Class<T> type)
                      throws java.io.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:
        `java.io.IOException`
      Since:
        2.4

    - #### readValue

          public <T> T readValue(com.fasterxml.jackson.core.JsonParser p,
                        JavaType type)
                      throws java.io.IOException

      Throws:
        `java.io.IOException`
      Since:
        2.4

    - #### readPropertyValue

          public <T> T readPropertyValue(com.fasterxml.jackson.core.JsonParser p,
                                BeanProperty prop,
                                java.lang.Class<T> type)
                              throws java.io.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.
      Throws:
        `java.io.IOException`
      Since:
        2.4

    - #### readPropertyValue

          public <T> T readPropertyValue(com.fasterxml.jackson.core.JsonParser p,
                                BeanProperty prop,
                                JavaType type)
                              throws java.io.IOException

      Throws:
        `java.io.IOException`
      Since:
        2.4

    - #### handleUnknownProperty

          public boolean handleUnknownProperty(com.fasterxml.jackson.core.JsonParser p,
                                      JsonDeserializer<?> deser,
                                      java.lang.Object instanceOrClass,
                                      java.lang.String propName)
                                        throws java.io.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 `DeserializationProblemHandler`s and let it handle the problem.
      Returns:
        True if there was a configured problem handler that was able to handle the problem
      Throws:
        `java.io.IOException`

    - #### handleWeirdKey

          public java.lang.Object handleWeirdKey(java.lang.Class<?> keyClass,
                                        java.lang.String keyValue,
                                        java.lang.String msg,
                                        java.lang.Object... msgArgs)
                                          throws java.io.IOException

      Method that deserializers should call if they encounter a String value that can not 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:
        `java.io.IOException` - To indicate unrecoverable problem, usually based on `msg`
      Since:
        2.8

    - #### handleWeirdStringValue

          public java.lang.Object handleWeirdStringValue(java.lang.Class<?> targetClass,
                                                java.lang.String value,
                                                java.lang.String msg,
                                                java.lang.Object... msgArgs)
                                                  throws java.io.IOException

      Method that deserializers should call if they encounter a String value that can not be converted to target property type, in cases where some String values could be acceptable (either with different settings, or different value). Default implementation will try to call `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:
        `java.io.IOException` - To indicate unrecoverable problem, usually based on `msg`
      Since:
        2.8

    - #### handleWeirdNumberValue

          public java.lang.Object handleWeirdNumberValue(java.lang.Class<?> targetClass,
                                                java.lang.Number value,
                                                java.lang.String msg,
                                                java.lang.Object... msgArgs)
                                                  throws java.io.IOException

      Method that deserializers should call if they encounter a numeric value that can not be converted to target property type, in cases where some numeric values could be acceptable (either with different settings, or different numeric value). Default implementation will try to call `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:
        `java.io.IOException` - To indicate unrecoverable problem, usually based on `msg`
      Since:
        2.8

    - #### handleMissingInstantiator

          public java.lang.Object handleMissingInstantiator(java.lang.Class<?> instClass,
                                                   com.fasterxml.jackson.core.JsonParser p,
                                                   java.lang.String msg,
                                                   java.lang.Object... msgArgs)
                                                     throws java.io.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
        `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:
        `java.io.IOException`
      Since:
        2.8

    - #### handleInstantiationProblem

          public java.lang.Object handleInstantiationProblem(java.lang.Class<?> instClass,
                                                    java.lang.Object argument,
                                                    java.lang.Throwable t)
                                                      throws java.io.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:
        `java.io.IOException`
      Since:
        2.8

    - #### handleUnexpectedToken

          public java.lang.Object handleUnexpectedToken(java.lang.Class<?> instClass,
                                               com.fasterxml.jackson.core.JsonParser p)
                                                 throws java.io.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 can not 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:
        `java.io.IOException`
      Since:
        2.8

    - #### handleUnexpectedToken

          public java.lang.Object handleUnexpectedToken(java.lang.Class<?> instClass,
                                               com.fasterxml.jackson.core.JsonToken t,
                                               com.fasterxml.jackson.core.JsonParser p,
                                               java.lang.String msg,
                                               java.lang.Object... msgArgs)
                                                 throws java.io.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 can not 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:
        `java.io.IOException`
      Since:
        2.8

    - #### handleUnknownTypeId

          public JavaType handleUnknownTypeId(JavaType baseType,
                                     java.lang.String id,
                                     TypeIdResolver idResolver,
                                     java.lang.String extraDesc)
                                       throws java.io.IOException

      Method that deserializers should call if they encounter a type id (for polymorphic deserialization) that can not 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 `unknownTypeIdException(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:
        `java.io.IOException` - To indicate unrecoverable problem, if resolution can not be made to work
      Since:
        2.8

    - #### reportWrongTokenException

          public void reportWrongTokenException(com.fasterxml.jackson.core.JsonParser p,
                                       com.fasterxml.jackson.core.JsonToken expToken,
                                       java.lang.String msg,
                                       java.lang.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.8

    - #### reportUnknownProperty

          @Deprecated
          public void reportUnknownProperty(java.lang.Object instanceOrClass,
                                              java.lang.String fieldName,
                                              JsonDeserializer<?> deser)
                                     throws JsonMappingException

      Deprecated. Since 2.8 call `handleUnknownProperty(com.fasterxml.jackson.core.JsonParser, com.fasterxml.jackson.databind.JsonDeserializer<?>, java.lang.Object, java.lang.String)` instead
      Helper method for reporting a problem with unhandled unknown property.
      Parameters:
        `instanceOrClass` - Either value being populated (if one has been instantiated), or Class that indicates type that would be (or have been) instantiated
        `deser` - Deserializer that had the problem, if called by deserializer (or on behalf of one)
      Throws:
        `JsonMappingException`

    - #### reportMappingException

          public void reportMappingException(java.lang.String msg,
                                    java.lang.Object... msgArgs)
                                      throws JsonMappingException

      Throws:
        `JsonMappingException`
      Since:
        2.8

    - #### reportMissingContent

          public void reportMissingContent(java.lang.String msg,
                                  java.lang.Object... msgArgs)
                                    throws JsonMappingException

      Throws:
        `JsonMappingException`
      Since:
        2.8

    - #### reportUnresolvedObjectId

          public void reportUnresolvedObjectId(ObjectIdReader oidReader,
                                      java.lang.Object bean)
                                        throws JsonMappingException

      Throws:
        `JsonMappingException`
      Since:
        2.8

    - #### reportBadTypeDefinition

          public <T> T reportBadTypeDefinition(BeanDescription bean,
                                      java.lang.String message,
                                      java.lang.Object... args)
                                    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,
                                          java.lang.String message,
                                          java.lang.Object... args)
                                        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

    - #### mappingException

          public JsonMappingException mappingException(java.lang.String 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 `reportMappingException(String, Object...)` instead.
      Since:
        2.6

    - #### mappingException

          public JsonMappingException mappingException(java.lang.String msgTemplate,
                                              java.lang.Object... args)

      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 `reportMappingException(String, Object...)` instead.
      Since:
        2.6

    - #### mappingException

          @Deprecated
          public JsonMappingException mappingException(java.lang.Class<?> targetClass)

      Deprecated. Since 2.8 use `handleUnexpectedToken(Class, JsonParser)` instead
      Helper method for constructing generic mapping exception for specified type

    - #### mappingException

          @Deprecated
          public JsonMappingException mappingException(java.lang.Class<?> targetClass,
                                                         com.fasterxml.jackson.core.JsonToken token)

      Deprecated. Since 2.8 use `handleUnexpectedToken(Class, JsonParser)` instead

    - #### wrongTokenException

          public JsonMappingException wrongTokenException(com.fasterxml.jackson.core.JsonParser p,
                                                 com.fasterxml.jackson.core.JsonToken expToken,
                                                 java.lang.String msg0)

      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.core.JsonParser, com.fasterxml.jackson.core.JsonToken, java.lang.String, java.lang.Object...)` should be called and will call this method as necessary.

    - #### weirdKeyException

          public JsonMappingException weirdKeyException(java.lang.Class<?> keyClass,
                                               java.lang.String keyValue,
                                               java.lang.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(java.lang.String value,
                                                  java.lang.Class<?> instClass,
                                                  java.lang.String msg)

      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
        `msg` - Message that describes specific problem
      Since:
        2.1

    - #### weirdNumberException

          public JsonMappingException weirdNumberException(java.lang.Number value,
                                                  java.lang.Class<?> instClass,
                                                  java.lang.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.

    - #### instantiationException

          public JsonMappingException instantiationException(java.lang.Class<?> instClass,
                                                    java.lang.Throwable t)

      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; 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(java.lang.Class<?> instClass,
                                                    java.lang.String msg)

      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.core.JsonParser, java.lang.String, java.lang.Object...)` should be called which will call this method if necessary.

    - #### unknownTypeIdException

          public JsonMappingException unknownTypeIdException(JavaType baseType,
                                                    java.lang.String typeId,
                                                    java.lang.String extraDesc)

      Helper method for constructing exception to indicate that given type id could not be resolved to a valid subtype of specified base type, during polymorphic deserialization.

      Note that most of the time this method should NOT be called; instead, `handleUnknownTypeId(com.fasterxml.jackson.databind.JavaType, java.lang.String, com.fasterxml.jackson.databind.jsontype.TypeIdResolver, java.lang.String)` should be called which will call this method if necessary.

    - #### unknownTypeException

          @Deprecated
          public JsonMappingException unknownTypeException(JavaType type,
                                                             java.lang.String id,
                                                             java.lang.String extraDesc)

      Deprecated. Since 2.8 use `handleUnknownTypeId(com.fasterxml.jackson.databind.JavaType, java.lang.String, com.fasterxml.jackson.databind.jsontype.TypeIdResolver, java.lang.String)` instead
      Since:
        2.5

    - #### endOfInputException

          @Deprecated
          public JsonMappingException endOfInputException(java.lang.Class<?> instClass)

      Deprecated. Since 2.8; currently no way to catch EOF at databind level
      Helper method for constructing exception to indicate that end-of-input was reached while still expecting more tokens to deserialize value of specified type.

    - #### getDateFormat

          protected java.text.DateFormat getDateFormat()

    - #### determineClassName

          protected java.lang.String determineClassName(java.lang.Object instance)

    - #### _calcName

          protected java.lang.String _calcName(java.lang.Class<?> cls)

    - #### _valueDesc

          protected java.lang.String _valueDesc()

    - #### _desc

          protected java.lang.String _desc(java.lang.String desc)

    - #### _quotedString

          protected java.lang.String _quotedString(java.lang.String desc)