com.fasterxml.jackson.databind.deser.std

## Class StdDeserializer<T>

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

All Implemented Interfaces:
  Serializable

Direct Known Subclasses:
  AtomicReferenceDeserializer, BeanDeserializerBase, ContainerDeserializerBase, DelegatingDeserializer, EnumDeserializer.FactoryBasedDeserializer, EnumSetDeserializer, FailingDeserializer, JsonNodeDeserializer, NullifyingDeserializer, PrimitiveArrayDeserializers, StdDelegatingDeserializer, StdNodeBasedDeserializer, StdScalarDeserializer, StringArrayDeserializer, UntypedObjectDeserializer, UntypedObjectDeserializer.Vanilla

    public abstract class StdDeserializer<T>
    extends JsonDeserializer<T>
    implements Serializable

Base class for common deserializers. Contains shared base functionality for dealing with primitive values, such as (re)parsing from String.

See Also:
  Serialized Form

### Nested Class Summary

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

`JsonDeserializer.None`

### Field Summary

Fields
`protected Class<?>` `_valueClass` Type of values this deserializer handles: sometimes exact types, other time most specific supertype of types deserializer handles (which may be as generic as `Object` in some case)
`protected static int` `F_MASK_INT_COERCIONS` Bitmask that covers `DeserializationFeature.USE_BIG_INTEGER_FOR_INTS` and `DeserializationFeature.USE_LONG_FOR_INTS`, used for more efficient cheks when coercing integral values for untyped deserialization.

### Constructor Summary

Constructors
`protected` `StdDeserializer(Class<?> vc)`
`protected` `StdDeserializer(JavaType valueType)`
`protected` `StdDeserializer(StdDeserializer<?> src)` Copy-constructor for sub-classes to use, most often when creating new instances for `ContextualDeserializer`.

### Method Summary

Methods
`protected Object` `_coerceIntegral(JsonParser p, DeserializationContext ctxt)` Helper method called in case where an integral number is encountered, but config settings suggest that a coercion may be needed to "upgrade" `Number` into "bigger" type like `Long` or `BigInteger`
`protected T` `_deserializeFromEmpty(JsonParser jp, DeserializationContext ctxt)` Helper method that may be used to support fallback for Empty String / Empty Array non-standard representations; usually for things serialized as JSON Objects.
`protected void` `_failDoubleToIntCoercion(JsonParser jp, DeserializationContext ctxt, String type)`
`protected boolean` `_hasTextualNull(String value)` Helper method called to determine if we are seeing String value of "null", and, further, that it should be coerced to null just like null token.
`protected boolean` `_isNaN(String text)`
`protected boolean` `_isNegInf(String text)`
`protected boolean` `_isPosInf(String text)`
`protected Boolean` `_parseBoolean(JsonParser p, DeserializationContext ctxt)`
`protected boolean` `_parseBooleanFromNumber(JsonParser jp, DeserializationContext ctxt)`
`protected boolean` `_parseBooleanPrimitive(JsonParser jp, DeserializationContext ctxt)`
`protected Byte` `_parseByte(JsonParser p, DeserializationContext ctxt)`
`protected Date` `_parseDate(JsonParser jp, DeserializationContext ctxt)`
`protected Double` `_parseDouble(JsonParser jp, DeserializationContext ctxt)`
`protected double` `_parseDoublePrimitive(JsonParser jp, DeserializationContext ctxt)`
`protected Float` `_parseFloat(JsonParser jp, DeserializationContext ctxt)`
`protected float` `_parseFloatPrimitive(JsonParser jp, DeserializationContext ctxt)`
`protected Integer` `_parseInteger(JsonParser p, DeserializationContext ctxt)`
`protected int` `_parseIntPrimitive(JsonParser p, DeserializationContext ctxt)`
`protected Long` `_parseLong(JsonParser p, DeserializationContext ctxt)`
`protected long` `_parseLongPrimitive(JsonParser p, DeserializationContext ctxt)`
`protected Short` `_parseShort(JsonParser p, DeserializationContext ctxt)`
`protected short` `_parseShortPrimitive(JsonParser jp, DeserializationContext ctxt)`
`protected String` `_parseString(JsonParser jp, DeserializationContext ctxt)` Helper method used for accessing String value, if possible, doing necessary conversion or throwing exception as necessary.
`Object` `deserializeWithType(JsonParser jp, DeserializationContext ctxt, TypeDeserializer typeDeserializer)` Base implementation that does not assume specific type inclusion mechanism.
`protected JsonDeserializer<?>` `findConvertingContentDeserializer(DeserializationContext ctxt, BeanProperty prop, JsonDeserializer<?> existingDeserializer)` Helper method that can be used to see if specified property has annotation indicating that a converter is to be used for contained values (contents of structured types; array/List/Map values)
`protected JsonDeserializer<Object>` `findDeserializer(DeserializationContext ctxt, JavaType type, BeanProperty property)` Helper method used to locate deserializers for properties the type this deserializer handles contains (usually for properties of bean types)
`Class<?>` `getValueClass()` Deprecated. Since 2.3 use `handledType()` instead
`JavaType` `getValueType()` Exact structured type deserializer handles, if known.
`Class<?>` `handledType()` Method for accessing type of values this deserializer produces.
`protected void` `handleUnknownProperty(JsonParser jp, DeserializationContext ctxt, Object instanceOrClass, String propName)` Method called to deal with a property that did not map to a known Bean property.
`protected boolean` `isDefaultDeserializer(JsonDeserializer<?> deserializer)` Method that can be called to determine if given deserializer is the default deserializer Jackson uses; as opposed to a custom deserializer installed by a module or calling application.
`protected boolean` `isDefaultKeyDeserializer(KeyDeserializer keyDeser)`
`protected static double` `parseDouble(String numStr)` Helper method for encapsulating calls to low-level double value parsing; single place just because we need a work-around that must be applied to all calls.

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

