BeanDeserializerBase
Date: 2016-12-04

com.fasterxml.jackson.databind.deser

## Class BeanDeserializerBase

- java.lang.Object
- - com.fasterxml.jackson.databind.JsonDeserializer<T>
  - - com.fasterxml.jackson.databind.deser.std.StdDeserializer<java.lang.Object>
    - - com.fasterxml.jackson.databind.deser.BeanDeserializerBase

- All Implemented Interfaces:
    ContextualDeserializer, ResolvableDeserializer, java.io.Serializable
  Direct Known Subclasses:
    BeanAsArrayBuilderDeserializer, BeanAsArrayDeserializer, BeanDeserializer, BuilderBasedDeserializer

      public abstract class BeanDeserializerBase
      extends StdDeserializer<java.lang.Object>
      implements ContextualDeserializer, ResolvableDeserializer, java.io.Serializable

  Base class for `BeanDeserializer`.
  See Also:
    Serialized Form

- - ### Nested Class Summary

    - ### Nested classes/interfaces inherited from class com.fasterxml.jackson.databind.JsonDeserializer

      `JsonDeserializer.None`

  - ### Field Summary

    Fields
    Modifier and Type | Field and Description
    --- | ---
    `protected SettableAnyProperty` | `_anySetter` Fallback setter used for handling any properties that are not mapped to regular setters.
    `protected JsonDeserializer<java.lang.Object>` | `_arrayDelegateDeserializer` Deserializer that is used iff array-delegate-based creator is to be used for deserializing from JSON Object.
    `protected java.util.Map<java.lang.String,SettableBeanProperty>` | `_backRefs` We may also have one or more back reference fields (usually zero or one).
    `protected BeanPropertyMap` | `_beanProperties` Mapping of property names to properties, built when all properties to use have been successfully resolved.
    `protected JavaType` | `_beanType` Declared type of the bean this deserializer handles.
    `protected JsonDeserializer<java.lang.Object>` | `_delegateDeserializer` Deserializer that is used iff delegate-based creator is to be used for deserializing from JSON Object.
    `protected ExternalTypeHandler` | `_externalTypeIdHandler` Handler that we need iff any of properties uses external type id.
    `protected java.util.Set<java.lang.String>` | `_ignorableProps` In addition to properties that are set, we will also keep track of recognized but ignorable properties: these will be skipped without errors or warnings.
    `protected boolean` | `_ignoreAllUnknown` Flag that can be set to ignore and skip unknown properties.
    `protected ValueInjector[]` | `_injectables` List of `ValueInjector`s, if any injectable values are expected by the bean; otherwise null.
    `protected boolean` | `_needViewProcesing` Flag that indicates that some aspect of deserialization depends on active view used (if any)
    `protected boolean` | `_nonStandardCreation` Flag that is set to mark "non-standard" cases; where either we use one of non-default creators, or there are unwrapped values to consider.
    `protected ObjectIdReader` | `_objectIdReader` If an Object Id is to be used for value handled by this deserializer, this reader is used for handling.
    `protected PropertyBasedCreator` | `_propertyBasedCreator` If the bean needs to be instantiated using constructor or factory method that takes one or more named properties as argument(s), this creator is used for instantiation.
    `protected com.fasterxml.jackson.annotation.JsonFormat.Shape` | `_serializationShape` Requested shape from bean class annotations.
    `protected java.util.HashMap<ClassKey,JsonDeserializer<java.lang.Object>>` | `_subDeserializers` Lazily constructed map used to contain deserializers needed for polymorphic subtypes.
    `protected UnwrappedPropertyHandler` | `_unwrappedPropertyHandler` If one of properties has "unwrapped" value, we need separate helper object
    `protected ValueInstantiator` | `_valueInstantiator` Object that handles details of constructing initial bean value (to which bind data to), unless instance is passed (via updateValue())
    `protected boolean` | `_vanillaProcessing` Flag that indicates that no "special features" whatsoever are enabled, so the simplest processing is possible.
    `protected static PropertyName` | `TEMP_PROPERTY_NAME`

    - ### Fields inherited from class com.fasterxml.jackson.databind.deser.std.StdDeserializer

      `_valueClass, F_MASK_INT_COERCIONS`

  - ### Constructor Summary

    Constructors
    Modifier | Constructor and Description
    --- | ---
    `protected` | `BeanDeserializerBase(BeanDeserializerBase src)`
    `protected` | `BeanDeserializerBase(BeanDeserializerBase src, BeanPropertyMap beanProps)`
    `protected` | `BeanDeserializerBase(BeanDeserializerBase src, boolean ignoreAllUnknown)`
    `protected` | `BeanDeserializerBase(BeanDeserializerBase src, NameTransformer unwrapper)`
    `` | `BeanDeserializerBase(BeanDeserializerBase src, ObjectIdReader oir)`
    `` | `BeanDeserializerBase(BeanDeserializerBase src, java.util.Set<java.lang.String> ignorableProps)`
    `protected` | `BeanDeserializerBase(BeanDeserializerBuilder builder, BeanDescription beanDesc, BeanPropertyMap properties, java.util.Map<java.lang.String,SettableBeanProperty> backRefs, java.util.Set<java.lang.String> ignorableProps, boolean ignoreAllUnknown, boolean hasViews)` Constructor used when initially building a deserializer instance, given a `BeanDeserializerBuilder` that contains configuration.

  - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `protected java.lang.Object` | `_convertObjectId(com.fasterxml.jackson.core.JsonParser p, DeserializationContext ctxt, java.lang.Object rawId, JsonDeserializer<java.lang.Object> idDeser)` Helper method we need to do necessary conversion from whatever native object id type is, into declared type that Jackson internals expect.
    `protected abstract java.lang.Object` | `_deserializeUsingPropertyBased(com.fasterxml.jackson.core.JsonParser p, DeserializationContext ctxt)`
    `protected JsonDeserializer<java.lang.Object>` | `_findSubclassDeserializer(DeserializationContext ctxt, java.lang.Object bean, TokenBuffer unknownTokens)` Helper method called to (try to) locate deserializer for given sub-type of type that this deserializer handles.
    `protected java.lang.Object` | `_handleTypedObjectId(com.fasterxml.jackson.core.JsonParser p, DeserializationContext ctxt, java.lang.Object pojo, java.lang.Object rawId)` Offlined method called to handle "native" Object Id that has been read and known to be associated with given deserialized POJO.
    `protected SettableBeanProperty` | `_resolvedObjectIdProperty(DeserializationContext ctxt, SettableBeanProperty prop)` Method that wraps given property with `ObjectIdReferenceProperty` in case where object id resolution is required.
    `protected SettableBeanProperty` | `_resolveInnerClassValuedProperty(DeserializationContext ctxt, SettableBeanProperty prop)` Helper method that will handle gruesome details of dealing with properties that have non-static inner class as value...
    `protected SettableBeanProperty` | `_resolveManagedReferenceProperty(DeserializationContext ctxt, SettableBeanProperty prop)` Helper method called to see if given property is part of 'managed' property pair (managed + back reference), and if so, handle resolution details.
    `protected SettableBeanProperty` | `_resolveUnwrappedProperty(DeserializationContext ctxt, SettableBeanProperty prop)` Helper method called to see if given property might be so-called unwrapped property: these require special handling.
    `protected abstract BeanDeserializerBase` | `asArrayDeserializer()` Fluent factory for creating a variant that can handle POJO output as a JSON Array.
    `JsonDeserializer<?>` | `createContextual(DeserializationContext ctxt, BeanProperty property)` Although most of post-processing is done in resolve(), we only get access to referring property's annotations here; and this is needed to support per-property ObjectIds.
    `java.util.Iterator<SettableBeanProperty>` | `creatorProperties()` Accessor for finding properties that represents values to pass through property-based creator method (constructor or factory method)
    `java.lang.Object` | `deserializeFromArray(com.fasterxml.jackson.core.JsonParser p, DeserializationContext ctxt)`
    `java.lang.Object` | `deserializeFromBoolean(com.fasterxml.jackson.core.JsonParser p, DeserializationContext ctxt)` Method called to deserialize POJO value from a JSON boolean value (true, false)
    `java.lang.Object` | `deserializeFromDouble(com.fasterxml.jackson.core.JsonParser p, DeserializationContext ctxt)` Method called to deserialize POJO value from a JSON floating-point number.
    `java.lang.Object` | `deserializeFromEmbedded(com.fasterxml.jackson.core.JsonParser p, DeserializationContext ctxt)`
    `java.lang.Object` | `deserializeFromNumber(com.fasterxml.jackson.core.JsonParser p, DeserializationContext ctxt)`
    `abstract java.lang.Object` | `deserializeFromObject(com.fasterxml.jackson.core.JsonParser p, DeserializationContext ctxt)` General version used when handling needs more advanced features.
    `protected java.lang.Object` | `deserializeFromObjectId(com.fasterxml.jackson.core.JsonParser p, DeserializationContext ctxt)` Method called in cases where it looks like we got an Object Id to parse and use as a reference.
    `protected java.lang.Object` | `deserializeFromObjectUsingNonDefault(com.fasterxml.jackson.core.JsonParser p, DeserializationContext ctxt)`
    `java.lang.Object` | `deserializeFromString(com.fasterxml.jackson.core.JsonParser p, DeserializationContext ctxt)`
    `protected java.lang.Object` | `deserializeWithObjectId(com.fasterxml.jackson.core.JsonParser p, DeserializationContext ctxt)` Alternative deserialization method used when we expect to see Object Id; if so, we will need to ensure that the Id is seen before anything else, to ensure that it is available for solving references, even if JSON itself is not ordered that way.
    `java.lang.Object` | `deserializeWithType(com.fasterxml.jackson.core.JsonParser p, DeserializationContext ctxt, TypeDeserializer typeDeserializer)` Base implementation that does not assume specific type inclusion mechanism.
    `SettableBeanProperty` | `findBackReference(java.lang.String logicalName)` Method needed by `BeanDeserializerFactory` to properly link managed- and back-reference pairs.
    `protected JsonDeserializer<java.lang.Object>` | `findConvertingDeserializer(DeserializationContext ctxt, SettableBeanProperty prop)` Helper method that can be used to see if specified property is annotated to indicate use of a converter for property value (in case of container types, it is container type itself, not key or content type).
    `SettableBeanProperty` | `findProperty(int propertyIndex)` Alternate find method that tries to locate a property with given `property index`.
    `SettableBeanProperty` | `findProperty(PropertyName propertyName)`
    `SettableBeanProperty` | `findProperty(java.lang.String propertyName)` Accessor for finding the property with given name, if POJO has one.
    `java.lang.Class<?>` | `getBeanClass()` Deprecated. Since 2.3, use `handledType()` instead
    `java.util.Collection<java.lang.Object>` | `getKnownPropertyNames()` Method that will either return null to indicate that type being deserializers has no concept of properties; or a collection of identifiers for which `toString` will give external property name.
    `ObjectIdReader` | `getObjectIdReader()` Overridden to return true for those instances that are handling value for which Object Identity handling is enabled (either via value type or referring property).
    `int` | `getPropertyCount()` Accessor for checking number of deserialized properties.
    `ValueInstantiator` | `getValueInstantiator()`
    `JavaType` | `getValueType()` Exact structured type deserializer handles, if known.
    `java.lang.Class<?>` | `handledType()` Method for accessing type of values this deserializer produces.
    `protected void` | `handleIgnoredProperty(com.fasterxml.jackson.core.JsonParser p, DeserializationContext ctxt, java.lang.Object beanOrClass, java.lang.String propName)` Method called when an explicitly ignored property (one specified with a name to match, either by property annotation or class annotation) is encountered.
    `protected java.lang.Object` | `handlePolymorphic(com.fasterxml.jackson.core.JsonParser p, DeserializationContext ctxt, java.lang.Object bean, TokenBuffer unknownTokens)` Method called in cases where we may have polymorphic deserialization case: that is, type of Creator-constructed bean is not the type of deserializer itself.
    `protected java.lang.Object` | `handleUnknownProperties(DeserializationContext ctxt, java.lang.Object bean, TokenBuffer unknownTokens)` Method called to handle set of one or more unknown properties, stored in their entirety in given `TokenBuffer` (as field entries, name and value).
    `protected void` | `handleUnknownProperty(com.fasterxml.jackson.core.JsonParser p, DeserializationContext ctxt, java.lang.Object beanOrClass, java.lang.String propName)` Method called when a JSON property is encountered that has not matching setter, any-setter or field, and thus can not be assigned.
    `protected void` | `handleUnknownVanilla(com.fasterxml.jackson.core.JsonParser p, DeserializationContext ctxt, java.lang.Object bean, java.lang.String propName)` Helper method called for an unknown property, when using "vanilla" processing.
    `boolean` | `hasProperty(java.lang.String propertyName)`
    `boolean` | `hasViews()`
    `protected void` | `injectValues(DeserializationContext ctxt, java.lang.Object bean)`
    `boolean` | `isCachable()` Method called to see if deserializer instance is cachable and usable for other properties of same type (type for which instance was created).
    `java.util.Iterator<SettableBeanProperty>` | `properties()` Accessor for iterating over properties this deserializer uses; with the exception that properties passed via Creator methods (specifically, "property-based constructor") are not included, but can be accessed separate by calling `creatorProperties()`
    `void` | `replaceProperty(SettableBeanProperty original, SettableBeanProperty replacement)` Method that can be used to replace an existing property with a modified one.
    `void` | `resolve(DeserializationContext ctxt)` Method called to finalize setup of this deserializer, after deserializer itself has been registered.
    `abstract JsonDeserializer<java.lang.Object>` | `unwrappingDeserializer(NameTransformer unwrapper)` Method that will return deserializer instance that is able to handle "unwrapped" value instances If no unwrapped instance can be constructed, will simply return this object as-is.
    `BeanDeserializerBase` | `withBeanProperties(BeanPropertyMap props)` Mutant factory method that custom sub-classes must override; not left as abstract to prevent more drastic backwards compatibility problems.
    `abstract BeanDeserializerBase` | `withIgnorableProperties(java.util.Set<java.lang.String> ignorableProps)`
    `abstract BeanDeserializerBase` | `withObjectIdReader(ObjectIdReader oir)`
    `void` | `wrapAndThrow(java.lang.Throwable t, java.lang.Object bean, int index, DeserializationContext ctxt)` Deprecated.
    `void` | `wrapAndThrow(java.lang.Throwable t, java.lang.Object bean, java.lang.String fieldName, DeserializationContext ctxt)` Method that will modify caught exception (passed in as argument) as necessary to include reference information, and to ensure it is a subtype of `IOException`, or an unchecked exception.
    `protected java.lang.Object` | `wrapInstantiationProblem(java.lang.Throwable t, DeserializationContext ctxt)`

    - ### Methods inherited from class com.fasterxml.jackson.databind.deser.std.StdDeserializer

      `_coerceIntegral, _deserializeFromEmpty, _failDoubleToIntCoercion, _hasTextualNull, _isIntNumber, _isNaN, _isNegInf, _isPosInf, _parseBoolean, _parseBooleanFromInt, _parseBooleanFromOther, _parseBooleanPrimitive, _parseByte, _parseDate, _parseDate, _parseDouble, _parseDoublePrimitive, _parseFloat, _parseFloatPrimitive, _parseInteger, _parseIntPrimitive, _parseLong, _parseLongPrimitive, _parseShort, _parseShortPrimitive, _parseString, findConvertingContentDeserializer, findDeserializer, findFormatFeature, findFormatOverrides, getValueClass, handleMissingEndArrayForSingle, isDefaultDeserializer, isDefaultKeyDeserializer, parseDouble`

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

      `deserialize, deserialize, getDelegatee, getEmptyValue, getEmptyValue, getNullValue, getNullValue, replaceDelegatee`

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

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

