com.fasterxml.jackson.databind

## 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:
  Serialized Form

### Field Summary

Fields
`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 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 JsonParser` `_parser` Currently active parser used for deserialization.
`protected JacksonFeatureSet<StreamReadCapability>` `_readCapabilities` Capabilities of the input format.
`protected Class<?>` `_view` Currently active view, if any.

### Constructor Summary

Constructors
`protected` `DeserializationContext(DeserializationContext src)` Copy-constructor for use with `copy()` by `ObjectMapper.copy()`
`protected` `DeserializationContext(DeserializationContext src, DeserializationConfig config)` Constructor used for creating bogus per-call style instance, but without underlying parser: needed for deserializer pre-fetching
`protected` `DeserializationContext(DeserializationContext src, DeserializationConfig config, 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

All Methods Instance Methods Abstract Methods Concrete Methods Deprecated Methods
`protected DateFormat` `_getDateFormat()`
`protected boolean` `_isCompatible(Class<?> target, Object value)`
`protected String` `_shapeForToken(JsonToken t)` Helper method for constructing description like "Object value" given `JsonToken` encountered.
`TokenBuffer` `bufferAsCopyOfValue(JsonParser p)` Convenience method, equivalent to:
`TokenBuffer` `bufferForInputBuffering()` Convenience method that is equivalent to:
`TokenBuffer` `bufferForInputBuffering(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)
`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.
`Calendar` `constructCalendar(Date d)` Convenience method for constructing Calendar instance set to specified time, to be modified and used by caller.
`JavaType` `constructSpecializedType(JavaType baseType, Class<?> subclass)` Convenience method for constructing subtypes, retaining generic type parameter (if any).
`JavaType` `constructType(Class<?> cls)` Convenience method, functionally equivalent to:
`abstract JsonDeserializer<Object>` `deserializerInstance(Annotated annotated, Object deserDef)`
`JsonMappingException` `endOfInputException(Class<?> instClass)` Deprecated. Since 2.8; currently no way to catch EOF at databind level
`String` `extractScalarFromObject(JsonParser p, JsonDeserializer<?> deser, Class<?> scalarType)` 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.
`Class<?>` `findClass(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.
`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.
`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).
`JsonDeserializer<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.
`Object` `findInjectableValue(Object valueId, BeanProperty forProperty, Object beanInstance)`
`KeyDeserializer` `findKeyDeserializer(JavaType keyType, BeanProperty prop)` Convenience method, functionally same as:

`JsonDeserializer<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(Object id, ObjectIdGenerator<?> generator, 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<Object>` `findRootValueDeserializer(JavaType type)` Method for finding a deserializer for root-level value.
`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[]).
`Object` `getAttribute(Object key)` Method for accessing attributes available in this context.
`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.
`DatatypeFeatures` `getDatatypeFeatures()`
`protected DateFormat` `getDateFormat()` Deprecated.
`JsonFormat.Value` `getDefaultPropertyFormat(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`.
`Locale` `getLocale()` Method for accessing default Locale to use: convenience method for
`JsonNodeFactory` `getNodeFactory()` Convenience method, functionally equivalent to:
`JsonParser` `getParser()` Method for accessing the currently active parser.
`TimeZone` `getTimeZone()` Method for accessing default TimeZone to use: convenience method for
`TypeFactory` `getTypeFactory()`
`void` `handleBadMerge(JsonDeserializer<?> deser)` Method that deserializer may call if it is called to do an update ("merge") but deserializer operates on a non-mergeable type.
`Object` `handleInstantiationProblem(Class<?> instClass, Object argument, 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).
`Object` `handleMissingInstantiator(Class<?> instClass, ValueInstantiator valueInst, JsonParser p, String msg, 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).
`JavaType` `handleMissingTypeId(JavaType baseType, TypeIdResolver idResolver, String extraDesc)`
`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, 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.

`Object` `handleUnexpectedToken(Class<?> instClass, 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 cannot handle).
`Object` `handleUnexpectedToken(Class<?> instClass, JsonToken t, JsonParser p, String msg, 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 cannot handle).
`Object` `handleUnexpectedToken(JavaType targetType, 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 cannot handle).
`Object` `handleUnexpectedToken(JavaType targetType, JsonToken t, JsonParser p, String msg, 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 cannot handle).
`boolean` `handleUnknownProperty(JsonParser p, JsonDeserializer<?> deser, Object instanceOrClass, 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, String id, TypeIdResolver idResolver, String extraDesc)` 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.
`Object` `handleWeirdKey(Class<?> keyClass, String keyValue, String msg, Object... msgArgs)` Method that deserializers should call if they encounter a String value that cannot be converted to expected key of a `Map` valued property.
`Object` `handleWeirdNativeValue(JavaType targetType, Object badValue, JsonParser p)`
`Object` `handleWeirdNumberValue(Class<?> targetClass, Number value, String msg, Object... msgArgs)` 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).
`Object` `handleWeirdStringValue(Class<?> targetClass, String value, String msg, Object... msgArgs)` 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).
`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, AtomicReference<Throwable> cause)` Method for checking whether we could find a deserializer for given type.
`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).
`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)
`JsonMappingException` `invalidTypeIdException(JavaType baseType, String typeId, 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.
`boolean` `isEnabled(DatatypeFeature feature)` Method for checking whether specified datatype feature is enabled or not.
`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 Mapper feature is enabled or not.
`boolean` `isEnabled(StreamReadCapability cap)` Accessor for checking whether input format has specified capability or not.
`abstract KeyDeserializer` `keyDeserializerInstance(Annotated annotated, 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(Class<?> targetClass)` Deprecated. Since 2.8 use `handleUnexpectedToken(Class, JsonParser)` instead
`JsonMappingException` `mappingException(Class<?> targetClass, JsonToken token)` Deprecated. Since 2.8 use `handleUnexpectedToken(Class, JsonParser)` instead
`JsonMappingException` `mappingException(String message)` Deprecated. Since 2.9 use more specific error reporting methods instead
`JsonMappingException` `mappingException(String msg, Object... msgArgs)` Deprecated. Since 2.9 use more specific error reporting methods instead
`JsonMappingException` `missingTypeIdException(JavaType baseType, String extraDesc)`
`Date` `parseDate(String dateStr)` Convenience method for parsing a Date from given String, using currently configured date format (accessed using `MapperConfig.getDateFormat()`).
`<T> T` `readPropertyValue(JsonParser p, BeanProperty prop, 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(JsonParser p, BeanProperty prop, JavaType type)` Same as `readPropertyValue(JsonParser, BeanProperty, Class)` but with fully resolved `JavaType` as target: needs to be used for generic types, for example.
`JsonNode` `readTree(JsonParser p)` Convenience method for reading the value that passed `JsonParser` points to as a `JsonNode`.
`<T> T` `readTreeAsValue(JsonNode n, Class<T> targetType)` Helper method similar to `ObjectReader.treeToValue(TreeNode, Class)` which will read contents of given tree (`JsonNode`) and bind them into specified target type.
`<T> T` `readTreeAsValue(JsonNode n, JavaType targetType)` Same as `readTreeAsValue(JsonNode, Class)` but will fully resolved `JavaType` as `targetType`
`<T> T` `readValue(JsonParser p, 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(JsonParser p, JavaType type)`
`<T> T` `reportBadCoercion(JsonDeserializer<?> src, Class<?> targetType, Object inputValue, String msg, Object... msgArgs)` Helper method used to indicate a problem with input in cases where specific input coercion was not allowed.
`<T> T` `reportBadDefinition(JavaType type, String msg)` 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`.
`<T> T` `reportBadMerge(JsonDeserializer<?> deser)` Deprecated. Since 2.10 use `handleBadMerge(com.fasterxml.jackson.databind.JsonDeserializer<?>)` instead
`<T> T` `reportBadPropertyDefinition(BeanDescription bean, BeanPropertyDefinition prop, String msg, Object... msgArgs)` 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, String msg, Object... msgArgs)` Helper method called to indicate problem in POJO (serialization) definitions or settings regarding specific Java type, unrelated to actual JSON content to map.
`<T> T` `reportInputMismatch(BeanProperty prop, String msg, Object... msgArgs)` Helper method used to indicate a problem with input in cases where more specific `reportXxx()` method was not available.
`<T> T` `reportInputMismatch(Class<?> targetType, String msg, Object... msgArgs)` Helper method used to indicate a problem with input in cases where more specific `reportXxx()` method was not available.
`<T> T` `reportInputMismatch(JavaType targetType, String msg, Object... msgArgs)` Helper method used to indicate a problem with input in cases where more specific `reportXxx()` method was not available.
`<T> T` `reportInputMismatch(JsonDeserializer<?> src, String msg, Object... msgArgs)` Helper method used to indicate a problem with input in cases where more specific `reportXxx()` method was not available.
`void` `reportMappingException(String msg, Object... msgArgs)` Deprecated. Since 2.9: use a more specific method, or `reportBadDefinition(JavaType, String)`, or `reportInputMismatch(com.fasterxml.jackson.databind.JsonDeserializer<?>, java.lang.String, java.lang.Object...)` instead
`void` `reportMissingContent(String msg, Object... msgArgs)` Deprecated. Since 2.9: not clear this ever occurs
`<T> T` `reportPropertyInputMismatch(Class<?> targetType, String propertyName, String msg, Object... msgArgs)` Helper method used to indicate a problem with input in cases where more specific `reportXxx()` method was not available.
`<T> T` `reportPropertyInputMismatch(JavaType targetType, String propertyName, String msg, Object... msgArgs)` Helper method used to indicate a problem with input in cases where more specific `reportXxx()` method was not available.
`<T> T` `reportTrailingTokens(Class<?> targetType, JsonParser p, JsonToken trailingToken)`
`void` `reportUnknownProperty(Object instanceOrClass, 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
`<T> T` `reportUnresolvedObjectId(ObjectIdReader oidReader, Object bean)`
`void` `reportWrongTokenException(Class<?> targetType, JsonToken expToken, String msg, 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` `reportWrongTokenException(JavaType targetType, JsonToken expToken, String msg, 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` `reportWrongTokenException(JsonDeserializer<?> deser, JsonToken expToken, String msg, 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` `reportWrongTokenException(JsonParser p, JsonToken expToken, String msg, Object... msgArgs)` Deprecated.
`void` `returnObjectBuffer(ObjectBuffer buf)` Method to call to return object buffer previously leased with `leaseObjectBuffer()`.
`DeserializationContext` `setAttribute(Object key, Object value)` Method for setting per-call value of given attribute.
`JsonMappingException` `unknownTypeException(JavaType type, String id, 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` `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.
`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).
`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.
`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.
`JsonMappingException` `wrongTokenException(JsonParser p, Class<?> targetType, JsonToken expToken, String extra)`
`JsonMappingException` `wrongTokenException(JsonParser p, JavaType targetType, 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.
`JsonMappingException` `wrongTokenException(JsonParser p, JsonToken expToken, String msg)` Deprecated.

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

`_colonConcat, _desc, _format, _quotedString, _throwNotASubtype, _throwSubtypeClassNotAllowed, _throwSubtypeNameNotAllowed, _truncate, constructType, converterInstance, objectIdGeneratorInstance, objectIdResolverInstance, reportBadDefinition, resolveAndValidateSubType, resolveSubType`

### 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

#### _readCapabilities

    protected final JacksonFeatureSet<StreamReadCapability> _readCapabilities

Capabilities of the input format.

Since:
  2.12

#### _view

    protected final Class<?> _view

Currently active view, if any.

#### _parser

    protected transient 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 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,
                                     JsonParser p,
                                     InjectableValues injectableValues)

Constructor used for creating actual per-call instances.

#### DeserializationContext

    protected DeserializationContext(DeserializationContext src,
                                     DeserializationConfig config)

Constructor used for creating bogus per-call style instance, but without underlying parser: needed for deserializer pre-fetching

Since:
  2.12

#### 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 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 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 `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

#### isEnabled

    public final boolean isEnabled(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 `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 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 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(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(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,
                                                  ObjectIdGenerator<?> generator,
                                                  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(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(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(JsonParser p,
                           JavaType type)
                    throws IOException

Throws:
  `IOException`
Since:
  2.4

#### readPropertyValue

    public <T> T readPropertyValue(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(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(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(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 `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:
  `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,
                                         JsonParser p)
                                  throws IOException

Throws:
  `IOException`

#### handleMissingInstantiator

    public Object handleMissingInstantiator(Class<?> instClass,
                                            ValueInstantiator valueInst,
                                            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,
                                        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,
                                        JsonToken t,
                                        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,
                                        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,
                                        JsonToken t,
                                        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,
                                          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,
                                          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,
                                          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,
                                      JsonParser p,
                                      JsonToken trailingToken)
                               throws JsonMappingException

Throws:
  `JsonMappingException`

#### reportWrongTokenException

    @Deprecated
    public void reportWrongTokenException(JsonParser p,
                                                      JsonToken expToken,
                                                      String msg,
                                                      Object... msgArgs)
                                               throws JsonMappingException

Deprecated.

Throws:
  `JsonMappingException`

#### reportUnknownProperty

    @Deprecated
    public void reportUnknownProperty(Object instanceOrClass,
                                                  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`

#### reportMissingContent

    @Deprecated
    public void reportMissingContent(String msg,
                                                 Object... msgArgs)
                                          throws JsonMappingException

Deprecated. Since 2.9: not clear this ever occurs

Throws:
  `JsonMappingException`
Since:
  2.8

#### 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`

#### reportBadMerge

    @Deprecated
    public <T> T reportBadMerge(JsonDeserializer<?> deser)
                                     throws JsonMappingException

Deprecated. Since 2.10 use `handleBadMerge(com.fasterxml.jackson.databind.JsonDeserializer<?>)` instead

Throws:
  `JsonMappingException`

#### wrongTokenException

    public JsonMappingException wrongTokenException(JsonParser p,
                                                    JavaType targetType,
                                                    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(JsonParser p,
                                                    Class<?> targetType,
                                                    JsonToken expToken,
                                                    String extra)

#### wrongTokenException

    @Deprecated
    public JsonMappingException wrongTokenException(JsonParser p,
                                                                JsonToken expToken,
                                                                String msg)

Deprecated.

#### 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

#### unknownTypeException

    @Deprecated
    public JsonMappingException unknownTypeException(JavaType type,
                                                                 String id,
                                                                 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(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.

#### reportMappingException

    @Deprecated
    public void reportMappingException(String msg,
                                                   Object... msgArgs)
                                            throws JsonMappingException

Deprecated. Since 2.9: use a more specific method, or `reportBadDefinition(JavaType, String)`, or `reportInputMismatch(com.fasterxml.jackson.databind.JsonDeserializer<?>, java.lang.String, java.lang.Object...)` instead
Fallback method that may be called if no other `reportXxx` is applicable -- but only in that case.

Throws:
  `JsonMappingException`
Since:
  2.8

#### mappingException

    @Deprecated
    public JsonMappingException mappingException(String message)

Deprecated. Since 2.9 use more specific error reporting methods instead
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(String msg,
                                                             Object... msgArgs)

Deprecated. Since 2.9 use more specific error reporting methods instead
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(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(Class<?> targetClass,
                                                             JsonToken token)

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

#### getDateFormat

    @Deprecated
    protected DateFormat getDateFormat()

Deprecated.

#### _getDateFormat

    protected DateFormat _getDateFormat()

#### _shapeForToken

    protected String _shapeForToken(JsonToken t)

Helper method for constructing description like "Object value" given `JsonToken` encountered.