`deserialize, deserialize, findBackReference, getDelegatee, getEmptyValue, getEmptyValue, getKnownPropertyNames, getNullValue, getNullValue, getObjectIdReader, isCachable, replaceDelegatee, unwrappingDeserializer`

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

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

### Field Detail

#### F_MASK_INT_COERCIONS

    protected static final int F_MASK_INT_COERCIONS

Bitmask that covers `DeserializationFeature.USE_BIG_INTEGER_FOR_INTS` and `DeserializationFeature.USE_LONG_FOR_INTS`, used for more efficient cheks when coercing integral values for untyped deserialization.

Since:
  2.6

#### _valueClass

    protected final Class<?> _valueClass

Type of values this deserializer handles: sometimes exact types, other time most specific supertype of types deserializer handles (which may be as generic as `Object` in some case)

### Constructor Detail

#### StdDeserializer

    protected StdDeserializer(Class<?> vc)

#### StdDeserializer

    protected StdDeserializer(JavaType valueType)

#### StdDeserializer

    protected StdDeserializer(StdDeserializer<?> src)

Copy-constructor for sub-classes to use, most often when creating new instances for `ContextualDeserializer`.

Since:
  2.5

### Method Detail

#### handledType

    public 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 `JsonDeserializer<T>`

#### getValueClass

    @Deprecated
    public final Class<?> getValueClass()

Deprecated. Since 2.3 use `handledType()` instead

#### getValueType

    public JavaType getValueType()

Exact structured type deserializer handles, if known.

Default implementation just returns null.

#### isDefaultDeserializer

    protected boolean isDefaultDeserializer(JsonDeserializer<?> deserializer)

Method that can be called to determine if given deserializer is the default deserializer Jackson uses; as opposed to a custom deserializer installed by a module or calling application. Determination is done using `JacksonStdImpl` annotation on deserializer class.

#### isDefaultKeyDeserializer

    protected boolean isDefaultKeyDeserializer(KeyDeserializer keyDeser)

#### deserializeWithType

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

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

#### _parseBooleanPrimitive

    protected final boolean _parseBooleanPrimitive(JsonParser jp,
                                 DeserializationContext ctxt)
                                            throws IOException

Throws:
  `IOException`

#### _parseBoolean

    protected final Boolean _parseBoolean(JsonParser p,
                        DeserializationContext ctxt)
                                   throws IOException

Throws:
  `IOException`

#### _parseBooleanFromNumber

    protected final boolean _parseBooleanFromNumber(JsonParser jp,
                                  DeserializationContext ctxt)
                                             throws IOException

Throws:
  `IOException`

#### _parseByte

    protected Byte _parseByte(JsonParser p,
                  DeserializationContext ctxt)
                       throws IOException

Throws:
  `IOException`

#### _parseShort

    protected Short _parseShort(JsonParser p,
                    DeserializationContext ctxt)
                         throws IOException

Throws:
  `IOException`

#### _parseShortPrimitive

    protected final short _parseShortPrimitive(JsonParser jp,
                             DeserializationContext ctxt)
                                        throws IOException

Throws:
  `IOException`

#### _parseIntPrimitive

    protected final int _parseIntPrimitive(JsonParser p,
                         DeserializationContext ctxt)
                                    throws IOException

Throws:
  `IOException`

#### _parseInteger

    protected final Integer _parseInteger(JsonParser p,
                        DeserializationContext ctxt)
                                   throws IOException

Throws:
  `IOException`

#### _parseLong

    protected final Long _parseLong(JsonParser p,
                  DeserializationContext ctxt)
                             throws IOException

Throws:
  `IOException`

