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

org.codehaus.jackson.map

## Class ObjectMapper

- java.lang.Object
- - org.codehaus.jackson.ObjectCodec
  - - org.codehaus.jackson.map.ObjectMapper

- All Implemented Interfaces:
    Versioned

      public class ObjectMapper
      extends ObjectCodec
      implements Versioned

  This mapper (or, data binder, or codec) provides functionality for converting between Java objects (instances of JDK provided core classes, beans), and matching JSON constructs. It will use instances of `JsonParser` and `JsonGenerator` for implementing actual reading/writing of JSON.

  The main conversion API is defined in `ObjectCodec`, so that implementation details of this class need not be exposed to streaming parser and generator classes.

  Note on caching: root-level deserializers are always cached, and accessed using full (generics-aware) type information. This is different from caching of referenced types, which is more limited and is done only for a subset of all deserializer types. The main reason for difference is that at root-level there is no incoming reference (and hence no referencing property, no referral information or annotations to produce differing deserializers), and that the performance impact greatest at root level (since it'll essentially cache the full graph of deserializers involved).

- - ### Nested Class Summary

    Nested Classes
    Modifier and Type | Class and Description
    --- | ---
    `static class` | `ObjectMapper.DefaultTypeResolverBuilder` Customized `TypeResolverBuilder` that provides type resolver builders used with so-called "default typing" (see `enableDefaultTyping()` for details).
    `static class` | `ObjectMapper.DefaultTyping` Enumeration used with `enableDefaultTyping()` to specify what kind of types (classes) default typing should be used for.

  - ### Field Summary

    Fields
    Modifier and Type | Field and Description
    --- | ---
    `protected DeserializationConfig` | `_deserializationConfig` Configuration object that defines basic global settings for the serialization process
    `protected DeserializerProvider` | `_deserializerProvider` Object that manages access to deserializers used for deserializing JSON content into Java objects, including possible caching of the deserializers.
    `protected InjectableValues` | `_injectableValues` Provider for values to inject in deserialized POJOs.
    `protected JsonFactory` | `_jsonFactory` Factory used to create `JsonParser` and `JsonGenerator` instances as necessary.
    `protected ConcurrentHashMap<JavaType,JsonDeserializer<Object>>` | `_rootDeserializers` We will use a separate main-level Map for keeping track of root-level deserializers.
    `protected SerializationConfig` | `_serializationConfig` Configuration object that defines basic global settings for the serialization process
    `protected SerializerFactory` | `_serializerFactory` Serializer factory used for constructing serializers.
    `protected SerializerProvider` | `_serializerProvider` Object that manages access to serializers used for serialization, including caching.
    `protected SubtypeResolver` | `_subtypeResolver` Registered concrete subtypes that can be used instead of (or in addition to) ones declared using annotations.
    `protected TypeFactory` | `_typeFactory` Specific factory used for creating `JavaType` instances; needed to allow modules to add more custom type handling (mostly to support types of non-Java JVM languages)
    `protected static AnnotationIntrospector` | `DEFAULT_ANNOTATION_INTROSPECTOR`
    `protected static ClassIntrospector<? extends BeanDescription>` | `DEFAULT_INTROSPECTOR`
    `protected static VisibilityChecker<?>` | `STD_VISIBILITY_CHECKER`

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `ObjectMapper()` Default constructor, which will construct the default `JsonFactory` as necessary, use `StdSerializerProvider` as its `SerializerProvider`, and `BeanSerializerFactory` as its `SerializerFactory`.
    `ObjectMapper(JsonFactory jf)` Construct mapper that uses specified `JsonFactory` for constructing necessary `JsonParser`s and/or `JsonGenerator`s.
    `ObjectMapper(JsonFactory jf, SerializerProvider sp, DeserializerProvider dp)`
    `ObjectMapper(JsonFactory jf, SerializerProvider sp, DeserializerProvider dp, SerializationConfig sconfig, DeserializationConfig dconfig)`
    `ObjectMapper(SerializerFactory sf)` Deprecated. Use other constructors instead; note that you can just set serializer factory with `setSerializerFactory(org.codehaus.jackson.map.SerializerFactory)`

  - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `protected void` | `_configAndWriteValue(JsonGenerator jgen, Object value)` Method called to configure the generator as necessary and then call write functionality
    `protected void` | `_configAndWriteValue(JsonGenerator jgen, Object value, Class<?> viewClass)`
    `protected Object` | `_convert(Object fromValue, JavaType toValueType)`
    `protected DeserializationContext` | `_createDeserializationContext(JsonParser jp, DeserializationConfig cfg)`
    `protected PrettyPrinter` | `_defaultPrettyPrinter()` Helper method that should return default pretty-printer to use for generators constructed by this mapper, when instructed to use default pretty printer.
    `protected JsonDeserializer<Object>` | `_findRootDeserializer(DeserializationConfig cfg, JavaType valueType)` Method called to locate deserializer for the passed root-level value.
    `protected JsonToken` | `_initForReading(JsonParser jp)` Method called to ensure that given parser is ready for reading content for data binding.
    `protected Object` | `_readMapAndClose(JsonParser jp, JavaType valueType)`
    `protected Object` | `_readValue(DeserializationConfig cfg, JsonParser jp, JavaType valueType)` Actual implementation of value reading+binding operation.
    `protected Object` | `_unwrapAndDeserialize(JsonParser jp, JavaType rootType, DeserializationContext ctxt, JsonDeserializer<Object> deser)`
    `boolean` | `canDeserialize(JavaType type)` Method that can be called to check whether mapper thinks it could deserialize an Object of given type.
    `boolean` | `canSerialize(Class<?> type)` Method that can be called to check whether mapper thinks it could serialize an instance of given Class.
    `ObjectMapper` | `configure(DeserializationConfig.Feature f, boolean state)` Method for changing state of an on/off deserialization feature for this object mapper.
    `ObjectMapper` | `configure(JsonGenerator.Feature f, boolean state)` Method for changing state of an on/off `JsonGenerator` feature for `JsonFactory` instance this object mapper uses.
    `ObjectMapper` | `configure(JsonParser.Feature f, boolean state)` Method for changing state of an on/off `JsonParser` feature for `JsonFactory` instance this object mapper uses.
    `ObjectMapper` | `configure(SerializationConfig.Feature f, boolean state)` Method for changing state of an on/off serialization feature for this object mapper.
    `JavaType` | `constructType(Type t)` Convenience method for constructing `JavaType` out of given type (typically `java.lang.Class`), but without explicit context.
    `<T> T` | `convertValue(Object fromValue, Class<T> toValueType)` Convenience method for doing two-step conversion from given value, into instance of given value type.
    `<T> T` | `convertValue(Object fromValue, JavaType toValueType)`
    `<T> T` | `convertValue(Object fromValue, TypeReference toValueTypeRef)`
    `DeserializationConfig` | `copyDeserializationConfig()` Method that creates a copy of the shared default `DeserializationConfig` object that defines configuration settings for deserialization.
    `SerializationConfig` | `copySerializationConfig()` Method that creates a copy of the shared default `SerializationConfig` object that defines configuration settings for serialization.
    `ArrayNode` | `createArrayNode()` Note: return type is co-variant, as basic ObjectCodec abstraction can not refer to concrete node types (as it's part of core package, whereas impls are part of mapper package)
    `ObjectNode` | `createObjectNode()` Note: return type is co-variant, as basic ObjectCodec abstraction can not refer to concrete node types (as it's part of core package, whereas impls are part of mapper package)
    `ObjectWriter` | `defaultPrettyPrintingWriter()` Deprecated. Since 1.9, use `writerWithDefaultPrettyPrinter()` instead.
    `ObjectMapper` | `disable(DeserializationConfig.Feature... f)` Method for enabling specified `DeserializationConfig` features.
    `ObjectMapper` | `disable(SerializationConfig.Feature... f)` Method for enabling specified `DeserializationConfig` features.
    `ObjectMapper` | `disableDefaultTyping()` Method for disabling automatic inclusion of type information; if so, only explicitly annotated types (ones with `JsonTypeInfo`) will have additional embedded type information.
    `ObjectMapper` | `enable(DeserializationConfig.Feature... f)` Method for enabling specified `DeserializationConfig` features.
    `ObjectMapper` | `enable(SerializationConfig.Feature... f)` Method for enabling specified `DeserializationConfig` features.
    `ObjectMapper` | `enableDefaultTyping()` Convenience method that is equivalent to calling
    `ObjectMapper` | `enableDefaultTyping(ObjectMapper.DefaultTyping dti)` Convenience method that is equivalent to calling
    `ObjectMapper` | `enableDefaultTyping(ObjectMapper.DefaultTyping applicability, JsonTypeInfo.As includeAs)` Method for enabling automatic inclusion of type information, needed for proper deserialization of polymorphic types (unless types have been annotated with `JsonTypeInfo`).
    `ObjectMapper` | `enableDefaultTypingAsProperty(ObjectMapper.DefaultTyping applicability, String propertyName)` Method for enabling automatic inclusion of type information -- needed for proper deserialization of polymorphic types (unless types have been annotated with `JsonTypeInfo`) -- using "As.PROPERTY" inclusion mechanism and specified property name to use for inclusion (default being "@class" since default type information always uses class name as type identifier)
    `ObjectWriter` | `filteredWriter(FilterProvider filterProvider)` Deprecated. Since 1.9, use `writer(FilterProvider)` instead.
    `JsonSchema` | `generateJsonSchema(Class<?> t)` Generate Json-schema instance for specified class.
    `JsonSchema` | `generateJsonSchema(Class<?> t, SerializationConfig cfg)` Generate Json-schema instance for specified class, using specific serialization configuration
    `DeserializationConfig` | `getDeserializationConfig()` Method that returns the shared default `DeserializationConfig` object that defines configuration settings for deserialization.
    `DeserializerProvider` | `getDeserializerProvider()`
    `JsonFactory` | `getJsonFactory()` Method that can be used to get hold of `JsonFactory` that this mapper uses if it needs to construct `JsonParser`s and/or `JsonGenerator`s.
    `JsonNodeFactory` | `getNodeFactory()` Method that can be used to get hold of `JsonNodeFactory` that this mapper will use when directly constructing root `JsonNode` instances for Trees.
    `SerializationConfig` | `getSerializationConfig()` Method that returns the shared default `SerializationConfig` object that defines configuration settings for serialization.
    `SerializerProvider` | `getSerializerProvider()`
    `SubtypeResolver` | `getSubtypeResolver()` Method for accessing subtype resolver in use.
    `TypeFactory` | `getTypeFactory()` Accessor for getting currently configured `TypeFactory` instance.
    `VisibilityChecker<?>` | `getVisibilityChecker()` Method for accessing currently configured visibility checker; object used for determining whether given property element (method, field, constructor) can be auto-detected or not.
    `boolean` | `isEnabled(DeserializationConfig.Feature f)` Convenience method, equivalent to:
    `boolean` | `isEnabled(JsonGenerator.Feature f)` Convenience method, equivalent to:
    `boolean` | `isEnabled(JsonParser.Feature f)` Convenience method, equivalent to:
    `boolean` | `isEnabled(SerializationConfig.Feature f)` Convenience method, equivalent to:
    `ObjectWriter` | `prettyPrintingWriter(PrettyPrinter pp)` Deprecated. Since 1.9, use `writer(FilterProvider)` instead.
    `ObjectReader` | `reader()` Factory method for constructing `ObjectReader` with default settings.
    `ObjectReader` | `reader(Class<?> type)` Factory method for constructing `ObjectReader` that will read or update instances of specified type
    `ObjectReader` | `reader(FormatSchema schema)` Factory method for constructing `ObjectReader` that will pass specific schema object to `JsonParser` used for reading content.
    `ObjectReader` | `reader(InjectableValues injectableValues)` Factory method for constructing `ObjectReader` that will use specified injectable values.
    `ObjectReader` | `reader(JavaType type)` Factory method for constructing `ObjectReader` that will read or update instances of specified type
    `ObjectReader` | `reader(JsonNodeFactory f)` Factory method for constructing `ObjectReader` that will use specified `JsonNodeFactory` for constructing JSON trees.
    `ObjectReader` | `reader(TypeReference<?> type)` Factory method for constructing `ObjectReader` that will read or update instances of specified type
    `ObjectReader` | `readerForUpdating(Object valueToUpdate)` Factory method for constructing `ObjectReader` that will update given Object (usually Bean, but can be a Collection or Map as well, but NOT an array) with JSON data.
    `JsonNode` | `readTree(byte[] content)` Method to deserialize JSON content as tree expressed using set of `JsonNode` instances.
    `JsonNode` | `readTree(File file)` Method to deserialize JSON content as tree expressed using set of `JsonNode` instances.
    `JsonNode` | `readTree(InputStream in)` Method to deserialize JSON content as tree expressed using set of `JsonNode` instances.
    `JsonNode` | `readTree(JsonParser jp)` Method to deserialize JSON content as tree expressed using set of `JsonNode` instances.
    `JsonNode` | `readTree(JsonParser jp, DeserializationConfig cfg)` Method to deserialize JSON content as tree expressed using set of `JsonNode` instances.
    `JsonNode` | `readTree(Reader r)` Method to deserialize JSON content as tree expressed using set of `JsonNode` instances.
    `JsonNode` | `readTree(String content)` Method to deserialize JSON content as tree expressed using set of `JsonNode` instances.
    `JsonNode` | `readTree(URL source)` Method to deserialize JSON content as tree expressed using set of `JsonNode` instances.
    `<T> T` | `readValue(byte[] src, Class<T> valueType)`
    `<T> T` | `readValue(byte[] src, int offset, int len, Class<T> valueType)`
    `<T> T` | `readValue(byte[] src, int offset, int len, JavaType valueType)`
    `<T> T` | `readValue(byte[] src, int offset, int len, TypeReference valueTypeRef)`
    `<T> T` | `readValue(byte[] src, JavaType valueType)`
    `<T> T` | `readValue(byte[] src, TypeReference valueTypeRef)`
    `<T> T` | `readValue(File src, Class<T> valueType)`
    `<T> T` | `readValue(File src, JavaType valueType)`
    `<T> T` | `readValue(File src, TypeReference valueTypeRef)`
    `<T> T` | `readValue(InputStream src, Class<T> valueType)`
    `<T> T` | `readValue(InputStream src, JavaType valueType)`
    `<T> T` | `readValue(InputStream src, TypeReference valueTypeRef)`
    `<T> T` | `readValue(JsonNode root, Class<T> valueType)` Convenience method for converting results from given JSON tree into given value type.
    `<T> T` | `readValue(JsonNode root, JavaType valueType)` Convenience method for converting results from given JSON tree into given value type.
    `<T> T` | `readValue(JsonNode root, TypeReference valueTypeRef)` Convenience method for converting results from given JSON tree into given value type.
    `<T> T` | `readValue(JsonParser jp, Class<T> valueType)` Method to deserialize JSON content into a non-container type (it can be an array type, however): typically a bean, array or a wrapper type (like `Boolean`).
    `<T> T` | `readValue(JsonParser jp, Class<T> valueType, DeserializationConfig cfg)` Method to deserialize JSON content into a non-container type (it can be an array type, however): typically a bean, array or a wrapper type (like `Boolean`).
    `<T> T` | `readValue(JsonParser jp, JavaType valueType)` Method to deserialize JSON content into a Java type, reference to which is passed as argument.
    `<T> T` | `readValue(JsonParser jp, JavaType valueType, DeserializationConfig cfg)` Method to deserialize JSON content into a Java type, reference to which is passed as argument.
    `<T> T` | `readValue(JsonParser jp, TypeReference<?> valueTypeRef)` Method to deserialize JSON content into a Java type, reference to which is passed as argument.
    `<T> T` | `readValue(JsonParser jp, TypeReference<?> valueTypeRef, DeserializationConfig cfg)` Method to deserialize JSON content into a Java type, reference to which is passed as argument.
    `<T> T` | `readValue(Reader src, Class<T> valueType)`
    `<T> T` | `readValue(Reader src, JavaType valueType)`
    `<T> T` | `readValue(Reader src, TypeReference valueTypeRef)`
    `<T> T` | `readValue(String content, Class<T> valueType)`
    `<T> T` | `readValue(String content, JavaType valueType)`
    `<T> T` | `readValue(String content, TypeReference valueTypeRef)`
    `<T> T` | `readValue(URL src, Class<T> valueType)`
    `<T> T` | `readValue(URL src, JavaType valueType)`
    `<T> T` | `readValue(URL src, TypeReference valueTypeRef)`
    `<T> MappingIterator<T>` | `readValues(JsonParser jp, Class<T> valueType)` Method for reading sequence of Objects from parser stream.
    `<T> MappingIterator<T>` | `readValues(JsonParser jp, JavaType valueType)` Method for reading sequence of Objects from parser stream.
    `<T> MappingIterator<T>` | `readValues(JsonParser jp, TypeReference<?> valueTypeRef)` Method for reading sequence of Objects from parser stream.
    `void` | `registerModule(Module module)` Method for registering a module that can extend functionality provided by this mapper; for example, by adding providers for custom serializers and deserializers.
    `void` | `registerSubtypes(Class<?>... classes)` Method for registering specified class as a subtype, so that typename-based resolution can link supertypes to subtypes (as an alternative to using annotations).
    `void` | `registerSubtypes(NamedType... types)` Method for registering specified class as a subtype, so that typename-based resolution can link supertypes to subtypes (as an alternative to using annotations).
    `ObjectReader` | `schemaBasedReader(FormatSchema schema)` Deprecated. Since 1.9, use `reader(FormatSchema)` instead.
    `ObjectWriter` | `schemaBasedWriter(FormatSchema schema)` Deprecated. Since 1.9, use `writer(FilterProvider)` instead.
    `ObjectMapper` | `setAnnotationIntrospector(AnnotationIntrospector ai)` Method for changing `AnnotationIntrospector` used by this mapper instance for both serialization and deserialization
    `void` | `setDateFormat(DateFormat dateFormat)` Method for configuring the default `DateFormat` to use when serializing time values as Strings, and deserializing from JSON Strings.
    `ObjectMapper` | `setDefaultTyping(TypeResolverBuilder<?> typer)` Method for enabling automatic inclusion of type information, using specified handler object for determining which types this affects, as well as details of how information is embedded.
    `ObjectMapper` | `setDeserializationConfig(DeserializationConfig cfg)` Method for replacing the shared default deserialization configuration object.
    `ObjectMapper` | `setDeserializerProvider(DeserializerProvider p)` Method for setting specific `DeserializerProvider` to use for handling caching of `JsonDeserializer` instances.
    `void` | `setFilters(FilterProvider filterProvider)` Convenience method that is equivalent to:
    `void` | `setHandlerInstantiator(HandlerInstantiator hi)` Method for configuring `HandlerInstantiator` to use for creating instances of handlers (such as serializers, deserializers, type and type id resolvers), given a class.
    `ObjectMapper` | `setInjectableValues(InjectableValues injectableValues)`
    `ObjectMapper` | `setNodeFactory(JsonNodeFactory f)` Method for specifying `JsonNodeFactory` to use for constructing root level tree nodes (via method `createObjectNode()`
    `ObjectMapper` | `setPropertyNamingStrategy(PropertyNamingStrategy s)` Method for setting custom property naming strategy to use.
    `ObjectMapper` | `setSerializationConfig(SerializationConfig cfg)` Method for replacing the shared default serialization configuration object.
    `ObjectMapper` | `setSerializationInclusion(JsonSerialize.Inclusion incl)` Method for setting defalt POJO property inclusion strategy for serialization.
    `ObjectMapper` | `setSerializerFactory(SerializerFactory f)` Method for setting specific `SerializerFactory` to use for constructing (bean) serializers.
    `ObjectMapper` | `setSerializerProvider(SerializerProvider p)` Method for setting specific `SerializerProvider` to use for handling caching of `JsonSerializer` instances.
    `void` | `setSubtypeResolver(SubtypeResolver r)` Method for setting custom subtype resolver to use.
    `ObjectMapper` | `setTypeFactory(TypeFactory f)` Method that can be used to override `TypeFactory` instance used by this mapper.
    `ObjectMapper` | `setVisibility(JsonMethod forMethod, JsonAutoDetect.Visibility visibility)` Convenience method that allows changing configuration for underlying `VisibilityChecker`s, to change details of what kinds of properties are auto-detected.
    `void` | `setVisibilityChecker(VisibilityChecker<?> vc)` Method for setting currently configured visibility checker; object used for determining whether given property element (method, field, constructor) can be auto-detected or not.
    `JsonParser` | `treeAsTokens(JsonNode n)` Method for constructing a `JsonParser` out of JSON tree representation.
    `<T> T` | `treeToValue(JsonNode n, Class<T> valueType)` Convenience conversion method that will bind data given JSON tree contains into specific value (usually bean) type.
    `ObjectWriter` | `typedWriter(Class<?> rootType)` Deprecated. Since 1.9, use `writerWithType(Class)` instead.
    `ObjectWriter` | `typedWriter(JavaType rootType)` Deprecated. Since 1.9, use `writerWithType(JavaType)` instead.
    `ObjectWriter` | `typedWriter(TypeReference<?> rootType)` Deprecated. Since 1.9, use `writerWithType(TypeReference)` instead.
    `ObjectReader` | `updatingReader(Object valueToUpdate)` Deprecated. Since 1.9, use `readerForUpdating(java.lang.Object)` instead.
    `<T extends JsonNode> T` | `valueToTree(Object fromValue)` Reverse of `treeToValue(org.codehaus.jackson.JsonNode, java.lang.Class<T>)`; given a value (usually bean), will construct equivalent JSON Tree representation.
    `Version` | `version()` Method that will return version information stored in and read from jar that contains this class.
    `ObjectWriter` | `viewWriter(Class<?> serializationView)` Deprecated. Since 1.9, use `writerWithView(Class)` instead.
    `ObjectMapper` | `withModule(Module module)` Fluent-style alternative to `registerModule(org.codehaus.jackson.map.Module)`; functionally equivalent to:
    `ObjectWriter` | `writer()` Convenience method for constructing `ObjectWriter` with default settings.
    `ObjectWriter` | `writer(DateFormat df)` Factory method for constructing `ObjectWriter` that will serialize objects using specified `DateFormat`; or, if null passed, using timestamp (64-bit number.
    `ObjectWriter` | `writer(FilterProvider filterProvider)` Factory method for constructing `ObjectWriter` that will serialize objects using specified filter provider.
    `ObjectWriter` | `writer(FormatSchema schema)` Factory method for constructing `ObjectWriter` that will pass specific schema object to `JsonGenerator` used for writing content.
    `ObjectWriter` | `writer(PrettyPrinter pp)` Factory method for constructing `ObjectWriter` that will serialize objects using specified pretty printer for indentation (or if null, no pretty printer)
    `ObjectWriter` | `writerWithDefaultPrettyPrinter()` Factory method for constructing `ObjectWriter` that will serialize objects using the default pretty printer for indentation
    `ObjectWriter` | `writerWithType(Class<?> rootType)` Factory method for constructing `ObjectWriter` that will serialize objects using specified root type, instead of actual runtime type of value.
    `ObjectWriter` | `writerWithType(JavaType rootType)` Factory method for constructing `ObjectWriter` that will serialize objects using specified root type, instead of actual runtime type of value.
    `ObjectWriter` | `writerWithType(TypeReference<?> rootType)` Factory method for constructing `ObjectWriter` that will serialize objects using specified root type, instead of actual runtime type of value.
    `ObjectWriter` | `writerWithView(Class<?> serializationView)` Factory method for constructing `ObjectWriter` that will serialize objects using specified JSON View (filter).
    `void` | `writeTree(JsonGenerator jgen, JsonNode rootNode)` Method to serialize given JSON Tree, using generator provided.
    `void` | `writeTree(JsonGenerator jgen, JsonNode rootNode, SerializationConfig cfg)` Method to serialize given Json Tree, using generator provided.
    `void` | `writeValue(File resultFile, Object value)` Method that can be used to serialize any Java value as JSON output, written to File provided.
    `void` | `writeValue(JsonGenerator jgen, Object value)` Method that can be used to serialize any Java value as JSON output, using provided `JsonGenerator`.
    `void` | `writeValue(JsonGenerator jgen, Object value, SerializationConfig config)` Method that can be used to serialize any Java value as JSON output, using provided `JsonGenerator`, configured as per passed configuration object.
    `void` | `writeValue(OutputStream out, Object value)` Method that can be used to serialize any Java value as JSON output, using output stream provided (using encoding `JsonEncoding.UTF8`).
    `void` | `writeValue(Writer w, Object value)` Method that can be used to serialize any Java value as JSON output, using Writer provided.
    `byte[]` | `writeValueAsBytes(Object value)` Method that can be used to serialize any Java value as a byte array.
    `String` | `writeValueAsString(Object value)` Method that can be used to serialize any Java value as a String.

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

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

- - ### Field Detail

    - #### DEFAULT_INTROSPECTOR

          protected static final ClassIntrospector<? extends BeanDescription> DEFAULT_INTROSPECTOR

    - #### DEFAULT_ANNOTATION_INTROSPECTOR

          protected static final AnnotationIntrospector DEFAULT_ANNOTATION_INTROSPECTOR

    - #### STD_VISIBILITY_CHECKER

          protected static final VisibilityChecker<?> STD_VISIBILITY_CHECKER

      Since:
        1.5

    - #### _jsonFactory

          protected final JsonFactory _jsonFactory

      Factory used to create `JsonParser` and `JsonGenerator` instances as necessary.

    - #### _subtypeResolver

          protected SubtypeResolver _subtypeResolver

      Registered concrete subtypes that can be used instead of (or in addition to) ones declared using annotations.
      Since:
        1.6

    - #### _typeFactory

          protected TypeFactory _typeFactory

      Specific factory used for creating `JavaType` instances; needed to allow modules to add more custom type handling (mostly to support types of non-Java JVM languages)

    - #### _injectableValues

          protected InjectableValues _injectableValues

      Provider for values to inject in deserialized POJOs.
      Since:
        1.9

    - #### _serializationConfig

          protected SerializationConfig _serializationConfig

      Configuration object that defines basic global settings for the serialization process

    - #### _serializerProvider

          protected SerializerProvider _serializerProvider

      Object that manages access to serializers used for serialization, including caching. It is configured with `_serializerFactory` to allow for constructing custom serializers.

    - #### _serializerFactory

          protected SerializerFactory _serializerFactory

      Serializer factory used for constructing serializers.

    - #### _deserializationConfig

          protected DeserializationConfig _deserializationConfig

      Configuration object that defines basic global settings for the serialization process

    - #### _deserializerProvider

          protected DeserializerProvider _deserializerProvider

      Object that manages access to deserializers used for deserializing JSON content into Java objects, including possible caching of the deserializers. It contains a reference to `DeserializerFactory` to use for constructing acutal deserializers.

    - #### _rootDeserializers

          protected final ConcurrentHashMap<JavaType,JsonDeserializer<Object>> _rootDeserializers

      We will use a separate main-level Map for keeping track of root-level deserializers. This is where most succesful cache lookups get resolved. Map will contain resolvers for all kinds of types, including container types: this is different from the component cache which will only cache bean deserializers.

      Given that we don't expect much concurrency for additions (should very quickly converge to zero after startup), let's explicitly define a low concurrency setting.

      Since version 1.5, these may are either "raw" deserializers (when no type information is needed for base type), or type-wrapped deserializers (if it is needed)

  - ### Constructor Detail

    - #### ObjectMapper

          public ObjectMapper()

      Default constructor, which will construct the default `JsonFactory` as necessary, use `StdSerializerProvider` as its `SerializerProvider`, and `BeanSerializerFactory` as its `SerializerFactory`. This means that it can serialize all standard JDK types, as well as regular Java Beans (based on method names and Jackson-specific annotations), but does not support JAXB annotations.

    - #### ObjectMapper

          public ObjectMapper(JsonFactory jf)

      Construct mapper that uses specified `JsonFactory` for constructing necessary `JsonParser`s and/or `JsonGenerator`s.

    - #### ObjectMapper

          @Deprecated
          public ObjectMapper(SerializerFactory sf)

      Deprecated. Use other constructors instead; note that you can just set serializer factory with `setSerializerFactory(org.codehaus.jackson.map.SerializerFactory)`
      Construct mapper that uses specified `SerializerFactory` for constructing necessary serializers.

    - #### ObjectMapper

          public ObjectMapper(JsonFactory jf,
                      SerializerProvider sp,
                      DeserializerProvider dp)

    - #### ObjectMapper

          public ObjectMapper(JsonFactory jf,
                      SerializerProvider sp,
                      DeserializerProvider dp,
                      SerializationConfig sconfig,
                      DeserializationConfig dconfig)

      Parameters:
        `jf` - JsonFactory to use: if null, a new `MappingJsonFactory` will be constructed
        `sp` - SerializerProvider to use: if null, a `StdSerializerProvider` will be constructed
        `dp` - DeserializerProvider to use: if null, a `StdDeserializerProvider` will be constructed
        `sconfig` - Serialization configuration to use; if null, basic `SerializationConfig` will be constructed
        `dconfig` - Deserialization configuration to use; if null, basic `DeserializationConfig` will be constructed

  - ### Method Detail

    - #### version

          public Version version()

      Method that will return version information stored in and read from jar that contains this class.
      Specified by:
        `version` in interface `Versioned`
      Since:
        1.6

    - #### registerModule

          public void registerModule(Module module)

      Method for registering a module that can extend functionality provided by this mapper; for example, by adding providers for custom serializers and deserializers.
      Parameters:
        `module` - Module to register
      Since:
        1.7

    - #### withModule

          public ObjectMapper withModule(Module module)

      Fluent-style alternative to `registerModule(org.codehaus.jackson.map.Module)`; functionally equivalent to:

            mapper.registerModule(module);
            return mapper;

      NOTE: name is unfortunately misleading in suggesting that a new instance might be created (as is the case with most other 'withXxx()' methods for Jackson core objects) -- this is not the case; rather, this is just a variant of `registerModule(org.codehaus.jackson.map.Module)` but one that returns 'this' (like it should return, but does not for historical reasons).
      Since:
        1.8

    - #### getSerializationConfig

          public SerializationConfig getSerializationConfig()

      Method that returns the shared default `SerializationConfig` object that defines configuration settings for serialization. Returned object is "live" meaning that changes will be used for future serialization operations for this mapper when using mapper's default configuration

    - #### copySerializationConfig

          public SerializationConfig copySerializationConfig()

      Method that creates a copy of the shared default `SerializationConfig` object that defines configuration settings for serialization. Since it is a copy, any changes made to the configuration object will NOT directly affect serialization done using basic serialization methods that use the shared object (that is, ones that do not take separate `SerializationConfig` argument.

      The use case is that of changing object settings of the configuration (like date format being used, see `SerializationConfig.setDateFormat(java.text.DateFormat)`).

    - #### setSerializationConfig

          public ObjectMapper setSerializationConfig(SerializationConfig cfg)

      Method for replacing the shared default serialization configuration object.

    - #### getDeserializationConfig

          public DeserializationConfig getDeserializationConfig()

      Method that returns the shared default `DeserializationConfig` object that defines configuration settings for deserialization. Returned object is "live" meaning that changes will be used for future deserialization operations for this mapper when using mapper's default configuration

    - #### copyDeserializationConfig

          public DeserializationConfig copyDeserializationConfig()

      Method that creates a copy of the shared default `DeserializationConfig` object that defines configuration settings for deserialization. Since it is a copy, any changes made to the configuration object will NOT directly affect deserialization done using basic deserialization methods that use the shared object (that is, ones that do not take separate `DeserializationConfig` argument.

      The use case is that of changing object settings of the configuration (like deserialization problem handler, see `DeserializationConfig.addHandler(org.codehaus.jackson.map.DeserializationProblemHandler)`)

    - #### setDeserializationConfig

          public ObjectMapper setDeserializationConfig(DeserializationConfig cfg)

      Method for replacing the shared default deserialization configuration object.

    - #### setSerializerFactory

          public ObjectMapper setSerializerFactory(SerializerFactory f)

      Method for setting specific `SerializerFactory` to use for constructing (bean) serializers.

    - #### setSerializerProvider

          public ObjectMapper setSerializerProvider(SerializerProvider p)

      Method for setting specific `SerializerProvider` to use for handling caching of `JsonSerializer` instances.

    - #### getSerializerProvider

          public SerializerProvider getSerializerProvider()

      Since:
        1.4

    - #### setDeserializerProvider

          public ObjectMapper setDeserializerProvider(DeserializerProvider p)

      Method for setting specific `DeserializerProvider` to use for handling caching of `JsonDeserializer` instances.

    - #### getDeserializerProvider

          public DeserializerProvider getDeserializerProvider()

      Since:
        1.4

    - #### getVisibilityChecker

          public VisibilityChecker<?> getVisibilityChecker()

      Method for accessing currently configured visibility checker; object used for determining whether given property element (method, field, constructor) can be auto-detected or not.
      Since:
        1.5

    - #### setVisibilityChecker

          public void setVisibilityChecker(VisibilityChecker<?> vc)

      Method for setting currently configured visibility checker; object used for determining whether given property element (method, field, constructor) can be auto-detected or not. This default checker is used if no per-class overrides are defined.
      Since:
        1.5

    - #### setVisibility

          public ObjectMapper setVisibility(JsonMethod forMethod,
                                   JsonAutoDetect.Visibility visibility)

      Convenience method that allows changing configuration for underlying `VisibilityChecker`s, to change details of what kinds of properties are auto-detected. Basically short cut for doing:

            mapper.setVisibilityChecker(
               mapper.getVisibilityChecker().withVisibility(forMethod, visibility)
            );

      one common use case would be to do:

            mapper.setVisibility(JsonMethod.FIELD, Visibility.ANY);

      which would make all member fields serializable without further annotations, instead of just public fields (default setting).
      Parameters:
        `forMethod` - Type of property descriptor affected (field, getter/isGetter, setter, creator)
        `visibility` - Minimum visibility to require for the property descriptors of type
      Returns:
        Modified mapper instance (that is, "this"), to allow chaining of configuration calls
      Since:
        1.9

    - #### getSubtypeResolver

          public SubtypeResolver getSubtypeResolver()

      Method for accessing subtype resolver in use.
      Since:
        1.6

    - #### setSubtypeResolver

          public void setSubtypeResolver(SubtypeResolver r)

      Method for setting custom subtype resolver to use.
      Since:
        1.6

    - #### setAnnotationIntrospector

          public ObjectMapper setAnnotationIntrospector(AnnotationIntrospector ai)

      Method for changing `AnnotationIntrospector` used by this mapper instance for both serialization and deserialization
      Since:
        1.8

    - #### setPropertyNamingStrategy

          public ObjectMapper setPropertyNamingStrategy(PropertyNamingStrategy s)

      Method for setting custom property naming strategy to use.
      Since:
        1.8

    - #### setSerializationInclusion

          public ObjectMapper setSerializationInclusion(JsonSerialize.Inclusion incl)

      Method for setting defalt POJO property inclusion strategy for serialization. Equivalent to:

            mapper.setSerializationConfig(mapper.getSerializationConfig().withSerializationInclusion(incl));

      Since:
        1.9

    - #### enableDefaultTyping

          public ObjectMapper enableDefaultTyping()

      Convenience method that is equivalent to calling

            enableObjectTyping(DefaultTyping.OBJECT_AND_NON_CONCRETE);

    - #### enableDefaultTyping

          public ObjectMapper enableDefaultTyping(ObjectMapper.DefaultTyping dti)

      Convenience method that is equivalent to calling

            enableObjectTyping(dti, JsonTypeInfo.As.WRAPPER_ARRAY);

    - #### enableDefaultTyping

          public ObjectMapper enableDefaultTyping(ObjectMapper.DefaultTyping applicability,
                                         JsonTypeInfo.As includeAs)

      Method for enabling automatic inclusion of type information, needed for proper deserialization of polymorphic types (unless types have been annotated with `JsonTypeInfo`).
      Parameters:
        `applicability` - Defines kinds of types for which additional type information is added; see `ObjectMapper.DefaultTyping` for more information.

    - #### enableDefaultTypingAsProperty

          public ObjectMapper enableDefaultTypingAsProperty(ObjectMapper.DefaultTyping applicability,
                                                   String propertyName)

      Method for enabling automatic inclusion of type information -- needed for proper deserialization of polymorphic types (unless types have been annotated with `JsonTypeInfo`) -- using "As.PROPERTY" inclusion mechanism and specified property name to use for inclusion (default being "@class" since default type information always uses class name as type identifier)
      Since:
        1.7

    - #### disableDefaultTyping

          public ObjectMapper disableDefaultTyping()

      Method for disabling automatic inclusion of type information; if so, only explicitly annotated types (ones with `JsonTypeInfo`) will have additional embedded type information.

    - #### setDefaultTyping

          public ObjectMapper setDefaultTyping(TypeResolverBuilder<?> typer)

      Method for enabling automatic inclusion of type information, using specified handler object for determining which types this affects, as well as details of how information is embedded.
      Parameters:
        `typer` - Type information inclusion handler

    - #### registerSubtypes

          public void registerSubtypes(Class<?>... classes)

      Method for registering specified class as a subtype, so that typename-based resolution can link supertypes to subtypes (as an alternative to using annotations). Type for given class is determined from appropriate annotation; or if missing, default name (unqualified class name)
      Since:
        1.6

    - #### registerSubtypes

          public void registerSubtypes(NamedType... types)

      Method for registering specified class as a subtype, so that typename-based resolution can link supertypes to subtypes (as an alternative to using annotations). Name may be provided as part of argument, but if not will be based on annotations or use default name (unqualified class name).
      Since:
        1.6

    - #### getTypeFactory

          public TypeFactory getTypeFactory()

      Accessor for getting currently configured `TypeFactory` instance.
      Since:
        1.8

    - #### setTypeFactory

          public ObjectMapper setTypeFactory(TypeFactory f)

      Method that can be used to override `TypeFactory` instance used by this mapper.

      Note: will also set `TypeFactory` that deserialization and serialization config objects use.

    - #### constructType

          public JavaType constructType(Type t)

      Convenience method for constructing `JavaType` out of given type (typically `java.lang.Class`), but without explicit context.
      Since:
        1.8

    - #### setNodeFactory

          public ObjectMapper setNodeFactory(JsonNodeFactory f)

      Method for specifying `JsonNodeFactory` to use for constructing root level tree nodes (via method `createObjectNode()`
      Since:
        1.2

    - #### setFilters

          public void setFilters(FilterProvider filterProvider)

      Convenience method that is equivalent to:

            mapper.setFilters(mapper.getSerializationConfig().withFilters(filterProvider));

      Note that usually it is better to use method `filteredWriter(org.codehaus.jackson.map.ser.FilterProvider)`; however, sometimes this method is more convenient. For example, some frameworks only allow configuring of ObjectMapper instances and not ObjectWriters.

      Since:
        1.8

    - #### getJsonFactory

          public JsonFactory getJsonFactory()

      Method that can be used to get hold of `JsonFactory` that this mapper uses if it needs to construct `JsonParser`s and/or `JsonGenerator`s.
      Returns:
        `JsonFactory` that this mapper uses when it needs to construct Json parser and generators

    - #### setDateFormat

          public void setDateFormat(DateFormat dateFormat)

      Method for configuring the default `DateFormat` to use when serializing time values as Strings, and deserializing from JSON Strings. This is preferably to directly modifying `SerializationConfig` and `DeserializationConfig` instances. If you need per-request configuration, use `writer(DateFormat)` to create properly configured `ObjectWriter` and use that; this because `ObjectWriter`s are thread-safe whereas ObjectMapper itself is only thread-safe when configuring methods (such as this one) are NOT called.
      Since:
        1.8

    - #### setHandlerInstantiator

          public void setHandlerInstantiator(HandlerInstantiator hi)

      Method for configuring `HandlerInstantiator` to use for creating instances of handlers (such as serializers, deserializers, type and type id resolvers), given a class.
      Parameters:
        `hi` - Instantiator to use; if null, use the default implementation

    - #### setInjectableValues

          public ObjectMapper setInjectableValues(InjectableValues injectableValues)

      Since:
        1.9

    - #### configure

          public ObjectMapper configure(SerializationConfig.Feature f,
                               boolean state)

      Method for changing state of an on/off serialization feature for this object mapper.

      This is method is basically a shortcut method for calling `SerializationConfig.set(org.codehaus.jackson.map.SerializationConfig.Feature, boolean)` on the shared `SerializationConfig` object with given arguments.

    - #### configure

          public ObjectMapper configure(DeserializationConfig.Feature f,
                               boolean state)

      Method for changing state of an on/off deserialization feature for this object mapper.

      This is method is basically a shortcut method for calling `DeserializationConfig.set(org.codehaus.jackson.map.DeserializationConfig.Feature, boolean)` on the shared `DeserializationConfig` object with given arguments.

    - #### configure

          public ObjectMapper configure(JsonParser.Feature f,
                               boolean state)

      Method for changing state of an on/off `JsonParser` feature for `JsonFactory` instance this object mapper uses.

      This is method is basically a shortcut method for calling `JsonFactory.setParserFeature(org.codehaus.jackson.JsonParser.Feature, boolean)` on the shared `JsonFactory` this mapper uses (which is accessible using `getJsonFactory()`).

      Since:
        1.2

    - #### configure

          public ObjectMapper configure(JsonGenerator.Feature f,
                               boolean state)

      Method for changing state of an on/off `JsonGenerator` feature for `JsonFactory` instance this object mapper uses.

      This is method is basically a shortcut method for calling `JsonFactory.setGeneratorFeature(org.codehaus.jackson.JsonGenerator.Feature, boolean)` on the shared `JsonFactory` this mapper uses (which is accessible using `getJsonFactory()`).

      Since:
        1.2

    - #### enable

          public ObjectMapper enable(DeserializationConfig.Feature... f)

      Method for enabling specified `DeserializationConfig` features. Modifies and returns this instance; no new object is created.
      Since:
        1.9

    - #### disable

          public ObjectMapper disable(DeserializationConfig.Feature... f)

      Method for enabling specified `DeserializationConfig` features. Modifies and returns this instance; no new object is created.
      Since:
        1.9

    - #### enable

          public ObjectMapper enable(SerializationConfig.Feature... f)

      Method for enabling specified `DeserializationConfig` features. Modifies and returns this instance; no new object is created.
      Since:
        1.9

    - #### disable

          public ObjectMapper disable(SerializationConfig.Feature... f)

      Method for enabling specified `DeserializationConfig` features. Modifies and returns this instance; no new object is created.
      Since:
        1.9

    - #### isEnabled

          public boolean isEnabled(SerializationConfig.Feature f)

      Convenience method, equivalent to:

            getSerializationConfig().isEnabled(f);

      Since:
        1.9

    - #### isEnabled

          public boolean isEnabled(DeserializationConfig.Feature f)

      Convenience method, equivalent to:

            getDeserializationConfig().isEnabled(f);

      Since:
        1.9

    - #### isEnabled

          public boolean isEnabled(JsonParser.Feature f)

      Convenience method, equivalent to:

            getJsonFactory().isEnabled(f);

      Since:
        1.9

    - #### isEnabled

          public boolean isEnabled(JsonGenerator.Feature f)

      Convenience method, equivalent to:

            getJsonFactory().isEnabled(f);

      Since:
        1.9

    - #### getNodeFactory

          public JsonNodeFactory getNodeFactory()

      Method that can be used to get hold of `JsonNodeFactory` that this mapper will use when directly constructing root `JsonNode` instances for Trees.

      Note: this is just a shortcut for calling

             getDeserializationConfig().getNodeFactory()

      Since:
        1.2

    - #### readValue

          public <T> T readValue(JsonParser jp,
                        Class<T> valueType)
                      throws IOException,
                             JsonParseException,
                             JsonMappingException

      Method to deserialize JSON content into a non-container type (it can be an array type, however): typically a bean, array or a wrapper type (like `Boolean`).

      Note: this method should NOT be used if the result type is a container (`Collection` or `Map`. The reason is that due to type erasure, key and value types can not be introspected when using this method.

      Specified by:
        `readValue` in class `ObjectCodec`
      Throws:
        `IOException`
        `JsonParseException`
        `JsonMappingException`

    - #### readValue

          public <T> T readValue(JsonParser jp,
                        TypeReference<?> valueTypeRef)
                      throws IOException,
                             JsonParseException,
                             JsonMappingException

      Method to deserialize JSON content into a Java type, reference to which is passed as argument. Type is passed using so-called "super type token" (see ) and specifically needs to be used if the root type is a parameterized (generic) container type.
      Specified by:
        `readValue` in class `ObjectCodec`
      Throws:
        `IOException`
        `JsonParseException`
        `JsonMappingException`

    - #### readValue

          public <T> T readValue(JsonParser jp,
                        JavaType valueType)
                      throws IOException,
                             JsonParseException,
                             JsonMappingException

      Method to deserialize JSON content into a Java type, reference to which is passed as argument. Type is passed using Jackson specific type; instance of which can be constructed using `TypeFactory`.
      Specified by:
        `readValue` in class `ObjectCodec`
      Throws:
        `IOException`
        `JsonParseException`
        `JsonMappingException`

    - #### readTree

          public JsonNode readTree(JsonParser jp)
                            throws IOException,
                                   JsonProcessingException

      Method to deserialize JSON content as tree expressed using set of `JsonNode` instances. Returns root of the resulting tree (where root can consist of just a single node if the current event is a value event, not container).
      Specified by:
        `readTree` in class `ObjectCodec`
      Throws:
        `IOException`
        `JsonProcessingException`

    - #### readValues

          public <T> MappingIterator<T> readValues(JsonParser jp,
                                          JavaType valueType)
                                        throws IOException,
                                               JsonProcessingException

      Method for reading sequence of Objects from parser stream.

      Note that `ObjectReader` has more complete set of variants.

      Specified by:
        `readValues` in class `ObjectCodec`
      Throws:
        `IOException`
        `JsonProcessingException`
      Since:
        1.8

    - #### readValues

          public <T> MappingIterator<T> readValues(JsonParser jp,
                                          Class<T> valueType)
                                        throws IOException,
                                               JsonProcessingException

      Method for reading sequence of Objects from parser stream.
      Specified by:
        `readValues` in class `ObjectCodec`
      Throws:
        `IOException`
        `JsonProcessingException`
      Since:
        1.8

    - #### readValues

          public <T> MappingIterator<T> readValues(JsonParser jp,
                                          TypeReference<?> valueTypeRef)
                                        throws IOException,
                                               JsonProcessingException

      Method for reading sequence of Objects from parser stream.
      Specified by:
        `readValues` in class `ObjectCodec`
      Throws:
        `IOException`
        `JsonProcessingException`
      Since:
        1.8

    - #### readValue

          public <T> T readValue(JsonParser jp,
                        Class<T> valueType,
                        DeserializationConfig cfg)
                      throws IOException,
                             JsonParseException,
                             JsonMappingException

      Method to deserialize JSON content into a non-container type (it can be an array type, however): typically a bean, array or a wrapper type (like `Boolean`).

      Note: this method should NOT be used if the result type is a container (`Collection` or `Map`. The reason is that due to type erasure, key and value types can not be introspected when using this method.

      Parameters:
        `cfg` - Specific deserialization configuration to use for this operation. Note that not all config settings can be changed on per-operation basis: some changeds only take effect before calling the operation for the first time (for the mapper instance)
      Throws:
        `IOException`
        `JsonParseException`
        `JsonMappingException`
      Since:
        1.1

    - #### readValue

          public <T> T readValue(JsonParser jp,
                        TypeReference<?> valueTypeRef,
                        DeserializationConfig cfg)
                      throws IOException,
                             JsonParseException,
                             JsonMappingException

      Method to deserialize JSON content into a Java type, reference to which is passed as argument. Type is passed using so-called "super type token" (see ) and specifically needs to be used if the root type is a parameterized (generic) container type.
      Parameters:
        `cfg` - Specific deserialization configuration to use for this operation. Note that not all config settings can be changed on per-operation basis: some changeds only take effect before calling the operation for the first time (for the mapper instance)
      Throws:
        `IOException`
        `JsonParseException`
        `JsonMappingException`
      Since:
        1.1

    - #### readValue

          public <T> T readValue(JsonParser jp,
                        JavaType valueType,
                        DeserializationConfig cfg)
                      throws IOException,
                             JsonParseException,
                             JsonMappingException

      Method to deserialize JSON content into a Java type, reference to which is passed as argument. Type is passed using Jackson specific type; instance of which can be constructed using `TypeFactory`.
      Parameters:
        `cfg` - Specific deserialization configuration to use for this operation. Note that not all config settings can be changed on per-operation basis: some changeds only take effect before calling the operation for the first time (for the mapper instance)
      Throws:
        `IOException`
        `JsonParseException`
        `JsonMappingException`
      Since:
        1.1

    - #### readTree

          public JsonNode readTree(JsonParser jp,
                          DeserializationConfig cfg)
                            throws IOException,
                                   JsonProcessingException

      Method to deserialize JSON content as tree expressed using set of `JsonNode` instances. Returns root of the resulting tree (where root can consist of just a single node if the current event is a value event, not container).
      Parameters:
        `cfg` - Specific deserialization configuration to use for this operation. Note that not all config settings can be changed on per-operation basis: some changeds only take effect before calling the operation for the first time (for the mapper instance)
      Throws:
        `IOException`
        `JsonProcessingException`
      Since:
        1.1

    - #### readTree

          public JsonNode readTree(InputStream in)
                            throws IOException,
                                   JsonProcessingException

      Method to deserialize JSON content as tree expressed using set of `JsonNode` instances. Returns root of the resulting tree (where root can consist of just a single node if the current event is a value event, not container).
      Parameters:
        `in` - Input stream used to read JSON content for building the JSON tree.
      Throws:
        `IOException`
        `JsonProcessingException`
      Since:
        1.3

    - #### readTree

          public JsonNode readTree(Reader r)
                            throws IOException,
                                   JsonProcessingException

      Method to deserialize JSON content as tree expressed using set of `JsonNode` instances. Returns root of the resulting tree (where root can consist of just a single node if the current event is a value event, not container).
      Parameters:
        `r` - Reader used to read JSON content for building the JSON tree.
      Throws:
        `IOException`
        `JsonProcessingException`
      Since:
        1.3

    - #### readTree

          public JsonNode readTree(String content)
                            throws IOException,
                                   JsonProcessingException

      Method to deserialize JSON content as tree expressed using set of `JsonNode` instances. Returns root of the resulting tree (where root can consist of just a single node if the current event is a value event, not container).
      Parameters:
        `content` - JSON content to parse to build the JSON tree.
      Throws:
        `IOException`
        `JsonProcessingException`
      Since:
        1.3

    - #### readTree

          public JsonNode readTree(byte[] content)
                            throws IOException,
                                   JsonProcessingException

      Method to deserialize JSON content as tree expressed using set of `JsonNode` instances. Returns root of the resulting tree (where root can consist of just a single node if the current event is a value event, not container).
      Parameters:
        `content` - JSON content to parse to build the JSON tree.
      Throws:
        `IOException`
        `JsonProcessingException`
      Since:
        1.9

    - #### readTree

          public JsonNode readTree(File file)
                            throws IOException,
                                   JsonProcessingException

      Method to deserialize JSON content as tree expressed using set of `JsonNode` instances. Returns root of the resulting tree (where root can consist of just a single node if the current event is a value event, not container).
      Parameters:
        `file` - File of which contents to parse as JSON for building a tree instance
      Throws:
        `IOException`
        `JsonProcessingException`
      Since:
        1.9

    - #### readTree

          public JsonNode readTree(URL source)
                            throws IOException,
                                   JsonProcessingException

      Method to deserialize JSON content as tree expressed using set of `JsonNode` instances. Returns root of the resulting tree (where root can consist of just a single node if the current event is a value event, not container).
      Parameters:
        `source` - URL to use for fetching contents to parse as JSON for building a tree instance
      Throws:
        `IOException`
        `JsonProcessingException`
      Since:
        1.9

    - #### writeValue

          public void writeValue(JsonGenerator jgen,
                        Object value)
                          throws IOException,
                                 JsonGenerationException,
                                 JsonMappingException

      Method that can be used to serialize any Java value as JSON output, using provided `JsonGenerator`.
      Specified by:
        `writeValue` in class `ObjectCodec`
      Throws:
        `IOException`
        `JsonGenerationException`
        `JsonMappingException`

    - #### writeValue

          public void writeValue(JsonGenerator jgen,
                        Object value,
                        SerializationConfig config)
                          throws IOException,
                                 JsonGenerationException,
                                 JsonMappingException

      Method that can be used to serialize any Java value as JSON output, using provided `JsonGenerator`, configured as per passed configuration object.
      Throws:
        `IOException`
        `JsonGenerationException`
        `JsonMappingException`
      Since:
        1.1

    - #### writeTree

          public void writeTree(JsonGenerator jgen,
                       JsonNode rootNode)
                         throws IOException,
                                JsonProcessingException

      Method to serialize given JSON Tree, using generator provided.
      Specified by:
        `writeTree` in class `ObjectCodec`
      Throws:
        `IOException`
        `JsonProcessingException`

    - #### writeTree

          public void writeTree(JsonGenerator jgen,
                       JsonNode rootNode,
                       SerializationConfig cfg)
                         throws IOException,
                                JsonProcessingException

      Method to serialize given Json Tree, using generator provided.
      Throws:
        `IOException`
        `JsonProcessingException`
      Since:
        1.1

    - #### createObjectNode

          public ObjectNode createObjectNode()

      Note: return type is co-variant, as basic ObjectCodec abstraction can not refer to concrete node types (as it's part of core package, whereas impls are part of mapper package)

      Specified by:
        `createObjectNode` in class `ObjectCodec`
      Since:
        1.2

    - #### createArrayNode

          public ArrayNode createArrayNode()

      Note: return type is co-variant, as basic ObjectCodec abstraction can not refer to concrete node types (as it's part of core package, whereas impls are part of mapper package)

      Specified by:
        `createArrayNode` in class `ObjectCodec`
      Since:
        1.2

    - #### treeAsTokens

          public JsonParser treeAsTokens(JsonNode n)

      Method for constructing a `JsonParser` out of JSON tree representation.
      Specified by:
        `treeAsTokens` in class `ObjectCodec`
      Parameters:
        `n` - Root node of the tree that resulting parser will read from
      Since:
        1.3

    - #### treeToValue

          public <T> T treeToValue(JsonNode n,
                          Class<T> valueType)
                        throws IOException,
                               JsonParseException,
                               JsonMappingException

      Convenience conversion method that will bind data given JSON tree contains into specific value (usually bean) type.

      Equivalent to:

             objectMapper.convertValue(n, valueClass);

      Specified by:
        `treeToValue` in class `ObjectCodec`
      Throws:
        `IOException`
        `JsonParseException`
        `JsonMappingException`

    - #### valueToTree

          public <T extends JsonNode> T valueToTree(Object fromValue)
                                         throws IllegalArgumentException

      Reverse of `treeToValue(org.codehaus.jackson.JsonNode, java.lang.Class<T>)`; given a value (usually bean), will construct equivalent JSON Tree representation. Functionally same as if serializing value into JSON and parsing JSON as tree, but more efficient.
      Type Parameters:
        `T` - Actual node type; usually either basic `JsonNode` or `ObjectNode`
      Parameters:
        `fromValue` - Bean value to convert
      Returns:
        Root node of the resulting JSON tree
      Throws:
        `IllegalArgumentException`
      Since:
        1.6

    - #### canSerialize

          public boolean canSerialize(Class<?> type)

      Method that can be called to check whether mapper thinks it could serialize an instance of given Class. Check is done by checking whether a serializer can be found for the type.
      Returns:
        True if mapper can find a serializer for instances of given class (potentially serializable), false otherwise (not serializable)

    - #### canDeserialize

          public boolean canDeserialize(JavaType type)

      Method that can be called to check whether mapper thinks it could deserialize an Object of given type. Check is done by checking whether a deserializer can be found for the type.
      Returns:
        True if mapper can find a serializer for instances of given class (potentially serializable), false otherwise (not serializable)

    - #### readValue

          public <T> T readValue(File src,
                        Class<T> valueType)
                      throws IOException,
                             JsonParseException,
                             JsonMappingException

      Throws:
        `IOException`
        `JsonParseException`
        `JsonMappingException`

    - #### readValue

          public <T> T readValue(File src,
                        TypeReference valueTypeRef)
                      throws IOException,
                             JsonParseException,
                             JsonMappingException

      Throws:
        `IOException`
        `JsonParseException`
        `JsonMappingException`

    - #### readValue

          public <T> T readValue(File src,
                        JavaType valueType)
                      throws IOException,
                             JsonParseException,
                             JsonMappingException

      Throws:
        `IOException`
        `JsonParseException`
        `JsonMappingException`

    - #### readValue

          public <T> T readValue(URL src,
                        Class<T> valueType)
                      throws IOException,
                             JsonParseException,
                             JsonMappingException

      Throws:
        `IOException`
        `JsonParseException`
        `JsonMappingException`

    - #### readValue

          public <T> T readValue(URL src,
                        TypeReference valueTypeRef)
                      throws IOException,
                             JsonParseException,
                             JsonMappingException

      Throws:
        `IOException`
        `JsonParseException`
        `JsonMappingException`

    - #### readValue

          public <T> T readValue(URL src,
                        JavaType valueType)
                      throws IOException,
                             JsonParseException,
                             JsonMappingException

      Throws:
        `IOException`
        `JsonParseException`
        `JsonMappingException`

    - #### readValue

          public <T> T readValue(String content,
                        Class<T> valueType)
                      throws IOException,
                             JsonParseException,
                             JsonMappingException

      Throws:
        `IOException`
        `JsonParseException`
        `JsonMappingException`

    - #### readValue

          public <T> T readValue(String content,
                        TypeReference valueTypeRef)
                      throws IOException,
                             JsonParseException,
                             JsonMappingException

      Throws:
        `IOException`
        `JsonParseException`
        `JsonMappingException`

    - #### readValue

          public <T> T readValue(String content,
                        JavaType valueType)
                      throws IOException,
                             JsonParseException,
                             JsonMappingException

      Throws:
        `IOException`
        `JsonParseException`
        `JsonMappingException`

    - #### readValue

          public <T> T readValue(Reader src,
                        Class<T> valueType)
                      throws IOException,
                             JsonParseException,
                             JsonMappingException

      Throws:
        `IOException`
        `JsonParseException`
        `JsonMappingException`

    - #### readValue

          public <T> T readValue(Reader src,
                        TypeReference valueTypeRef)
                      throws IOException,
                             JsonParseException,
                             JsonMappingException

      Throws:
        `IOException`
        `JsonParseException`
        `JsonMappingException`

    - #### readValue

          public <T> T readValue(Reader src,
                        JavaType valueType)
                      throws IOException,
                             JsonParseException,
                             JsonMappingException

      Throws:
        `IOException`
        `JsonParseException`
        `JsonMappingException`

    - #### readValue

          public <T> T readValue(InputStream src,
                        Class<T> valueType)
                      throws IOException,
                             JsonParseException,
                             JsonMappingException

      Throws:
        `IOException`
        `JsonParseException`
        `JsonMappingException`

    - #### readValue

          public <T> T readValue(InputStream src,
                        TypeReference valueTypeRef)
                      throws IOException,
                             JsonParseException,
                             JsonMappingException

      Throws:
        `IOException`
        `JsonParseException`
        `JsonMappingException`

    - #### readValue

          public <T> T readValue(InputStream src,
                        JavaType valueType)
                      throws IOException,
                             JsonParseException,
                             JsonMappingException

      Throws:
        `IOException`
        `JsonParseException`
        `JsonMappingException`

    - #### readValue

          public <T> T readValue(byte[] src,
                        Class<T> valueType)
                      throws IOException,
                             JsonParseException,
                             JsonMappingException

      Throws:
        `IOException`
        `JsonParseException`
        `JsonMappingException`
      Since:
        1.8

    - #### readValue

          public <T> T readValue(byte[] src,
                        int offset,
                        int len,
                        Class<T> valueType)
                      throws IOException,
                             JsonParseException,
                             JsonMappingException

      Throws:
        `IOException`
        `JsonParseException`
        `JsonMappingException`

    - #### readValue

          public <T> T readValue(byte[] src,
                        TypeReference valueTypeRef)
                      throws IOException,
                             JsonParseException,
                             JsonMappingException

      Throws:
        `IOException`
        `JsonParseException`
        `JsonMappingException`
      Since:
        1.8

    - #### readValue

          public <T> T readValue(byte[] src,
                        int offset,
                        int len,
                        TypeReference valueTypeRef)
                      throws IOException,
                             JsonParseException,
                             JsonMappingException

      Throws:
        `IOException`
        `JsonParseException`
        `JsonMappingException`

    - #### readValue

          public <T> T readValue(byte[] src,
                        JavaType valueType)
                      throws IOException,
                             JsonParseException,
                             JsonMappingException

      Throws:
        `IOException`
        `JsonParseException`
        `JsonMappingException`
      Since:
        1.8

    - #### readValue

          public <T> T readValue(byte[] src,
                        int offset,
                        int len,
                        JavaType valueType)
                      throws IOException,
                             JsonParseException,
                             JsonMappingException

      Throws:
        `IOException`
        `JsonParseException`
        `JsonMappingException`

    - #### readValue

          public <T> T readValue(JsonNode root,
                        Class<T> valueType)
                      throws IOException,
                             JsonParseException,
                             JsonMappingException

      Convenience method for converting results from given JSON tree into given value type. Basically short-cut for:

             mapper.readValue(mapper.treeAsTokens(root), valueType);

      Throws:
        `IOException`
        `JsonParseException`
        `JsonMappingException`
      Since:
        1.6

    - #### readValue

          public <T> T readValue(JsonNode root,
                        TypeReference valueTypeRef)
                      throws IOException,
                             JsonParseException,
                             JsonMappingException

      Convenience method for converting results from given JSON tree into given value type. Basically short-cut for:

             mapper.readValue(mapper.treeAsTokens(root), valueType);

      Throws:
        `IOException`
        `JsonParseException`
        `JsonMappingException`
      Since:
        1.6

    - #### readValue

          public <T> T readValue(JsonNode root,
                        JavaType valueType)
                      throws IOException,
                             JsonParseException,
                             JsonMappingException

      Convenience method for converting results from given JSON tree into given value type. Basically short-cut for:

             mapper.readValue(mapper.treeAsTokens(root), valueType);

      Throws:
        `IOException`
        `JsonParseException`
        `JsonMappingException`
      Since:
        1.6

    - #### writeValue

          public void writeValue(File resultFile,
                        Object value)
                          throws IOException,
                                 JsonGenerationException,
                                 JsonMappingException

      Method that can be used to serialize any Java value as JSON output, written to File provided.
      Throws:
        `IOException`
        `JsonGenerationException`
        `JsonMappingException`

    - #### writeValue

          public void writeValue(OutputStream out,
                        Object value)
                          throws IOException,
                                 JsonGenerationException,
                                 JsonMappingException

      Method that can be used to serialize any Java value as JSON output, using output stream provided (using encoding `JsonEncoding.UTF8`).

      Note: method does not close the underlying stream explicitly here; however, `JsonFactory` this mapper uses may choose to close the stream depending on its settings (by default, it will try to close it when `JsonGenerator` we construct is closed).

      Throws:
        `IOException`
        `JsonGenerationException`
        `JsonMappingException`

    - #### writeValue

          public void writeValue(Writer w,
                        Object value)
                          throws IOException,
                                 JsonGenerationException,
                                 JsonMappingException

      Method that can be used to serialize any Java value as JSON output, using Writer provided.

      Note: method does not close the underlying stream explicitly here; however, `JsonFactory` this mapper uses may choose to close the stream depending on its settings (by default, it will try to close it when `JsonGenerator` we construct is closed).

      Throws:
        `IOException`
        `JsonGenerationException`
        `JsonMappingException`

    - #### writeValueAsString

          public String writeValueAsString(Object value)
                                    throws IOException,
                                           JsonGenerationException,
                                           JsonMappingException

      Method that can be used to serialize any Java value as a String. Functionally equivalent to calling `writeValue(Writer,Object)` with `StringWriter` and constructing String, but more efficient.
      Throws:
        `IOException`
        `JsonGenerationException`
        `JsonMappingException`
      Since:
        1.3

    - #### writeValueAsBytes

          public byte[] writeValueAsBytes(Object value)
                                   throws IOException,
                                          JsonGenerationException,
                                          JsonMappingException

      Method that can be used to serialize any Java value as a byte array. Functionally equivalent to calling `writeValue(Writer,Object)` with `ByteArrayOutputStream` and getting bytes, but more efficient. Encoding used will be UTF-8.
      Throws:
        `IOException`
        `JsonGenerationException`
        `JsonMappingException`
      Since:
        1.5

    - #### writer

          public ObjectWriter writer()

      Convenience method for constructing `ObjectWriter` with default settings.
      Since:
        1.6

    - #### writer

          public ObjectWriter writer(DateFormat df)

      Factory method for constructing `ObjectWriter` that will serialize objects using specified `DateFormat`; or, if null passed, using timestamp (64-bit number.
      Since:
        1.9

    - #### writerWithView

          public ObjectWriter writerWithView(Class<?> serializationView)

      Factory method for constructing `ObjectWriter` that will serialize objects using specified JSON View (filter).
      Since:
        1.9

    - #### writerWithType

          public ObjectWriter writerWithType(Class<?> rootType)

      Factory method for constructing `ObjectWriter` that will serialize objects using specified root type, instead of actual runtime type of value. Type must be a super-type of runtime type.
      Since:
        1.9

    - #### writerWithType

          public ObjectWriter writerWithType(JavaType rootType)

      Factory method for constructing `ObjectWriter` that will serialize objects using specified root type, instead of actual runtime type of value. Type must be a super-type of runtime type.
      Since:
        1.9

    - #### writerWithType

          public ObjectWriter writerWithType(TypeReference<?> rootType)

      Factory method for constructing `ObjectWriter` that will serialize objects using specified root type, instead of actual runtime type of value. Type must be a super-type of runtime type.
      Since:
        1.9

    - #### writer

          public ObjectWriter writer(PrettyPrinter pp)

      Factory method for constructing `ObjectWriter` that will serialize objects using specified pretty printer for indentation (or if null, no pretty printer)
      Since:
        1.9

    - #### writerWithDefaultPrettyPrinter

          public ObjectWriter writerWithDefaultPrettyPrinter()

      Factory method for constructing `ObjectWriter` that will serialize objects using the default pretty printer for indentation
      Since:
        1.9

    - #### writer

          public ObjectWriter writer(FilterProvider filterProvider)

      Factory method for constructing `ObjectWriter` that will serialize objects using specified filter provider.
      Since:
        1.9

    - #### writer

          public ObjectWriter writer(FormatSchema schema)

      Factory method for constructing `ObjectWriter` that will pass specific schema object to `JsonGenerator` used for writing content.
      Parameters:
        `schema` - Schema to pass to generator
      Since:
        1.9

    - #### typedWriter

          @Deprecated
          public ObjectWriter typedWriter(Class<?> rootType)

      Deprecated. Since 1.9, use `writerWithType(Class)` instead.

    - #### typedWriter

          @Deprecated
          public ObjectWriter typedWriter(JavaType rootType)

      Deprecated. Since 1.9, use `writerWithType(JavaType)` instead.

    - #### typedWriter

          @Deprecated
          public ObjectWriter typedWriter(TypeReference<?> rootType)

      Deprecated. Since 1.9, use `writerWithType(TypeReference)` instead.

    - #### viewWriter

          @Deprecated
          public ObjectWriter viewWriter(Class<?> serializationView)

      Deprecated. Since 1.9, use `writerWithView(Class)` instead.

    - #### prettyPrintingWriter

          @Deprecated
          public ObjectWriter prettyPrintingWriter(PrettyPrinter pp)

      Deprecated. Since 1.9, use `writer(FilterProvider)` instead.

    - #### defaultPrettyPrintingWriter

          @Deprecated
          public ObjectWriter defaultPrettyPrintingWriter()

      Deprecated. Since 1.9, use `writerWithDefaultPrettyPrinter()` instead.

    - #### filteredWriter

          @Deprecated
          public ObjectWriter filteredWriter(FilterProvider filterProvider)

      Deprecated. Since 1.9, use `writer(FilterProvider)` instead.

    - #### schemaBasedWriter

          @Deprecated
          public ObjectWriter schemaBasedWriter(FormatSchema schema)

      Deprecated. Since 1.9, use `writer(FilterProvider)` instead.

    - #### reader

          public ObjectReader reader()

      Factory method for constructing `ObjectReader` with default settings. Note that the resulting instance is NOT usable as is, without defining expected value type.
      Since:
        1.6

    - #### readerForUpdating

          public ObjectReader readerForUpdating(Object valueToUpdate)

      Factory method for constructing `ObjectReader` that will update given Object (usually Bean, but can be a Collection or Map as well, but NOT an array) with JSON data. Deserialization occurs normally except that the root-level value in JSON is not used for instantiating a new object; instead give updateable object is used as root. Runtime type of value object is used for locating deserializer, unless overridden by other factory methods of `ObjectReader`
      Since:
        1.9

    - #### reader

          public ObjectReader reader(JavaType type)

      Factory method for constructing `ObjectReader` that will read or update instances of specified type
      Since:
        1.6

    - #### reader

          public ObjectReader reader(Class<?> type)

      Factory method for constructing `ObjectReader` that will read or update instances of specified type
      Since:
        1.6

    - #### reader

          public ObjectReader reader(TypeReference<?> type)

      Factory method for constructing `ObjectReader` that will read or update instances of specified type
      Since:
        1.6

    - #### reader

          public ObjectReader reader(JsonNodeFactory f)

      Factory method for constructing `ObjectReader` that will use specified `JsonNodeFactory` for constructing JSON trees.
      Since:
        1.6

    - #### reader

          public ObjectReader reader(FormatSchema schema)

      Factory method for constructing `ObjectReader` that will pass specific schema object to `JsonParser` used for reading content.
      Parameters:
        `schema` - Schema to pass to parser
      Since:
        1.8

    - #### reader

          public ObjectReader reader(InjectableValues injectableValues)

      Factory method for constructing `ObjectReader` that will use specified injectable values.
      Parameters:
        `injectableValues` - Injectable values to use
      Since:
        1.9

    - #### updatingReader

          @Deprecated
          public ObjectReader updatingReader(Object valueToUpdate)

      Deprecated. Since 1.9, use `readerForUpdating(java.lang.Object)` instead.

    - #### schemaBasedReader

          @Deprecated
          public ObjectReader schemaBasedReader(FormatSchema schema)

      Deprecated. Since 1.9, use `reader(FormatSchema)` instead.

    - #### convertValue

          public <T> T convertValue(Object fromValue,
                           Class<T> toValueType)
                         throws IllegalArgumentException

      Convenience method for doing two-step conversion from given value, into instance of given value type. This is functionality equivalent to first serializing given value into JSON, then binding JSON data into value of given type, but may be executed without fully serializing into JSON. Same converters (serializers, deserializers) will be used as for data binding, meaning same object mapper configuration works.
      Throws:
        `IllegalArgumentException` - If conversion fails due to incompatible type; if so, root cause will contain underlying checked exception data binding functionality threw

    - #### convertValue

          public <T> T convertValue(Object fromValue,
                           TypeReference toValueTypeRef)
                         throws IllegalArgumentException

      Throws:
        `IllegalArgumentException`

    - #### convertValue

          public <T> T convertValue(Object fromValue,
                           JavaType toValueType)
                         throws IllegalArgumentException

      Throws:
        `IllegalArgumentException`

    - #### _convert

          protected Object _convert(Object fromValue,
                        JavaType toValueType)
                             throws IllegalArgumentException

      Throws:
        `IllegalArgumentException`

    - #### generateJsonSchema

          public JsonSchema generateJsonSchema(Class<?> t)
                                        throws JsonMappingException

      Generate Json-schema instance for specified class.
      Parameters:
        `t` - The class to generate schema for
      Returns:
        Constructed JSON schema.
      Throws:
        `JsonMappingException`

    - #### generateJsonSchema

          public JsonSchema generateJsonSchema(Class<?> t,
                                      SerializationConfig cfg)
                                        throws JsonMappingException

      Generate Json-schema instance for specified class, using specific serialization configuration
      Parameters:
        `t` - The class to generate schema for
      Returns:
        Constructed JSON schema.
      Throws:
        `JsonMappingException`

    - #### _defaultPrettyPrinter

          protected PrettyPrinter _defaultPrettyPrinter()

      Helper method that should return default pretty-printer to use for generators constructed by this mapper, when instructed to use default pretty printer.
      Since:
        1.7

    - #### _configAndWriteValue

          protected final void _configAndWriteValue(JsonGenerator jgen,
                                  Object value)
                                             throws IOException,
                                                    JsonGenerationException,
                                                    JsonMappingException

      Method called to configure the generator as necessary and then call write functionality
      Throws:
        `IOException`
        `JsonGenerationException`
        `JsonMappingException`

    - #### _configAndWriteValue

          protected final void _configAndWriteValue(JsonGenerator jgen,
                                  Object value,
                                  Class<?> viewClass)
                                             throws IOException,
                                                    JsonGenerationException,
                                                    JsonMappingException

      Throws:
        `IOException`
        `JsonGenerationException`
        `JsonMappingException`

    - #### _readValue

          protected Object _readValue(DeserializationConfig cfg,
                          JsonParser jp,
                          JavaType valueType)
                               throws IOException,
                                      JsonParseException,
                                      JsonMappingException

      Actual implementation of value reading+binding operation.
      Throws:
        `IOException`
        `JsonParseException`
        `JsonMappingException`

    - #### _readMapAndClose

          protected Object _readMapAndClose(JsonParser jp,
                                JavaType valueType)
                                     throws IOException,
                                            JsonParseException,
                                            JsonMappingException

      Throws:
        `IOException`
        `JsonParseException`
        `JsonMappingException`

    - #### _initForReading

          protected JsonToken _initForReading(JsonParser jp)
                                       throws IOException,
                                              JsonParseException,
                                              JsonMappingException

      Method called to ensure that given parser is ready for reading content for data binding.
      Returns:
        First token to be used for data binding after this call: can never be null as exception will be thrown if parser can not provide more tokens.
      Throws:
        `IOException` - if the underlying input source has problems during parsing
        `JsonParseException` - if parser has problems parsing content
        `JsonMappingException` - if the parser does not have any more content to map (note: Json "null" value is considered content; enf-of-stream not)

    - #### _unwrapAndDeserialize

          protected Object _unwrapAndDeserialize(JsonParser jp,
                                     JavaType rootType,
                                     DeserializationContext ctxt,
                                     JsonDeserializer<Object> deser)
                                          throws IOException,
                                                 JsonParseException,
                                                 JsonMappingException

      Throws:
        `IOException`
        `JsonParseException`
        `JsonMappingException`

    - #### _findRootDeserializer

          protected JsonDeserializer<Object> _findRootDeserializer(DeserializationConfig cfg,
                                                       JavaType valueType)
                                                            throws JsonMappingException

      Method called to locate deserializer for the passed root-level value.
      Throws:
        `JsonMappingException`

    - #### _createDeserializationContext

          protected DeserializationContext _createDeserializationContext(JsonParser jp,
                                                             DeserializationConfig cfg)