org.codehaus.jackson.map.deser.std

## Class StdDeserializer<T>

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

- Direct Known Subclasses:
    BeanDeserializer, ContainerDeserializerBase, DomElementJsonDeserializer, EnumMapDeserializer, EnumSetDeserializer, JsonNodeDeserializer, StdDeserializer, StdScalarDeserializer, StdScalarDeserializer, UntypedObjectDeserializer, XmlAdapterJsonDeserializer

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

  Base class for common deserializers. Contains shared base functionality for dealing with primitive values, such as (re)parsing from String.
  Since:
    1.9 (moved from higher-level package)

- - ### Nested Class Summary

    Nested Classes
    Modifier and Type | Class and Description
    --- | ---
    `static class` | `StdDeserializer.BigDecimalDeserializer`
    `static class` | `StdDeserializer.BigIntegerDeserializer` This is bit trickier to implement efficiently, while avoiding overflow problems.
    `static class` | `StdDeserializer.BooleanDeserializer`
    `static class` | `StdDeserializer.ByteDeserializer`
    `static class` | `StdDeserializer.CharacterDeserializer`
    `static class` | `StdDeserializer.DoubleDeserializer`
    `static class` | `StdDeserializer.FloatDeserializer`
    `static class` | `StdDeserializer.IntegerDeserializer`
    `static class` | `StdDeserializer.LongDeserializer`
    `static class` | `StdDeserializer.NumberDeserializer` For type `Number.class`, we can just rely on type mappings that plain `JsonParser.getNumberValue()` returns.
    `protected static class` | `StdDeserializer.PrimitiveOrWrapperDeserializer<T>`
    `static class` | `StdDeserializer.ShortDeserializer`
    `static class` | `StdDeserializer.SqlDateDeserializer` Compared to plain old `Date`, SQL version is easier to deal with: mostly because it is more limited.
    `static class` | `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 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 Summary

    Constructors
    Modifier | Constructor and Description
    --- | ---
    `protected` | `StdDeserializer(Class<?> vc)`
    `protected` | `StdDeserializer(JavaType valueType)`

  - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `protected Boolean` | `_parseBoolean(JsonParser jp, DeserializationContext ctxt)`
    `protected boolean` | `_parseBooleanFromNumber(JsonParser jp, DeserializationContext ctxt)`
    `protected boolean` | `_parseBooleanPrimitive(JsonParser jp, DeserializationContext ctxt)`
    `protected Byte` | `_parseByte(JsonParser jp, 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 jp, DeserializationContext ctxt)`
    `protected int` | `_parseIntPrimitive(JsonParser jp, DeserializationContext ctxt)`
    `protected Long` | `_parseLong(JsonParser jp, DeserializationContext ctxt)`
    `protected long` | `_parseLongPrimitive(JsonParser jp, DeserializationContext ctxt)`
    `protected Short` | `_parseShort(JsonParser jp, DeserializationContext ctxt)`
    `protected short` | `_parseShortPrimitive(JsonParser jp, DeserializationContext ctxt)`
    `Object` | `deserializeWithType(JsonParser jp, DeserializationContext ctxt, TypeDeserializer typeDeserializer)` Base implementation that does not assume specific type inclusion mechanism.
    `protected JsonDeserializer<Object>` | `findDeserializer(DeserializationConfig config, DeserializerProvider provider, 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()`
    `JavaType` | `getValueType()` Exact structured type deserializer handles, if known.
    `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` | `isDefaultSerializer(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 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.
    `protected void` | `reportUnknownProperty(DeserializationContext ctxt, Object instanceOrClass, String fieldName)`

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

      `deserialize, deserialize, getEmptyValue, getNullValue, unwrappingDeserializer`

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

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

- - ### Field Detail

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

  - ### Method Detail

    - #### getValueClass

          public Class<?> getValueClass()

    - #### getValueType

          public JavaType getValueType()

      Exact structured type deserializer handles, if known.

      Default implementation just returns null.

    - #### isDefaultSerializer

          protected boolean isDefaultSerializer(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.
      Since:
        1.7

    - #### deserializeWithType

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

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

    - #### _parseBooleanPrimitive

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

      Throws:
        `IOException`
        `JsonProcessingException`

    - #### _parseBoolean

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

      Throws:
        `IOException`
        `JsonProcessingException`

    - #### _parseBooleanFromNumber

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

      Throws:
        `IOException`
        `JsonProcessingException`

    - #### _parseByte

          protected Byte _parseByte(JsonParser jp,
                        DeserializationContext ctxt)
                             throws IOException,
                                    JsonProcessingException

      Throws:
        `IOException`
        `JsonProcessingException`

    - #### _parseShort

          protected Short _parseShort(JsonParser jp,
                          DeserializationContext ctxt)
                               throws IOException,
                                      JsonProcessingException

      Throws:
        `IOException`
        `JsonProcessingException`

    - #### _parseShortPrimitive

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

      Throws:
        `IOException`
        `JsonProcessingException`

    - #### _parseIntPrimitive

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

      Throws:
        `IOException`
        `JsonProcessingException`

    - #### _parseInteger

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

      Throws:
        `IOException`
        `JsonProcessingException`

    - #### _parseLong

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

      Throws:
        `IOException`
        `JsonProcessingException`

    - #### _parseLongPrimitive

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

      Throws:
        `IOException`
        `JsonProcessingException`

    - #### _parseFloat

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

      Throws:
        `IOException`
        `JsonProcessingException`

    - #### _parseFloatPrimitive

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

      Throws:
        `IOException`
        `JsonProcessingException`

    - #### _parseDouble

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

      Throws:
        `IOException`
        `JsonProcessingException`

    - #### _parseDoublePrimitive

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

      Throws:
        `IOException`
        `JsonProcessingException`

    - #### _parseDate

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

      Throws:
        `IOException`
        `JsonProcessingException`

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

      Note: copied from `org.codehaus.jackson.io.NumberUtil` (to avoid dependency to version 1.8; except for String constants, but that gets compiled in bytecode here)

      Throws:
        `NumberFormatException`

    - #### findDeserializer

          protected JsonDeserializer<Object> findDeserializer(DeserializationConfig config,
                                                  DeserializerProvider provider,
                                                  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:
        `config` - Active deserialization configuration
        `provider` - Deserializer provider to use for actually finding deserializer(s)
        `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`

    - #### handleUnknownProperty

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

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

    - #### reportUnknownProperty

          protected void reportUnknownProperty(DeserializationContext ctxt,
                                   Object instanceOrClass,
                                   String fieldName)
                                        throws IOException,
                                               JsonProcessingException

      Throws:
        `IOException`
        `JsonProcessingException`