com.fasterxml.jackson.databind

## Enum DeserializationFeature

- java.lang.Object
- - java.lang.Enum<DeserializationFeature>
  - - com.fasterxml.jackson.databind.DeserializationFeature

All Implemented Interfaces:
  ConfigFeature, Serializable, Comparable<DeserializationFeature>

    public enum DeserializationFeature
    extends Enum<DeserializationFeature>
    implements ConfigFeature

Enumeration that defines simple on/off features that affect the way Java objects are deserialized from JSON

Note that features can be set both through `ObjectMapper` (as sort of defaults) and through `ObjectReader`. In first case these defaults must follow "config-then-use" patterns (i.e. defined once, not changed afterwards); all per-call changes must be done using `ObjectReader`.

Note that features that do not indicate version of inclusion were available in Jackson 2.0 (or earlier); only later additions indicate version of inclusion.

### Enum Constant Summary

Enum Constants
Enum Constant and Description
`ACCEPT_EMPTY_ARRAY_AS_NULL_OBJECT` Feature that can be enabled to allow empty JSON Array value (that is, to be bound to POJOs (and with 2.9, other values too) as `null`.
`ACCEPT_EMPTY_STRING_AS_NULL_OBJECT` Feature that can be enabled to allow JSON empty String value (`""`) to be bound as `null` for POJOs and other structured values (`Map`s, `Collection`s).
`ACCEPT_FLOAT_AS_INT` Feature that determines whether coercion from JSON floating point number (anything with command (`.`) or exponent portion (`e` / `E')) to an expected integral number (`int`, `long`, `java.lang.Integer`, `java.lang.Long`, `java.math.BigDecimal`) is allowed or not.
`ACCEPT_SINGLE_VALUE_AS_ARRAY` Feature that determines whether it is acceptable to coerce non-array (in JSON) values to work with Java collection (arrays, java.util.Collection) types.
`ADJUST_DATES_TO_CONTEXT_TIME_ZONE` Feature that specifies whether context provided `TimeZone` (`DeserializationContext.getTimeZone()` should be used to adjust Date/Time values on deserialization, even if value itself contains timezone information.
`EAGER_DESERIALIZER_FETCH` Feature that determines whether `ObjectReader` should try to eagerly fetch necessary `JsonDeserializer` when possible.
`FAIL_ON_IGNORED_PROPERTIES` Feature that determines what happens when a property that has been explicitly marked as ignorable is encountered in input: if feature is enabled, `JsonMappingException` is thrown; if false, property is quietly skipped.
`FAIL_ON_INVALID_SUBTYPE` Feature that determines what happens when type of a polymorphic value (indicated for example by `JsonTypeInfo`) cannot be found (missing) or resolved (invalid class name, non-mappable id); if enabled, an exception is thrown; if false, null value is used instead.
`FAIL_ON_MISSING_CREATOR_PROPERTIES` Feature that determines what happens if one or more Creator properties (properties bound to parameters of Creator method (constructor or static factory method)) are missing value to bind to from content.
`FAIL_ON_MISSING_EXTERNAL_TYPE_ID_PROPERTY` Feature that determines what happens when a property annotated with `JsonTypeInfo.As.EXTERNAL_PROPERTY` is missing, but associated type id is available.
`FAIL_ON_NULL_CREATOR_PROPERTIES` Feature that determines what happens if one or more Creator properties (properties bound to parameters of Creator method (constructor or static factory method)) are bound to null values - either from the JSON or as a default value.
`FAIL_ON_NULL_FOR_PRIMITIVES` Feature that determines whether encountering of JSON null is an error when deserializing into Java primitive types (like 'int' or 'double').
`FAIL_ON_NUMBERS_FOR_ENUMS` Feature that determines whether JSON integer numbers are valid values to be used for deserializing Java enum values.
`FAIL_ON_READING_DUP_TREE_KEY` Feature that determines what happens when reading JSON content into tree (`JsonNode` and a duplicate key is encountered (property name that was already seen for the JSON Object).

`FAIL_ON_SUBTYPE_CLASS_NOT_REGISTERED`
Feature that determines behavior when deserializing polymorphic types that use Class-based Type Id mechanism (either `JsonTypeInfo.Id.CLASS` or `JsonTypeInfo.Id.MINIMAL_CLASS`): If enabled, an exception will be thrown if a subtype (Class) is encountered that has not been explicitly registered (by calling `ObjectMapper.registerSubtypes(java.lang.Class<?>...)` or `JsonSubTypes`).

`FAIL_ON_TRAILING_TOKENS` Feature that determines behavior for data-binding after binding the root value.
`FAIL_ON_UNEXPECTED_VIEW_PROPERTIES` Feature that determines the handling of properties not included in the active JSON view during deserialization.
`FAIL_ON_UNKNOWN_INJECT_VALUE` Feature that determines the handling of injected properties during deserialization.
`FAIL_ON_UNKNOWN_PROPERTIES` Feature that determines whether encountering of unknown properties (ones that do not map to a property, and there is no "any setter" or handler that can handle it) should result in a failure (by throwing a `JsonMappingException`) or not.
`FAIL_ON_UNRESOLVED_OBJECT_IDS` Feature that determines what happens if an Object Id reference is encountered that does not refer to an actual Object with that id ("unresolved Object Id"): either an exception `UnresolvedForwardReference` containing information about `UnresolvedId` is thrown (`true`), or a null object is used instead (`false`).
`READ_DATE_TIMESTAMPS_AS_NANOSECONDS` Feature that controls whether numeric timestamp values are expected to be written using nanosecond timestamps (enabled) or not (disabled), if and only if datatype supports such resolution.
`READ_ENUMS_USING_TO_STRING` Feature that determines standard deserialization mechanism used for Enum values: if enabled, Enums are assumed to have been serialized using return value of `Enum.toString()`; if disabled, return value of `Enum.name()` is assumed to have been used.
`READ_UNKNOWN_ENUM_VALUES_AS_NULL` Feature that allows unknown Enum values to be parsed as `null` values.
`READ_UNKNOWN_ENUM_VALUES_USING_DEFAULT_VALUE` Feature that allows unknown Enum values to be ignored and replaced by a predefined value specified through `@JsonEnumDefaultValue` annotation.
`UNWRAP_ROOT_VALUE` Feature to allow "unwrapping" root-level JSON value, to match setting of `SerializationFeature.WRAP_ROOT_VALUE` used for serialization.
`UNWRAP_SINGLE_VALUE_ARRAYS` Feature that determines whether it is acceptable to coerce single value array (in JSON) values to the corresponding value type.
`USE_BIG_DECIMAL_FOR_FLOATS` Feature that determines whether JSON floating point numbers are to be deserialized into `BigDecimal`s if only generic type description (either `Object` or `Number`, or within untyped `Map` or `Collection` context) is available.
`USE_BIG_INTEGER_FOR_INTS` Feature that determines whether JSON integral (non-floating-point) numbers are to be deserialized into `BigInteger`s if only generic type description (either `Object` or `Number`, or within untyped `Map` or `Collection` context) is available.
`USE_JAVA_ARRAY_FOR_JSON_ARRAY` Feature that determines whether JSON Array is mapped to `Object[]` or `List<Object>` when binding "untyped" objects (ones with nominal type of `java.lang.Object`).
`USE_LONG_FOR_INTS` Feature that determines how "small" JSON integral (non-floating-point) numbers -- ones that fit in 32-bit signed integer (`int`) -- are bound when target type is loosely typed as `Object` or `Number` (or within untyped `Map` or `Collection` context).
`WRAP_EXCEPTIONS` Feature that determines whether Jackson code should catch and wrap `Exception`s (but never `Error`s!)

### Method Summary

All Methods Static Methods Instance Methods Concrete Methods
`boolean` `enabledByDefault()` Accessor for checking whether this feature is enabled by default.
`boolean` `enabledIn(int flags)` Convenience method for checking whether feature is enabled in given bitmask
`int` `getMask()` Returns bit mask for this feature instance
`static DeserializationFeature` `valueOf(String name)` Returns the enum constant of this type with the specified name.
`static DeserializationFeature[]` `values()` Returns an array containing the constants of this enum type, in the order they are declared.

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

`clone, compareTo, equals, finalize, getDeclaringClass, hashCode, name, ordinal, toString, valueOf`

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

`getClass, notify, notifyAll, wait, wait, wait`

### Enum Constant Detail

#### USE_BIG_DECIMAL_FOR_FLOATS

    public static final DeserializationFeature USE_BIG_DECIMAL_FOR_FLOATS

Feature that determines whether JSON floating point numbers are to be deserialized into `BigDecimal`s if only generic type description (either `Object` or `Number`, or within untyped `Map` or `Collection` context) is available. If enabled such values will be deserialized as `BigDecimal`s; if disabled, will be deserialized as `Double`s.

NOTE: one aspect of `BigDecimal` handling that may need configuring is whether trailing zeroes are trimmed: `JsonNodeFactory` has `JsonNodeFactory.withExactBigDecimals(boolean)` for changing default behavior (default is for trailing zeroes to be trimmed).

Feature is disabled by default, meaning that "untyped" floating point numbers will by default be deserialized as `Double`s (choice is for performance reason -- BigDecimals are slower than Doubles).

#### USE_BIG_INTEGER_FOR_INTS

    public static final DeserializationFeature USE_BIG_INTEGER_FOR_INTS

Feature that determines whether JSON integral (non-floating-point) numbers are to be deserialized into `BigInteger`s if only generic type description (either `Object` or `Number`, or within untyped `Map` or `Collection` context) is available. If enabled such values will be deserialized as `BigInteger`s; if disabled, will be deserialized as "smallest" available type, which is either `Integer`, `Long` or `BigInteger`, depending on number of digits.

Feature is disabled by default, meaning that "untyped" integral numbers will by default be deserialized using whatever is the most compact integral type, to optimize efficiency.

#### USE_LONG_FOR_INTS

    public static final DeserializationFeature USE_LONG_FOR_INTS

Feature that determines how "small" JSON integral (non-floating-point) numbers -- ones that fit in 32-bit signed integer (`int`) -- are bound when target type is loosely typed as `Object` or `Number` (or within untyped `Map` or `Collection` context). If enabled, such values will be deserialized as `Long`; if disabled, they will be deserialized as "smallest" available type, `Integer`.

Note: if `USE_BIG_INTEGER_FOR_INTS` is enabled, it has precedence over this setting, forcing use of `BigInteger` for all integral values.

Feature is disabled by default, meaning that "untyped" integral numbers will by default be deserialized using `Integer` if value fits.

Since:
  2.6

#### USE_JAVA_ARRAY_FOR_JSON_ARRAY

    public static final DeserializationFeature USE_JAVA_ARRAY_FOR_JSON_ARRAY

Feature that determines whether JSON Array is mapped to `Object[]` or `List<Object>` when binding "untyped" objects (ones with nominal type of `java.lang.Object`). If true, binds as `Object[]`; if false, as `List<Object>`.

Feature is disabled by default, meaning that JSON arrays are bound as `List`s.

#### FAIL_ON_UNKNOWN_PROPERTIES

    public static final DeserializationFeature FAIL_ON_UNKNOWN_PROPERTIES

Feature that determines whether encountering of unknown properties (ones that do not map to a property, and there is no "any setter" or handler that can handle it) should result in a failure (by throwing a `JsonMappingException`) or not. This setting only takes effect after all other handling methods for unknown properties have been tried, and property remains unhandled.

Feature is enabled by default (meaning that a `JsonMappingException` will be thrown if an unknown property is encountered).

#### FAIL_ON_NULL_FOR_PRIMITIVES

    public static final DeserializationFeature FAIL_ON_NULL_FOR_PRIMITIVES

Feature that determines whether encountering of JSON null is an error when deserializing into Java primitive types (like 'int' or 'double'). If it is, a `InvalidNullException` is thrown to indicate this; if not, default value is used (0 for 'int', 0.0 for double, same defaulting as what JVM uses).

Feature is disabled by default for Jackson 2.x: will be changed to enabled in 3.0.

#### FAIL_ON_NUMBERS_FOR_ENUMS

    public static final DeserializationFeature FAIL_ON_NUMBERS_FOR_ENUMS

Feature that determines whether JSON integer numbers are valid values to be used for deserializing Java enum values. If set to 'false' numbers are acceptable and are used to map to ordinal() of matching enumeration value; if 'true', numbers are not allowed and a `JsonMappingException` will be thrown. Latter behavior makes sense if there is concern that accidental mapping from integer values to enums might happen (and when enums are always serialized as JSON Strings)

Feature is disabled by default.

#### FAIL_ON_INVALID_SUBTYPE

    public static final DeserializationFeature FAIL_ON_INVALID_SUBTYPE

Feature that determines what happens when type of a polymorphic value (indicated for example by `JsonTypeInfo`) cannot be found (missing) or resolved (invalid class name, non-mappable id); if enabled, an exception is thrown; if false, null value is used instead.

Feature is enabled by default so that exception is thrown for missing or invalid type information.

Since:
  2.2

#### FAIL_ON_READING_DUP_TREE_KEY

    public static final DeserializationFeature FAIL_ON_READING_DUP_TREE_KEY

Feature that determines what happens when reading JSON content into tree (`JsonNode` and a duplicate key is encountered (property name that was already seen for the JSON Object). If enabled, `JsonMappingException` will be thrown; if disabled, no exception is thrown and the new (later) value overwrites the earlier value.

Note that this property does NOT affect other aspects of data-binding; that is, no detection is done with respect to POJO properties or `Map` keys. New features may be added to control additional cases.

Feature is disabled by default so that no exception is thrown.

Since:
  2.3

#### FAIL_ON_IGNORED_PROPERTIES

    public static final DeserializationFeature FAIL_ON_IGNORED_PROPERTIES

Feature that determines what happens when a property that has been explicitly marked as ignorable is encountered in input: if feature is enabled, `JsonMappingException` is thrown; if false, property is quietly skipped.

Feature is disabled by default so that no exception is thrown.

Since:
  2.3

#### FAIL_ON_UNRESOLVED_OBJECT_IDS

    public static final DeserializationFeature FAIL_ON_UNRESOLVED_OBJECT_IDS

Feature that determines what happens if an Object Id reference is encountered that does not refer to an actual Object with that id ("unresolved Object Id"): either an exception `UnresolvedForwardReference` containing information about `UnresolvedId` is thrown (`true`), or a null object is used instead (`false`). Note that if this is set to `false`, no further processing is done; specifically, if reference is defined via setter method, that method will NOT be called.

Feature is enabled by default, so that unknown Object Ids will result in an exception being thrown, at the end of deserialization.

Since:
  2.5

#### FAIL_ON_MISSING_CREATOR_PROPERTIES

    public static final DeserializationFeature FAIL_ON_MISSING_CREATOR_PROPERTIES

Feature that determines what happens if one or more Creator properties (properties bound to parameters of Creator method (constructor or static factory method)) are missing value to bind to from content. If enabled, such missing values result in a `JsonMappingException` being thrown with information on the first one (by index) of missing properties. If disabled, and if property is NOT marked as required, missing Creator properties are filled with `null values` provided by deserializer for the type of parameter (usually null for Object types, and default value for primitives; but redefinable via custom deserializers).

Note that having an injectable value counts as "not missing".

Feature is disabled by default, so that no exception is thrown for missing creator property values, unless they are explicitly marked as `required`.

Since:
  2.6

#### FAIL_ON_NULL_CREATOR_PROPERTIES

    public static final DeserializationFeature FAIL_ON_NULL_CREATOR_PROPERTIES

Feature that determines what happens if one or more Creator properties (properties bound to parameters of Creator method (constructor or static factory method)) are bound to null values - either from the JSON or as a default value. This is useful if you want to avoid nulls in your codebase, and particularly useful if you are using Java or Scala optionals for non-mandatory fields. Feature is disabled by default, so that no exception is thrown for missing creator property values, unless they are explicitly marked as `required`.

Since:
  2.8

#### FAIL_ON_MISSING_EXTERNAL_TYPE_ID_PROPERTY

    public static final DeserializationFeature FAIL_ON_MISSING_EXTERNAL_TYPE_ID_PROPERTY

Feature that determines what happens when a property annotated with `JsonTypeInfo.As.EXTERNAL_PROPERTY` is missing, but associated type id is available. If enabled, `JsonMappingException` is always thrown when property value is missing (if type id does exist); if disabled, exception is only thrown if property is marked as `required`.

Feature is enabled by default, so that exception is thrown when a subtype property is missing.

Since:
  2.9

#### FAIL_ON_TRAILING_TOKENS

    public static final DeserializationFeature FAIL_ON_TRAILING_TOKENS

Feature that determines behavior for data-binding after binding the root value. If feature is enabled, one more call to `JsonParser.nextToken()` is made to ensure that no more tokens are found (and if any is found, `MismatchedInputException` is thrown); if disabled, no further checks are made.

Feature could alternatively be called `READ_FULL_STREAM`, since it effectively verifies that input stream contains only as much data as is needed for binding the full value, and nothing more (except for possible ignorable white space or comments, if supported by data format).

Feature is disabled by default (so that no check is made for possible trailing token(s)) for backwards-compatibility reasons.

Since:
  2.9

#### FAIL_ON_SUBTYPE_CLASS_NOT_REGISTERED

    public static final DeserializationFeature FAIL_ON_SUBTYPE_CLASS_NOT_REGISTERED

Feature that determines behavior when deserializing polymorphic types that use Class-based Type Id mechanism (either `JsonTypeInfo.Id.CLASS` or `JsonTypeInfo.Id.MINIMAL_CLASS`): If enabled, an exception will be thrown if a subtype (Class) is encountered that has not been explicitly registered (by calling `ObjectMapper.registerSubtypes(java.lang.Class<?>...)` or `JsonSubTypes`).

Note that for Type Name - based Type Id mechanism (`JsonTypeInfo.Id.NAME`) you already need to register the subtypes but with so this feature has no effect.

Feature is disabled by default.

Since:
  2.19

#### WRAP_EXCEPTIONS

    public static final DeserializationFeature WRAP_EXCEPTIONS

Feature that determines whether Jackson code should catch and wrap `Exception`s (but never `Error`s!) to add additional information about location (within input) of problem or not. If enabled, most exceptions will be caught and re-thrown (exception specifically being that `IOException`s may be passed as is, since they are declared as throwable); this can be convenient both in that all exceptions will be checked and declared, and so there is more contextual information. However, sometimes calling application may just want "raw" unchecked exceptions passed as is.

NOTE: most of the time exceptions that may or may not be wrapped are of type `RuntimeException`: as mentioned earlier, various `IOException`s (and in particular `JacksonException`s) will always be passed as-is.

Disabling this feature will mean that you will need to adjust your try/catch blocks to properly handle `RuntimeException`s. Failing to do so, may cause your application to crash due to unhandled exceptions.

Feature is enabled by default.

#### FAIL_ON_UNEXPECTED_VIEW_PROPERTIES

    public static final DeserializationFeature FAIL_ON_UNEXPECTED_VIEW_PROPERTIES

Feature that determines the handling of properties not included in the active JSON view during deserialization.

When enabled, if a property is encountered during deserialization that is not part of the active view (as defined by `JsonView`).

This feature is particularly useful in scenarios where strict adherence to the specified view is required and any deviation, such as the presence of properties not belonging to the view, should be reported as an error. It enhances the robustness of data binding by ensuring that only the properties relevant to the active view are considered during deserialization, thereby preventing unintended data from being processed.

This feature is disabled by default to maintain backward compatibility

Since:
  2.17

#### FAIL_ON_UNKNOWN_INJECT_VALUE

    public static final DeserializationFeature FAIL_ON_UNKNOWN_INJECT_VALUE

Feature that determines the handling of injected properties during deserialization.

When enabled, if an injected property without matching value is encountered during deserialization, an exception is thrown. When disabled, no exception is thrown. See `JacksonInject.optional()` for per-property override of this setting.

This feature is enabled by default to maintain backwards-compatibility.

Since:
  2.20
See Also:
  `JacksonInject.optional()`

#### ACCEPT_SINGLE_VALUE_AS_ARRAY

    public static final DeserializationFeature ACCEPT_SINGLE_VALUE_AS_ARRAY

Feature that determines whether it is acceptable to coerce non-array (in JSON) values to work with Java collection (arrays, java.util.Collection) types. If enabled, collection deserializers will try to handle non-array values as if they had "implicit" surrounding JSON array. This feature is meant to be used for compatibility/interoperability reasons, to work with packages (such as XML-to-JSON converters) that leave out JSON array in cases where there is just a single element in array.

Feature is disabled by default.

#### UNWRAP_SINGLE_VALUE_ARRAYS

    public static final DeserializationFeature UNWRAP_SINGLE_VALUE_ARRAYS

Feature that determines whether it is acceptable to coerce single value array (in JSON) values to the corresponding value type. This is basically the opposite of the `ACCEPT_SINGLE_VALUE_AS_ARRAY` feature. If more than one value is found in the array, a JsonMappingException is thrown.

NOTE: only single wrapper Array is allowed: if multiple attempted, exception will be thrown. Feature is disabled by default.

Since:
  2.4

#### UNWRAP_ROOT_VALUE

    public static final DeserializationFeature UNWRAP_ROOT_VALUE

Feature to allow "unwrapping" root-level JSON value, to match setting of `SerializationFeature.WRAP_ROOT_VALUE` used for serialization. Will verify that the root JSON value is a JSON Object, and that it has a single property with expected root name. If not, a `JsonMappingException` is thrown; otherwise value of the wrapped property will be deserialized as if it was the root value.

Feature is disabled by default.

#### ACCEPT_EMPTY_STRING_AS_NULL_OBJECT

    public static final DeserializationFeature ACCEPT_EMPTY_STRING_AS_NULL_OBJECT

Feature that can be enabled to allow JSON empty String value (`""`) to be bound as `null` for POJOs and other structured values (`Map`s, `Collection`s). If disabled, standard POJOs can only be bound from JSON `null` or JSON Object (standard meaning that no custom deserializers or constructors are defined; both of which can add support for other kinds of JSON values); if enabled, empty JSON String can be taken to be equivalent of JSON null.

NOTE: this does NOT apply to scalar values such as Strings, booleans, numbers and date/time types; whether these can be coerced depends on `MapperFeature.ALLOW_COERCION_OF_SCALARS`.

Feature is disabled by default.

#### ACCEPT_EMPTY_ARRAY_AS_NULL_OBJECT

    public static final DeserializationFeature ACCEPT_EMPTY_ARRAY_AS_NULL_OBJECT

Feature that can be enabled to allow empty JSON Array value (that is, to be bound to POJOs (and with 2.9, other values too) as `null`. If disabled, standard POJOs can only be bound from JSON `null` or JSON Object (standard meaning that no custom deserializers or constructors are defined; both of which can add support for other kinds of JSON values); if enabled, empty JSON Array will be taken to be equivalent of JSON `null`.

Feature is disabled by default.

Since:
  2.5

#### ACCEPT_FLOAT_AS_INT

    public static final DeserializationFeature ACCEPT_FLOAT_AS_INT

Feature that determines whether coercion from JSON floating point number (anything with command (`.`) or exponent portion (`e` / `E')) to an expected integral number (`int`, `long`, `java.lang.Integer`, `java.lang.Long`, `java.math.BigDecimal`) is allowed or not. If enabled, coercion truncates value; if disabled, a `JsonMappingException` will be thrown.

Feature is enabled by default.

Since:
  2.6

#### READ_ENUMS_USING_TO_STRING

    public static final DeserializationFeature READ_ENUMS_USING_TO_STRING

Feature that determines standard deserialization mechanism used for Enum values: if enabled, Enums are assumed to have been serialized using return value of `Enum.toString()`; if disabled, return value of `Enum.name()` is assumed to have been used.

Note: this feature should usually have same value as `SerializationFeature.WRITE_ENUMS_USING_TO_STRING`.

Feature is disabled by default.

#### READ_UNKNOWN_ENUM_VALUES_AS_NULL

    public static final DeserializationFeature READ_UNKNOWN_ENUM_VALUES_AS_NULL

Feature that allows unknown Enum values to be parsed as `null` values. If disabled, unknown Enum values will throw exceptions.

Note that in some cases this will effectively ignore unknown `Enum` values, e.g. when the unknown values are used as keys of `EnumMap` or values of `EnumSet`: this is because these data structures cannot store `null` values.

Also note that this feature has lower precedence than `READ_UNKNOWN_ENUM_VALUES_USING_DEFAULT_VALUE`, meaning this feature will work only if latter feature is disabled.

Feature is disabled by default.

Since:
  2.0

#### READ_UNKNOWN_ENUM_VALUES_USING_DEFAULT_VALUE

    public static final DeserializationFeature READ_UNKNOWN_ENUM_VALUES_USING_DEFAULT_VALUE

Feature that allows unknown Enum values to be ignored and replaced by a predefined value specified through `@JsonEnumDefaultValue` annotation. If disabled, unknown Enum values will throw exceptions. If enabled, but no predefined default Enum value is specified, an exception will be thrown as well.

Note that this feature has higher precedence than `READ_UNKNOWN_ENUM_VALUES_AS_NULL`.

Feature is disabled by default.

Since:
  2.8

#### READ_DATE_TIMESTAMPS_AS_NANOSECONDS

    public static final DeserializationFeature READ_DATE_TIMESTAMPS_AS_NANOSECONDS

Feature that controls whether numeric timestamp values are expected to be written using nanosecond timestamps (enabled) or not (disabled), if and only if datatype supports such resolution. Only newer datatypes (such as Java8 Date/Time) support such resolution -- older types (pre-Java8 java.util.Date etc) and Joda do not -- and this setting has no effect on such types.

If disabled, standard millisecond timestamps are assumed. This is the counterpart to `SerializationFeature.WRITE_DATE_TIMESTAMPS_AS_NANOSECONDS`.

Feature is enabled by default, to support most accurate time values possible.

Since:
  2.2

#### ADJUST_DATES_TO_CONTEXT_TIME_ZONE

    public static final DeserializationFeature ADJUST_DATES_TO_CONTEXT_TIME_ZONE

Feature that specifies whether context provided `TimeZone` (`DeserializationContext.getTimeZone()` should be used to adjust Date/Time values on deserialization, even if value itself contains timezone information. If enabled, contextual `TimeZone` will essentially override any other TimeZone information; if disabled, it will only be used if value itself does not contain any TimeZone information.

Note that exact behavior depends on date/time types in question; and specifically JDK type of `Date` does NOT have in-built timezone information so this setting has no effect. Further, while `Calendar` does have this information basic JDK `SimpleDateFormat` is unable to retain parsed zone information, and as a result, `Calendar` will always get context timezone adjustment regardless of this setting.

Taking above into account, this feature is supported only by extension modules for Joda and Java 8 date/time datatypes.

Since:
  2.2

#### EAGER_DESERIALIZER_FETCH

    public static final DeserializationFeature EAGER_DESERIALIZER_FETCH

Feature that determines whether `ObjectReader` should try to eagerly fetch necessary `JsonDeserializer` when possible. This improves performance in cases where similarly configured `ObjectReader` instance is used multiple times; and should not significantly affect single-use cases.

Note that there should not be any need to normally disable this feature: only consider that if there are actual perceived problems.

Feature is enabled by default.

Since:
  2.1

### Method Detail

#### values

    public static DeserializationFeature[] values()

Returns an array containing the constants of this enum type, in the order they are declared. This method may be used to iterate over the constants as follows:

    for (DeserializationFeature c : DeserializationFeature.values())
        System.out.println(c);

Returns:
  an array containing the constants of this enum type, in the order they are declared

#### valueOf

    public static DeserializationFeature valueOf(String name)

Returns the enum constant of this type with the specified name. The string must match exactly an identifier used to declare an enum constant in this type. (Extraneous whitespace characters are not permitted.)

Parameters:
  `name` - the name of the enum constant to be returned.
Returns:
  the enum constant with the specified name
Throws:
  `IllegalArgumentException` - if this enum type has no constant with the specified name
  `NullPointerException` - if the argument is null

#### enabledByDefault

    public boolean enabledByDefault()

Description copied from interface: `ConfigFeature`
Accessor for checking whether this feature is enabled by default.

Specified by:
  `enabledByDefault` in interface `ConfigFeature`

#### getMask

    public int getMask()

Description copied from interface: `ConfigFeature`
Returns bit mask for this feature instance

Specified by:
  `getMask` in interface `ConfigFeature`

#### enabledIn

    public boolean enabledIn(int flags)

Description copied from interface: `ConfigFeature`
Convenience method for checking whether feature is enabled in given bitmask

Specified by:
  `enabledIn` in interface `ConfigFeature`