- - ### Field Detail

    - #### TEMP_PROPERTY_NAME

          protected static final PropertyName TEMP_PROPERTY_NAME

    - #### _beanType

          protected final JavaType _beanType

      Declared type of the bean this deserializer handles.

    - #### _serializationShape

          protected final com.fasterxml.jackson.annotation.JsonFormat.Shape _serializationShape

      Requested shape from bean class annotations.

    - #### _valueInstantiator

          protected final ValueInstantiator _valueInstantiator

      Object that handles details of constructing initial bean value (to which bind data to), unless instance is passed (via updateValue())

    - #### _delegateDeserializer

          protected JsonDeserializer<java.lang.Object> _delegateDeserializer

      Deserializer that is used iff delegate-based creator is to be used for deserializing from JSON Object.

    - #### _arrayDelegateDeserializer

          protected JsonDeserializer<java.lang.Object> _arrayDelegateDeserializer

      Deserializer that is used iff array-delegate-based creator is to be used for deserializing from JSON Object.

    - #### _propertyBasedCreator

          protected PropertyBasedCreator _propertyBasedCreator

      If the bean needs to be instantiated using constructor or factory method that takes one or more named properties as argument(s), this creator is used for instantiation. This value gets resolved during general resolution.

    - #### _nonStandardCreation

          protected boolean _nonStandardCreation

      Flag that is set to mark "non-standard" cases; where either we use one of non-default creators, or there are unwrapped values to consider.

    - #### _vanillaProcessing

          protected boolean _vanillaProcessing

      Flag that indicates that no "special features" whatsoever are enabled, so the simplest processing is possible.

    - #### _beanProperties

          protected final BeanPropertyMap _beanProperties

      Mapping of property names to properties, built when all properties to use have been successfully resolved.

    - #### _injectables

          protected final ValueInjector[] _injectables

      List of `ValueInjector`s, if any injectable values are expected by the bean; otherwise null. This includes injectors used for injecting values via setters and fields, but not ones passed through constructor parameters.

    - #### _anySetter

          protected SettableAnyProperty _anySetter

      Fallback setter used for handling any properties that are not mapped to regular setters. If setter is not null, it will be called once for each such property.

    - #### _ignorableProps

          protected final java.util.Set<java.lang.String> _ignorableProps

      In addition to properties that are set, we will also keep track of recognized but ignorable properties: these will be skipped without errors or warnings.

    - #### _ignoreAllUnknown

          protected final boolean _ignoreAllUnknown

      Flag that can be set to ignore and skip unknown properties. If set, will not throw an exception for unknown properties.

    - #### _needViewProcesing

          protected final boolean _needViewProcesing

      Flag that indicates that some aspect of deserialization depends on active view used (if any)

    - #### _backRefs

          protected final java.util.Map<java.lang.String,SettableBeanProperty> _backRefs

      We may also have one or more back reference fields (usually zero or one).

    - #### _subDeserializers

          protected transient java.util.HashMap<ClassKey,JsonDeserializer<java.lang.Object>> _subDeserializers

      Lazily constructed map used to contain deserializers needed for polymorphic subtypes. Note that this is only needed for polymorphic types, that is, when the actual type is not statically known. For other types this remains null.

    - #### _unwrappedPropertyHandler

          protected UnwrappedPropertyHandler _unwrappedPropertyHandler

      If one of properties has "unwrapped" value, we need separate helper object

    - #### _externalTypeIdHandler

          protected ExternalTypeHandler _externalTypeIdHandler

      Handler that we need iff any of properties uses external type id.

    - #### _objectIdReader

          protected final ObjectIdReader _objectIdReader

      If an Object Id is to be used for value handled by this deserializer, this reader is used for handling.

  - ### Constructor Detail

    - #### BeanDeserializerBase

          protected BeanDeserializerBase(BeanDeserializerBuilder builder,
                              BeanDescription beanDesc,
                              BeanPropertyMap properties,
                              java.util.Map<java.lang.String,SettableBeanProperty> backRefs,
                              java.util.Set<java.lang.String> ignorableProps,
                              boolean ignoreAllUnknown,
                              boolean hasViews)

      Constructor used when initially building a deserializer instance, given a `BeanDeserializerBuilder` that contains configuration.

    - #### BeanDeserializerBase

          protected BeanDeserializerBase(BeanDeserializerBase src)

    - #### BeanDeserializerBase

          protected BeanDeserializerBase(BeanDeserializerBase src,
                              boolean ignoreAllUnknown)

    - #### BeanDeserializerBase

          protected BeanDeserializerBase(BeanDeserializerBase src,
                              NameTransformer unwrapper)

    - #### BeanDeserializerBase

          public BeanDeserializerBase(BeanDeserializerBase src,
                              ObjectIdReader oir)

    - #### BeanDeserializerBase

          public BeanDeserializerBase(BeanDeserializerBase src,
                              java.util.Set<java.lang.String> ignorableProps)

    - #### BeanDeserializerBase

          protected BeanDeserializerBase(BeanDeserializerBase src,
                              BeanPropertyMap beanProps)

      Since:
        2.8

  - ### Method Detail

    - #### unwrappingDeserializer

          public abstract JsonDeserializer<java.lang.Object> unwrappingDeserializer(NameTransformer unwrapper)

      Description copied from class: `JsonDeserializer`
      Method that will return deserializer instance that is able to handle "unwrapped" value instances If no unwrapped instance can be constructed, will simply return this object as-is.

      Default implementation just returns 'this' indicating that no unwrapped variant exists

      Overrides:
        `unwrappingDeserializer` in class `JsonDeserializer<java.lang.Object>`

    - #### withObjectIdReader

          public abstract BeanDeserializerBase withObjectIdReader(ObjectIdReader oir)

    - #### withIgnorableProperties

          public abstract BeanDeserializerBase withIgnorableProperties(java.util.Set<java.lang.String> ignorableProps)

    - #### withBeanProperties

          public BeanDeserializerBase withBeanProperties(BeanPropertyMap props)

      Mutant factory method that custom sub-classes must override; not left as abstract to prevent more drastic backwards compatibility problems.
      Since:
        2.8

    - #### asArrayDeserializer

          protected abstract BeanDeserializerBase asArrayDeserializer()

      Fluent factory for creating a variant that can handle POJO output as a JSON Array. Implementations may ignore this request if no such input is possible.
      Since:
        2.1

    - #### resolve

          public void resolve(DeserializationContext ctxt)
                       throws JsonMappingException

      Method called to finalize setup of this deserializer, after deserializer itself has been registered. This is needed to handle recursive and transitive dependencies.
      Specified by:
        `resolve` in interface `ResolvableDeserializer`
      Parameters:
        `ctxt` - Context to use for accessing configuration, resolving secondary deserializers
      Throws:
        `JsonMappingException`

    - #### findConvertingDeserializer

          protected JsonDeserializer<java.lang.Object> findConvertingDeserializer(DeserializationContext ctxt,
                                                                      SettableBeanProperty prop)
                                                                           throws JsonMappingException

      Helper method that can be used to see if specified property is annotated to indicate use of a converter for property value (in case of container types, it is container type itself, not key or content type).
      Throws:
        `JsonMappingException`
      Since:
        2.2

    - #### createContextual

          public JsonDeserializer<?> createContextual(DeserializationContext ctxt,
                                             BeanProperty property)
                                               throws JsonMappingException

      Although most of post-processing is done in resolve(), we only get access to referring property's annotations here; and this is needed to support per-property ObjectIds. We will also consider Shape transformations (read from Array) at this point, since it may come from either Class definition or property.
      Specified by:
        `createContextual` in interface `ContextualDeserializer`
      Parameters:
        `ctxt` - Deserialization context to access configuration, additional deserializers that may be needed by this deserializer
        `property` - Method, field or constructor parameter that represents the property (and is used to assign deserialized value). Should be available; but there may be cases where caller can not provide it and null is passed instead (in which case impls usually pass 'this' deserializer as is)
      Returns:
        Deserializer to use for deserializing values of specified property; may be this instance or a new instance.
      Throws:
        `JsonMappingException`

    - #### _resolveManagedReferenceProperty

          protected SettableBeanProperty _resolveManagedReferenceProperty(DeserializationContext ctxt,
                                                              SettableBeanProperty prop)

      Helper method called to see if given property is part of 'managed' property pair (managed + back reference), and if so, handle resolution details.

    - #### _resolvedObjectIdProperty

          protected SettableBeanProperty _resolvedObjectIdProperty(DeserializationContext ctxt,
                                                       SettableBeanProperty prop)
                                                            throws JsonMappingException

      Method that wraps given property with `ObjectIdReferenceProperty` in case where object id resolution is required.
      Throws:
        `JsonMappingException`

    - #### _resolveUnwrappedProperty

          protected SettableBeanProperty _resolveUnwrappedProperty(DeserializationContext ctxt,
                                                       SettableBeanProperty prop)

      Helper method called to see if given property might be so-called unwrapped property: these require special handling.

    - #### _resolveInnerClassValuedProperty

          protected SettableBeanProperty _resolveInnerClassValuedProperty(DeserializationContext ctxt,
                                                              SettableBeanProperty prop)

      Helper method that will handle gruesome details of dealing with properties that have non-static inner class as value...

    - #### isCachable

          public boolean isCachable()

      Description copied from class: `JsonDeserializer`
      Method called to see if deserializer instance is cachable and usable for other properties of same type (type for which instance was created).

      Note that cached instances are still resolved on per-property basis, if instance implements `ResolvableDeserializer`: cached instance is just as the base. This means that in most cases it is safe to cache instances; however, it only makes sense to cache instances if instantiation is expensive, or if instances are heavy-weight.

      Default implementation returns false, to indicate that no caching is done.

      Overrides:
        `isCachable` in class `JsonDeserializer<java.lang.Object>`

    - #### handledType

          public java.lang.Class<?> handledType()

      Description copied from class: `JsonDeserializer`
      Method for accessing type of values this deserializer produces. Note that this information is not guaranteed to be exact -- it may be a more generic (super-type) -- but it should not be incorrect (return a non-related type).

      Default implementation will return null, which means almost same same as returning `Object.class` would; that is, that nothing is known about handled type.

      Overrides:
        `handledType` in class `StdDeserializer<java.lang.Object>`

    - #### getObjectIdReader

          public ObjectIdReader getObjectIdReader()

      Overridden to return true for those instances that are handling value for which Object Identity handling is enabled (either via value type or referring property).
      Overrides:
        `getObjectIdReader` in class `JsonDeserializer<java.lang.Object>`
      Returns:
        ObjectIdReader used for resolving possible Object Identifier value, instead of full value serialization, if deserializer can do that; null if no Object Id is expected.

    - #### hasProperty

          public boolean hasProperty(java.lang.String propertyName)

    - #### hasViews

          public boolean hasViews()

    - #### getPropertyCount

          public int getPropertyCount()

      Accessor for checking number of deserialized properties.

    - #### getKnownPropertyNames

          public java.util.Collection<java.lang.Object> getKnownPropertyNames()

      Description copied from class: `JsonDeserializer`
      Method that will either return null to indicate that type being deserializers has no concept of properties; or a collection of identifiers for which `toString` will give external property name. This is only to be used for error reporting and diagnostics purposes (most commonly, to accompany "unknown property" exception).
      Overrides:
        `getKnownPropertyNames` in class `JsonDeserializer<java.lang.Object>`

    - #### getBeanClass

          @Deprecated
          public final java.lang.Class<?> getBeanClass()

      Deprecated. Since 2.3, use `handledType()` instead

    - #### getValueType

          public JavaType getValueType()

      Description copied from class: `StdDeserializer`
      Exact structured type deserializer handles, if known.

      Default implementation just returns null.

      Overrides:
        `getValueType` in class `StdDeserializer<java.lang.Object>`

    - #### properties

          public java.util.Iterator<SettableBeanProperty> properties()

      Accessor for iterating over properties this deserializer uses; with the exception that properties passed via Creator methods (specifically, "property-based constructor") are not included, but can be accessed separate by calling `creatorProperties()`

    - #### creatorProperties

          public java.util.Iterator<SettableBeanProperty> creatorProperties()

      Accessor for finding properties that represents values to pass through property-based creator method (constructor or factory method)
      Since:
        2.0

    - #### findProperty

          public SettableBeanProperty findProperty(PropertyName propertyName)

    - #### findProperty

          public SettableBeanProperty findProperty(java.lang.String propertyName)

      Accessor for finding the property with given name, if POJO has one. Name used is the external name, i.e. name used in external data representation (JSON).
      Since:
        2.0

    - #### findProperty

          public SettableBeanProperty findProperty(int propertyIndex)

      Alternate find method that tries to locate a property with given `property index`. Note that access by index is not necessarily faster than by name, since properties are not directly indexable; however, for most instances difference is not significant as number of properties is low.
      Since:
        2.3

    - #### findBackReference

          public SettableBeanProperty findBackReference(java.lang.String logicalName)

      Method needed by `BeanDeserializerFactory` to properly link managed- and back-reference pairs.
      Overrides:
        `findBackReference` in class `JsonDeserializer<java.lang.Object>`

    - #### getValueInstantiator

          public ValueInstantiator getValueInstantiator()

    - #### replaceProperty

          public void replaceProperty(SettableBeanProperty original,
                             SettableBeanProperty replacement)

      Method that can be used to replace an existing property with a modified one.

      NOTE: only ever use this method if you know what you are doing; incorrect usage can break deserializer.

      Parameters:
        `original` - Property to replace
        `replacement` - Property to replace it with
      Since:
        2.1

    - #### deserializeFromObject

          public abstract java.lang.Object deserializeFromObject(com.fasterxml.jackson.core.JsonParser p,
                                               DeserializationContext ctxt)
                                                          throws java.io.IOException

      General version used when handling needs more advanced features.
      Throws:
        `java.io.IOException`

    - #### deserializeWithType

          public java.lang.Object deserializeWithType(com.fasterxml.jackson.core.JsonParser p,
                                             DeserializationContext ctxt,
                                             TypeDeserializer typeDeserializer)
                                               throws java.io.IOException

      Description copied from class: `StdDeserializer`
      Base implementation that does not assume specific type inclusion mechanism. Sub-classes are expected to override this method if they are to handle type information.
      Overrides:
        `deserializeWithType` in class `StdDeserializer<java.lang.Object>`
        `typeDeserializer` - Deserializer to use for handling type information
      Throws:
        `java.io.IOException`

    - #### _handleTypedObjectId

          protected java.lang.Object _handleTypedObjectId(com.fasterxml.jackson.core.JsonParser p,
                                              DeserializationContext ctxt,
                                              java.lang.Object pojo,
                                              java.lang.Object rawId)
                                                   throws java.io.IOException

      Offlined method called to handle "native" Object Id that has been read and known to be associated with given deserialized POJO.
      Throws:
        `java.io.IOException`
      Since:
        2.3

    - #### _convertObjectId

          protected java.lang.Object _convertObjectId(com.fasterxml.jackson.core.JsonParser p,
                                          DeserializationContext ctxt,
                                          java.lang.Object rawId,
                                          JsonDeserializer<java.lang.Object> idDeser)
                                               throws java.io.IOException

      Helper method we need to do necessary conversion from whatever native object id type is, into declared type that Jackson internals expect. This may be simple cast (for String ids), or something more complicated; in latter case we may need to create bogus content buffer to allow use of id deserializer.
      Throws:
        `java.io.IOException`
      Since:
        2.3

    - #### deserializeWithObjectId

          protected java.lang.Object deserializeWithObjectId(com.fasterxml.jackson.core.JsonParser p,
                                                 DeserializationContext ctxt)
                                                      throws java.io.IOException

      Alternative deserialization method used when we expect to see Object Id; if so, we will need to ensure that the Id is seen before anything else, to ensure that it is available for solving references, even if JSON itself is not ordered that way. This may require buffering in some cases, but usually just a simple lookup to ensure that ordering is correct.
      Throws:
        `java.io.IOException`

    - #### deserializeFromObjectId

          protected java.lang.Object deserializeFromObjectId(com.fasterxml.jackson.core.JsonParser p,
                                                 DeserializationContext ctxt)
                                                      throws java.io.IOException

      Method called in cases where it looks like we got an Object Id to parse and use as a reference.
      Throws:
        `java.io.IOException`

    - #### deserializeFromObjectUsingNonDefault

          protected java.lang.Object deserializeFromObjectUsingNonDefault(com.fasterxml.jackson.core.JsonParser p,
                                                              DeserializationContext ctxt)
                                                                   throws java.io.IOException

      Throws:
        `java.io.IOException`

    - #### _deserializeUsingPropertyBased

          protected abstract java.lang.Object _deserializeUsingPropertyBased(com.fasterxml.jackson.core.JsonParser p,
                                                        DeserializationContext ctxt)
                                                                      throws java.io.IOException,
                                                                             com.fasterxml.jackson.core.JsonProcessingException

      Throws:
        `java.io.IOException`
        `com.fasterxml.jackson.core.JsonProcessingException`

    - #### deserializeFromNumber

          public java.lang.Object deserializeFromNumber(com.fasterxml.jackson.core.JsonParser p,
                                               DeserializationContext ctxt)
                                                 throws java.io.IOException

      Throws:
        `java.io.IOException`

    - #### deserializeFromString

          public java.lang.Object deserializeFromString(com.fasterxml.jackson.core.JsonParser p,
                                               DeserializationContext ctxt)
                                                 throws java.io.IOException

      Throws:
        `java.io.IOException`

    - #### deserializeFromDouble

          public java.lang.Object deserializeFromDouble(com.fasterxml.jackson.core.JsonParser p,
                                               DeserializationContext ctxt)
                                                 throws java.io.IOException

      Method called to deserialize POJO value from a JSON floating-point number.
      Throws:
        `java.io.IOException`

    - #### deserializeFromBoolean

          public java.lang.Object deserializeFromBoolean(com.fasterxml.jackson.core.JsonParser p,
                                                DeserializationContext ctxt)
                                                  throws java.io.IOException

      Method called to deserialize POJO value from a JSON boolean value (true, false)
      Throws:
        `java.io.IOException`

    - #### deserializeFromArray

          public java.lang.Object deserializeFromArray(com.fasterxml.jackson.core.JsonParser p,
                                              DeserializationContext ctxt)
                                                throws java.io.IOException

      Throws:
        `java.io.IOException`

    - #### deserializeFromEmbedded

          public java.lang.Object deserializeFromEmbedded(com.fasterxml.jackson.core.JsonParser p,
                                                 DeserializationContext ctxt)
                                                   throws java.io.IOException

      Throws:
        `java.io.IOException`

    - #### injectValues

          protected void injectValues(DeserializationContext ctxt,
                          java.lang.Object bean)
                               throws java.io.IOException

      Throws:
        `java.io.IOException`

    - #### handleUnknownProperties

          protected java.lang.Object handleUnknownProperties(DeserializationContext ctxt,
                                                 java.lang.Object bean,
                                                 TokenBuffer unknownTokens)
                                                      throws java.io.IOException

      Method called to handle set of one or more unknown properties, stored in their entirety in given `TokenBuffer` (as field entries, name and value).
      Throws:
        `java.io.IOException`

    - #### handleUnknownVanilla

          protected void handleUnknownVanilla(com.fasterxml.jackson.core.JsonParser p,
                                  DeserializationContext ctxt,
                                  java.lang.Object bean,
                                  java.lang.String propName)
                                       throws java.io.IOException

      Helper method called for an unknown property, when using "vanilla" processing.
      Throws:
        `java.io.IOException`

    - #### handleUnknownProperty

          protected void handleUnknownProperty(com.fasterxml.jackson.core.JsonParser p,
                                   DeserializationContext ctxt,
                                   java.lang.Object beanOrClass,
                                   java.lang.String propName)
                                        throws java.io.IOException

      Method called when a JSON property is encountered that has not matching setter, any-setter or field, and thus can not be assigned.
      Overrides:
        `handleUnknownProperty` in class `StdDeserializer<java.lang.Object>`
      Parameters:
        `p` - Parser that points to value of the unknown property
        `ctxt` - Context for deserialization; allows access to the parser, error reporting functionality
        `beanOrClass` - Instance that is being populated by this deserializer, or if not known, Class that would be instantiated. If null, will assume type is what `StdDeserializer.getValueClass()` returns.
        `propName` - Name of the property that can not be mapped
      Throws:
        `java.io.IOException`

    - #### handleIgnoredProperty

          protected void handleIgnoredProperty(com.fasterxml.jackson.core.JsonParser p,
                                   DeserializationContext ctxt,
                                   java.lang.Object beanOrClass,
                                   java.lang.String propName)
                                        throws java.io.IOException

      Method called when an explicitly ignored property (one specified with a name to match, either by property annotation or class annotation) is encountered.
      Throws:
        `java.io.IOException`
      Since:
        2.3

    - #### handlePolymorphic

          protected java.lang.Object handlePolymorphic(com.fasterxml.jackson.core.JsonParser p,
                                           DeserializationContext ctxt,
                                           java.lang.Object bean,
                                           TokenBuffer unknownTokens)
                                                throws java.io.IOException

      Method called in cases where we may have polymorphic deserialization case: that is, type of Creator-constructed bean is not the type of deserializer itself. It should be a sub-class or implementation class; either way, we may have more specific deserializer to use for handling it.
      Parameters:
        `p` - (optional) If not null, parser that has more properties to handle (in addition to buffered properties); if null, all properties are passed in buffer
      Throws:
        `java.io.IOException`

    - #### _findSubclassDeserializer

          protected JsonDeserializer<java.lang.Object> _findSubclassDeserializer(DeserializationContext ctxt,
                                                                     java.lang.Object bean,
                                                                     TokenBuffer unknownTokens)
                                                                          throws java.io.IOException

      Helper method called to (try to) locate deserializer for given sub-type of type that this deserializer handles.
      Throws:
        `java.io.IOException`

    - #### wrapAndThrow

          public void wrapAndThrow(java.lang.Throwable t,
                          java.lang.Object bean,
                          java.lang.String fieldName,
                          DeserializationContext ctxt)
                            throws java.io.IOException

      Method that will modify caught exception (passed in as argument) as necessary to include reference information, and to ensure it is a subtype of `IOException`, or an unchecked exception.

      Rules for wrapping and unwrapping are bit complicated; essentially:

      - Errors are to be passed as is (if uncovered via unwrapping)
      - "Plain" IOExceptions (ones that are not of type `JsonMappingException` are to be passed as is
      Throws:
        `java.io.IOException`

    - #### wrapAndThrow

          @Deprecated
          public void wrapAndThrow(java.lang.Throwable t,
                                     java.lang.Object bean,
                                     int index,
                                     DeserializationContext ctxt)
                            throws java.io.IOException

      Deprecated.
      Throws:
        `java.io.IOException`

    - #### wrapInstantiationProblem

          protected java.lang.Object wrapInstantiationProblem(java.lang.Throwable t,
                                                  DeserializationContext ctxt)
                                                       throws java.io.IOException

      Throws:
        `java.io.IOException`