BeanDeserializer (Jackson JSON Processor)
Date: 2013-07-14

org.codehaus.jackson.map.deser

## Class BeanDeserializer

- java.lang.Object
- - org.codehaus.jackson.map.JsonDeserializer<T>
  - - org.codehaus.jackson.map.deser.std.StdDeserializer<Object>
    - - org.codehaus.jackson.map.deser.BeanDeserializer

- All Implemented Interfaces:
    ResolvableDeserializer
  Direct Known Subclasses:
    ThrowableDeserializer

      public class BeanDeserializer
      extends StdDeserializer<Object>
      implements ResolvableDeserializer

  Deserializer class that can deserialize instances of arbitrary bean objects, usually from JSON Object structs, but possibly also from simple types like String values.

- - ### Nested Class Summary

    - ### Nested classes/interfaces inherited from class org.codehaus.jackson.map.deser.std.StdDeserializer

      `StdDeserializer.BigDecimalDeserializer, StdDeserializer.BigIntegerDeserializer, StdDeserializer.BooleanDeserializer, StdDeserializer.ByteDeserializer, StdDeserializer.CharacterDeserializer, StdDeserializer.DoubleDeserializer, StdDeserializer.FloatDeserializer, StdDeserializer.IntegerDeserializer, StdDeserializer.LongDeserializer, StdDeserializer.NumberDeserializer, StdDeserializer.PrimitiveOrWrapperDeserializer<T>, StdDeserializer.ShortDeserializer, StdDeserializer.SqlDateDeserializer, StdDeserializer.StackTraceElementDeserializer`

    - ### Nested classes/interfaces inherited from class org.codehaus.jackson.map.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 Map<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<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 AnnotatedClass` | `_forClass` Class for which deserializer is built; used for accessing annotations during resolution phase (see `resolve(org.codehaus.jackson.map.DeserializationConfig, org.codehaus.jackson.map.DeserializerProvider)`).
    `protected HashSet<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` | `_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 BeanProperty` | `_property` Property that contains value to be deserialized using deserializer; mostly needed to find contextual annotations for subtypes.
    `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 HashMap<ClassKey,JsonDeserializer<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())

    - ### Fields inherited from class org.codehaus.jackson.map.deser.std.StdDeserializer

      `_valueClass`

  - ### Constructor Summary

    Constructors
    Modifier | Constructor and Description
    --- | ---
    `` | `BeanDeserializer(AnnotatedClass forClass, JavaType type, BeanProperty property, CreatorCollector creators, BeanPropertyMap properties, Map<String,SettableBeanProperty> backRefs, HashSet<String> ignorableProps, boolean ignoreAllUnknown, SettableAnyProperty anySetter)` Deprecated. (since 1.9) Use the constructor that takes `ValueInstantiator` instead
    `protected` | `BeanDeserializer(AnnotatedClass forClass, JavaType type, BeanProperty property, ValueInstantiator valueInstantiator, BeanPropertyMap properties, Map<String,SettableBeanProperty> backRefs, HashSet<String> ignorableProps, boolean ignoreAllUnknown, SettableAnyProperty anySetter, List<ValueInjector> injectables)`
    `` | `BeanDeserializer(BeanDescription beanDesc, BeanProperty property, ValueInstantiator valueInstantiator, BeanPropertyMap properties, Map<String,SettableBeanProperty> backRefs, HashSet<String> ignorableProps, boolean ignoreAllUnknown, SettableAnyProperty anySetter, List<ValueInjector> injectables)`
    `protected` | `BeanDeserializer(BeanDeserializer src)` Copy-constructor that can be used by sub-classes to allow copy-on-write styling copying of settings of an existing instance.
    `protected` | `BeanDeserializer(BeanDeserializer src, boolean ignoreAllUnknown)`

  - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `protected Object` | `_deserializeUsingPropertyBased(JsonParser jp, DeserializationContext ctxt)` Method called to deserialize bean using "property-based creator": this means that a non-default constructor or factory method is called, and then possibly other setters.
    `protected JsonDeserializer<Object>` | `_findSubclassDeserializer(DeserializationContext ctxt, Object bean, TokenBuffer unknownTokens)` Helper method called to (try to) locate deserializer for given sub-type of type that this deserializer handles.
    `protected SettableBeanProperty` | `_resolveInnerClassValuedProperty(DeserializationConfig config, SettableBeanProperty prop)` Helper method that will handle gruesome details of dealing with properties that have non-static inner class as value...
    `protected SettableBeanProperty` | `_resolveManagedReferenceProperty(DeserializationConfig config, 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(DeserializationConfig config, SettableBeanProperty prop)` Helper method called to see if given property might be so-called unwrapped property: these require special handling.
    `Object` | `deserialize(JsonParser jp, DeserializationContext ctxt)` Main deserialization method for bean-based objects (POJOs).
    `Object` | `deserialize(JsonParser jp, DeserializationContext ctxt, Object bean)` Secondary deserialization method, called in cases where POJO instance is created as part of deserialization, potentially after collecting some or all of the properties to set.
    `Object` | `deserializeFromArray(JsonParser jp, DeserializationContext ctxt)`
    `Object` | `deserializeFromBoolean(JsonParser jp, DeserializationContext ctxt)` Method called to deserialize POJO value from a JSON boolean value (true, false)
    `Object` | `deserializeFromDouble(JsonParser jp, DeserializationContext ctxt)` Method called to deserialize POJO value from a JSON floating-point number.
    `Object` | `deserializeFromNumber(JsonParser jp, DeserializationContext ctxt)`
    `Object` | `deserializeFromObject(JsonParser jp, DeserializationContext ctxt)`
    `protected Object` | `deserializeFromObjectUsingNonDefault(JsonParser jp, DeserializationContext ctxt)`
    `Object` | `deserializeFromString(JsonParser jp, DeserializationContext ctxt)`
    `protected Object` | `deserializeUsingPropertyBasedWithExternalTypeId(JsonParser jp, DeserializationContext ctxt)`
    `protected Object` | `deserializeUsingPropertyBasedWithUnwrapped(JsonParser jp, DeserializationContext ctxt)`
    `protected Object` | `deserializeWithExternalTypeId(JsonParser jp, DeserializationContext ctxt)`
    `protected Object` | `deserializeWithExternalTypeId(JsonParser jp, DeserializationContext ctxt, Object bean)`
    `Object` | `deserializeWithType(JsonParser jp, DeserializationContext ctxt, TypeDeserializer typeDeserializer)` Base implementation that does not assume specific type inclusion mechanism.
    `protected Object` | `deserializeWithUnwrapped(JsonParser jp, DeserializationContext ctxt)` Method called when there are declared "unwrapped" properties which need special handling
    `protected Object` | `deserializeWithUnwrapped(JsonParser jp, DeserializationContext ctxt, Object bean)`
    `SettableBeanProperty` | `findBackReference(String logicalName)` Method needed by `BeanDeserializerFactory` to properly link managed- and back-reference pairs.
    `Class<?>` | `getBeanClass()`
    `int` | `getPropertyCount()` Accessor for checking number of deserialized properties.
    `ValueInstantiator` | `getValueInstantiator()`
    `JavaType` | `getValueType()` Exact structured type deserializer handles, if known.
    `protected Object` | `handlePolymorphic(JsonParser jp, DeserializationContext ctxt, 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 Object` | `handleUnknownProperties(DeserializationContext ctxt, 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(JsonParser jp, DeserializationContext ctxt, Object beanOrClass, 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.
    `boolean` | `hasProperty(String propertyName)`
    `protected void` | `injectValues(DeserializationContext ctxt, Object bean)`
    `Iterator<SettableBeanProperty>` | `properties()`
    `void` | `resolve(DeserializationConfig config, DeserializerProvider provider)` Method called to finalize setup of this deserializer, after deserializer itself has been registered.
    `JsonDeserializer<Object>` | `unwrappingDeserializer()` 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.
    `void` | `wrapAndThrow(Throwable t, Object bean, int index)` Deprecated. Since 1.7 use variant that takes `DeserializationContext`
    `void` | `wrapAndThrow(Throwable t, Object bean, int index, DeserializationContext ctxt)`
    `void` | `wrapAndThrow(Throwable t, Object bean, String fieldName)` Deprecated. Since 1.7 use variant that takes `DeserializationContext`
    `void` | `wrapAndThrow(Throwable t, Object bean, 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 void` | `wrapInstantiationProblem(Throwable t, DeserializationContext ctxt)`

    - ### Methods inherited from class org.codehaus.jackson.map.deser.std.StdDeserializer

      `_parseBoolean, _parseBooleanFromNumber, _parseBooleanPrimitive, _parseByte, _parseDate, _parseDouble, _parseDoublePrimitive, _parseFloat, _parseFloatPrimitive, _parseInteger, _parseIntPrimitive, _parseLong, _parseLongPrimitive, _parseShort, _parseShortPrimitive, findDeserializer, getValueClass, isDefaultSerializer, parseDouble, reportUnknownProperty`

    - ### Methods inherited from class org.codehaus.jackson.map.JsonDeserializer

      `getEmptyValue, getNullValue`

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

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

- - ### Field Detail

    - #### _forClass

          protected final AnnotatedClass _forClass

      Class for which deserializer is built; used for accessing annotations during resolution phase (see `resolve(org.codehaus.jackson.map.DeserializationConfig, org.codehaus.jackson.map.DeserializerProvider)`).

    - #### _beanType

          protected final JavaType _beanType

      Declared type of the bean this deserializer handles.

    - #### _property

          protected final BeanProperty _property

      Property that contains value to be deserialized using deserializer; mostly needed to find contextual annotations for subtypes.
      Since:
        1.7

    - #### _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<Object> _delegateDeserializer

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

    - #### _propertyBasedCreator

          protected final 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.

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

    - #### _beanProperties

          protected final BeanPropertyMap _beanProperties

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

    - #### _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.
      Since:
        1.9

    - #### _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 HashSet<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.

    - #### _backRefs

          protected final Map<String,SettableBeanProperty> _backRefs

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

    - #### _subDeserializers

          protected HashMap<ClassKey,JsonDeserializer<Object>> _subDeserializers

      Lazily constructed map used to contain deserializers needed for polymorphic subtypes.

    - #### _unwrappedPropertyHandler

          protected UnwrappedPropertyHandler _unwrappedPropertyHandler

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

    - #### _externalTypeIdHandler

          protected ExternalTypeHandler _externalTypeIdHandler

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

  - ### Constructor Detail

    - #### BeanDeserializer

          @Deprecated
          public BeanDeserializer(AnnotatedClass forClass,
                                     JavaType type,
                                     BeanProperty property,
                                     CreatorCollector creators,
                                     BeanPropertyMap properties,
                                     Map<String,SettableBeanProperty> backRefs,
                                     HashSet<String> ignorableProps,
                                     boolean ignoreAllUnknown,
                                     SettableAnyProperty anySetter)

      Deprecated. (since 1.9) Use the constructor that takes `ValueInstantiator` instead

    - #### BeanDeserializer

          public BeanDeserializer(BeanDescription beanDesc,
                          BeanProperty property,
                          ValueInstantiator valueInstantiator,
                          BeanPropertyMap properties,
                          Map<String,SettableBeanProperty> backRefs,
                          HashSet<String> ignorableProps,
                          boolean ignoreAllUnknown,
                          SettableAnyProperty anySetter,
                          List<ValueInjector> injectables)

      Since:
        1.9

    - #### BeanDeserializer

          protected BeanDeserializer(AnnotatedClass forClass,
                          JavaType type,
                          BeanProperty property,
                          ValueInstantiator valueInstantiator,
                          BeanPropertyMap properties,
                          Map<String,SettableBeanProperty> backRefs,
                          HashSet<String> ignorableProps,
                          boolean ignoreAllUnknown,
                          SettableAnyProperty anySetter,
                          List<ValueInjector> injectables)

      Since:
        1.9

    - #### BeanDeserializer

          protected BeanDeserializer(BeanDeserializer src)

      Copy-constructor that can be used by sub-classes to allow copy-on-write styling copying of settings of an existing instance.
      Since:
        1.7

    - #### BeanDeserializer

          protected BeanDeserializer(BeanDeserializer src,
                          boolean ignoreAllUnknown)

      Since:
        1.9

  - ### Method Detail

    - #### unwrappingDeserializer

          public JsonDeserializer<Object> unwrappingDeserializer()

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

    - #### hasProperty

          public boolean hasProperty(String propertyName)

    - #### getPropertyCount

          public int getPropertyCount()

      Accessor for checking number of deserialized properties.
      Since:
        1.7

    - #### getBeanClass

          public final Class<?> getBeanClass()

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

    - #### properties

          public Iterator<SettableBeanProperty> properties()

      Since:
        1.6

    - #### findBackReference

          public SettableBeanProperty findBackReference(String logicalName)

      Method needed by `BeanDeserializerFactory` to properly link managed- and back-reference pairs.

    - #### getValueInstantiator

          public ValueInstantiator getValueInstantiator()

      Since:
        1.9

    - #### resolve

          public void resolve(DeserializationConfig config,
                     DeserializerProvider provider)
                       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`
        `provider` - Provider that has constructed deserializer this method is called on.
      Throws:
        `JsonMappingException`

    - #### _resolveManagedReferenceProperty

          protected SettableBeanProperty _resolveManagedReferenceProperty(DeserializationConfig config,
                                                              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.
      Since:
        1.9

    - #### _resolveUnwrappedProperty

          protected SettableBeanProperty _resolveUnwrappedProperty(DeserializationConfig config,
                                                       SettableBeanProperty prop)

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

    - #### _resolveInnerClassValuedProperty

          protected SettableBeanProperty _resolveInnerClassValuedProperty(DeserializationConfig config,
                                                              SettableBeanProperty prop)

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

    - #### deserialize

          public final Object deserialize(JsonParser jp,
                           DeserializationContext ctxt)
                                   throws IOException,
                                          JsonProcessingException

      Main deserialization method for bean-based objects (POJOs).
      Specified by:
        `deserialize` in class `JsonDeserializer<Object>`
      Parameters:
        `jp` - Parsed used for reading JSON content
        `ctxt` - Context that can be used to access information about this deserialization activity.
      Returns:
        Deserializer value
      Throws:
        `IOException`
        `JsonProcessingException`

    - #### deserialize

          public Object deserialize(JsonParser jp,
                           DeserializationContext ctxt,
                           Object bean)
                             throws IOException,
                                    JsonProcessingException

      Secondary deserialization method, called in cases where POJO instance is created as part of deserialization, potentially after collecting some or all of the properties to set.
      Overrides:
        `deserialize` in class `JsonDeserializer<Object>`
      Throws:
        `IOException`
        `JsonProcessingException`

    - #### deserializeWithType

          public Object deserializeWithType(JsonParser jp,
                                   DeserializationContext ctxt,
                                   TypeDeserializer typeDeserializer)
                                     throws IOException,
                                            JsonProcessingException

      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<Object>`
        `typeDeserializer` - Deserializer to use for handling type information
      Throws:
        `IOException`
        `JsonProcessingException`

    - #### deserializeFromObject

          public Object deserializeFromObject(JsonParser jp,
                                     DeserializationContext ctxt)
                                       throws IOException,
                                              JsonProcessingException

      Throws:
        `IOException`
        `JsonProcessingException`

    - #### deserializeFromObjectUsingNonDefault

          protected Object deserializeFromObjectUsingNonDefault(JsonParser jp,
                                                    DeserializationContext ctxt)
                                                         throws IOException,
                                                                JsonProcessingException

      Throws:
        `IOException`
        `JsonProcessingException`
      Since:
        1.9

    - #### deserializeFromString

          public Object deserializeFromString(JsonParser jp,
                                     DeserializationContext ctxt)
                                       throws IOException,
                                              JsonProcessingException

      Throws:
        `IOException`
        `JsonProcessingException`

    - #### deserializeFromNumber

          public Object deserializeFromNumber(JsonParser jp,
                                     DeserializationContext ctxt)
                                       throws IOException,
                                              JsonProcessingException

      Throws:
        `IOException`
        `JsonProcessingException`

    - #### deserializeFromDouble

          public Object deserializeFromDouble(JsonParser jp,
                                     DeserializationContext ctxt)
                                       throws IOException,
                                              JsonProcessingException

      Method called to deserialize POJO value from a JSON floating-point number.
      Throws:
        `IOException`
        `JsonProcessingException`
      Since:
        1.9

    - #### deserializeFromBoolean

          public Object deserializeFromBoolean(JsonParser jp,
                                      DeserializationContext ctxt)
                                        throws IOException,
                                               JsonProcessingException

      Method called to deserialize POJO value from a JSON boolean value (true, false)
      Throws:
        `IOException`
        `JsonProcessingException`
      Since:
        1.9

    - #### deserializeFromArray

          public Object deserializeFromArray(JsonParser jp,
                                    DeserializationContext ctxt)
                                      throws IOException,
                                             JsonProcessingException

      Throws:
        `IOException`
        `JsonProcessingException`
      Since:
        1.9

    - #### _deserializeUsingPropertyBased

          protected final Object _deserializeUsingPropertyBased(JsonParser jp,
                                              DeserializationContext ctxt)
                                                         throws IOException,
                                                                JsonProcessingException

      Method called to deserialize bean using "property-based creator": this means that a non-default constructor or factory method is called, and then possibly other setters. The trick is that values for creator method need to be buffered, first; and due to non-guaranteed ordering possibly some other properties as well.
      Throws:
        `IOException`
        `JsonProcessingException`
      Since:
        1.2

    - #### handlePolymorphic

          protected Object handlePolymorphic(JsonParser jp,
                                 DeserializationContext ctxt,
                                 Object bean,
                                 TokenBuffer unknownTokens)
                                      throws IOException,
                                             JsonProcessingException

      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:
        `jp` - (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:
        `IOException`
        `JsonProcessingException`

    - #### deserializeWithUnwrapped

          protected Object deserializeWithUnwrapped(JsonParser jp,
                                        DeserializationContext ctxt)
                                             throws IOException,
                                                    JsonProcessingException

      Method called when there are declared "unwrapped" properties which need special handling
      Throws:
        `IOException`
        `JsonProcessingException`

    - #### deserializeWithUnwrapped

          protected Object deserializeWithUnwrapped(JsonParser jp,
                                        DeserializationContext ctxt,
                                        Object bean)
                                             throws IOException,
                                                    JsonProcessingException

      Throws:
        `IOException`
        `JsonProcessingException`

    - #### deserializeUsingPropertyBasedWithUnwrapped

          protected Object deserializeUsingPropertyBasedWithUnwrapped(JsonParser jp,
                                                          DeserializationContext ctxt)
                                                               throws IOException,
                                                                      JsonProcessingException

      Throws:
        `IOException`
        `JsonProcessingException`

    - #### deserializeWithExternalTypeId

          protected Object deserializeWithExternalTypeId(JsonParser jp,
                                             DeserializationContext ctxt)
                                                  throws IOException,
                                                         JsonProcessingException

      Throws:
        `IOException`
        `JsonProcessingException`

    - #### deserializeWithExternalTypeId

          protected Object deserializeWithExternalTypeId(JsonParser jp,
                                             DeserializationContext ctxt,
                                             Object bean)
                                                  throws IOException,
                                                         JsonProcessingException

      Throws:
        `IOException`
        `JsonProcessingException`

    - #### deserializeUsingPropertyBasedWithExternalTypeId

          protected Object deserializeUsingPropertyBasedWithExternalTypeId(JsonParser jp,
                                                               DeserializationContext ctxt)
                                                                    throws IOException,
                                                                           JsonProcessingException

      Throws:
        `IOException`
        `JsonProcessingException`

    - #### injectValues

          protected void injectValues(DeserializationContext ctxt,
                          Object bean)
                               throws IOException,
                                      JsonProcessingException

      Throws:
        `IOException`
        `JsonProcessingException`

    - #### handleUnknownProperty

          protected void handleUnknownProperty(JsonParser jp,
                                   DeserializationContext ctxt,
                                   Object beanOrClass,
                                   String propName)
                                        throws IOException,
                                               JsonProcessingException

      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<Object>`
      Parameters:
        `jp` - 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:
        `IOException`
        `JsonProcessingException`

    - #### handleUnknownProperties

          protected Object handleUnknownProperties(DeserializationContext ctxt,
                                       Object bean,
                                       TokenBuffer unknownTokens)
                                            throws IOException,
                                                   JsonProcessingException

      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:
        `IOException`
        `JsonProcessingException`

    - #### _findSubclassDeserializer

          protected JsonDeserializer<Object> _findSubclassDeserializer(DeserializationContext ctxt,
                                                           Object bean,
                                                           TokenBuffer unknownTokens)
                                                                throws IOException,
                                                                       JsonProcessingException

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

    - #### wrapAndThrow

          public void wrapAndThrow(Throwable t,
                          Object bean,
                          String fieldName,
                          DeserializationContext ctxt)
                            throws 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:
        `IOException`

    - #### wrapAndThrow

          public void wrapAndThrow(Throwable t,
                          Object bean,
                          int index,
                          DeserializationContext ctxt)
                            throws IOException

      Throws:
        `IOException`

    - #### wrapInstantiationProblem

          protected void wrapInstantiationProblem(Throwable t,
                                      DeserializationContext ctxt)
                                           throws IOException

      Throws:
        `IOException`

    - #### wrapAndThrow

          @Deprecated
          public void wrapAndThrow(Throwable t,
                                     Object bean,
                                     String fieldName)
                            throws IOException

      Deprecated. Since 1.7 use variant that takes `DeserializationContext`
      Throws:
        `IOException`

    - #### wrapAndThrow

          @Deprecated
          public void wrapAndThrow(Throwable t,
                                     Object bean,
                                     int index)
                            throws IOException

      Deprecated. Since 1.7 use variant that takes `DeserializationContext`
      Throws:
        `IOException`