#### _parseLongPrimitive

    protected final long _parseLongPrimitive(JsonParser p,
                           DeserializationContext ctxt)
                                      throws IOException

Throws:
  `IOException`

#### _parseFloat

    protected final Float _parseFloat(JsonParser jp,
                    DeserializationContext ctxt)
                               throws IOException

Throws:
  `IOException`

#### _parseFloatPrimitive

    protected final float _parseFloatPrimitive(JsonParser jp,
                             DeserializationContext ctxt)
                                        throws IOException

Throws:
  `IOException`

#### _parseDouble

    protected final Double _parseDouble(JsonParser jp,
                      DeserializationContext ctxt)
                                 throws IOException

Throws:
  `IOException`

#### _parseDoublePrimitive

    protected final double _parseDoublePrimitive(JsonParser jp,
                               DeserializationContext ctxt)
                                          throws IOException

Throws:
  `IOException`

#### _parseDate

    protected Date _parseDate(JsonParser jp,
                  DeserializationContext ctxt)
                       throws IOException

Throws:
  `IOException`

#### parseDouble

    protected static final double parseDouble(String numStr)
                                       throws NumberFormatException

Helper method for encapsulating calls to low-level double value parsing; single place just because we need a work-around that must be applied to all calls.

Throws:
  `NumberFormatException`

#### _parseString

    protected final String _parseString(JsonParser jp,
                      DeserializationContext ctxt)
                                 throws IOException

Helper method used for accessing String value, if possible, doing necessary conversion or throwing exception as necessary.

Throws:
  `IOException`
Since:
  2.1

#### _deserializeFromEmpty

    protected T _deserializeFromEmpty(JsonParser jp,
                          DeserializationContext ctxt)
                               throws IOException

Helper method that may be used to support fallback for Empty String / Empty Array non-standard representations; usually for things serialized as JSON Objects.

Throws:
  `IOException`
Since:
  2.5

#### _hasTextualNull

    protected boolean _hasTextualNull(String value)

Helper method called to determine if we are seeing String value of "null", and, further, that it should be coerced to null just like null token.

Since:
  2.3

#### _isNegInf

    protected final boolean _isNegInf(String text)

#### _isPosInf

    protected final boolean _isPosInf(String text)

#### _isNaN

    protected final boolean _isNaN(String text)

#### _coerceIntegral

    protected Object _coerceIntegral(JsonParser p,
                         DeserializationContext ctxt)
                              throws IOException

Helper method called in case where an integral number is encountered, but config settings suggest that a coercion may be needed to "upgrade" `Number` into "bigger" type like `Long` or `BigInteger`

Throws:
  `IOException`
Since:
  2.6
See Also:
  `DeserializationFeature#USE_BIG_INTEGER_FOR_INTS}, {@link DeserializationFeature#USE_LONG_FOR_INTS}`

#### findDeserializer

    protected JsonDeserializer<Object> findDeserializer(DeserializationContext ctxt,
                                            JavaType type,
                                            BeanProperty property)
                                                 throws JsonMappingException

Helper method used to locate deserializers for properties the type this deserializer handles contains (usually for properties of bean types)

Parameters:
  `type` - Type of property to deserialize
  `property` - Actual property object (field, method, constuctor parameter) used for passing deserialized values; provided so deserializer can be contextualized if necessary (since 1.7)
Throws:
  `JsonMappingException`

#### findConvertingContentDeserializer

    protected JsonDeserializer<?> findConvertingContentDeserializer(DeserializationContext ctxt,
                                                        BeanProperty prop,
                                                        JsonDeserializer<?> existingDeserializer)
                                                             throws JsonMappingException

Helper method that can be used to see if specified property has annotation indicating that a converter is to be used for contained values (contents of structured types; array/List/Map values)

Parameters:
  `existingDeserializer` - (optional) configured content serializer if one already exists.
Throws:
  `JsonMappingException`
Since:
  2.2

#### handleUnknownProperty

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

Method called to deal with a property that did not map to a known Bean property. Method can deal with the problem as it sees fit (ignore, throw exception); but if it does return, it has to skip the matching Json content parser has.

NOTE: method signature was changed in version 1.5; explicit JsonParser must be passed since it may be something other than what context has. Prior versions did not include the first parameter.

Parameters:
  `jp` - Parser that points to value of the unknown property
  `ctxt` - Context for deserialization; allows access to the parser, error reporting functionality
  `instanceOrClass` - Instance that is being populated by this deserializer, or if not known, Class that would be instantiated. If null, will assume type is what `getValueClass()` returns.
  `propName` - Name of the property that can not be mapped
Throws:
  `IOException`

#### _failDoubleToIntCoercion

    protected void _failDoubleToIntCoercion(JsonParser jp,
                                DeserializationContext ctxt,
                                String type)
                                     throws IOException

Throws:
  `IOException`