## com.fasterxml.jackson.databind
Class ObjectReader

    java.lang.Object
      com.fasterxml.jackson.core.ObjectCodec
          com.fasterxml.jackson.databind.ObjectReader

All Implemented Interfaces:
  Versioned, Serializable

    public class ObjectReader

extends ObjectCodec
implements Versioned, Serializable

Builder object that can be used for per-serialization configuration of deserialization parameters, such as root type to use or object to update (instead of constructing new instance).

Uses "fluent" (or, kind of, builder) pattern so that instances are immutable (and thus fully thread-safe with no external synchronization); new instances are constructed for different configurations. Instances are initially constructed by `ObjectMapper` and can be reused, shared, cached; both because of thread-safety and because instances are relatively light-weight.

See Also:
  Serialized Form

Field Summary
`protected DeserializationConfig` `_config` General serialization configuration settings; while immutable, can use copy-constructor to create modified instances as necessary.
`protected DefaultDeserializationContext` `_context` Blueprint instance of deserialization context; used for creating actual instance when needed.
`protected DataFormatReaders` `_dataFormatReaders` Optional detector used for auto-detecting data format that byte-based input uses.
`protected InjectableValues` `_injectableValues` Values that can be injected during deserialization, if any.
`protected JsonFactory` `_jsonFactory` Factory used for constructing `JsonGenerator`s
`protected JsonDeserializer<Object>` `_rootDeserializer` We may pre-fetch deserializer as soon as `_valueType` is known, and if so, reuse it afterwards.
`protected ConcurrentHashMap<JavaType,JsonDeserializer<Object>>` `_rootDeserializers` Root-level cached deserializers
`protected RootNameLookup` `_rootNames` Cache for root names used when root-wrapping is enabled.
`protected FormatSchema` `_schema` When using data format that uses a schema, schema is passed to parser.
`protected boolean` `_unwrapRoot` Flag that indicates whether root values are expected to be unwrapped or not
`protected Object` `_valueToUpdate` Instance to update with data binding; if any.
`protected JavaType` `_valueType` Declared type of value to instantiate during deserialization.

Constructor Summary
`protected` `ObjectReader(ObjectMapper mapper, DeserializationConfig config)` Constructor used by `ObjectMapper` for initial instantiation
`protected` `ObjectReader(ObjectMapper mapper, DeserializationConfig config, JavaType valueType, Object valueToUpdate, FormatSchema schema, InjectableValues injectableValues)` Constructor called when a root deserializer should be fetched based on other configuration.
`protected` `ObjectReader(ObjectReader base, DeserializationConfig config)` Copy constructor used when modifying simple feature flags
`protected` `ObjectReader(ObjectReader base, DeserializationConfig config, JavaType valueType, JsonDeserializer<Object> rootDeser, Object valueToUpdate, FormatSchema schema, InjectableValues injectableValues, DataFormatReaders dataFormatReaders)` Copy constructor used for building variations.
`protected` `ObjectReader(ObjectReader base, JsonFactory f)`

Method Summary
`protected Object` `_bind(JsonParser jp, Object valueToUpdate)` Actual implementation of value reading+binding operation.
`protected Object` `_bindAndClose(JsonParser jp, Object valueToUpdate)`
`protected JsonNode` `_bindAndCloseAsTree(JsonParser jp)`

`protected

`<T> MappingIterator<T>`

`

`_bindAndReadValues(JsonParser p, Object valueToUpdate)`

`protected JsonNode` `_bindAsTree(JsonParser jp)`
`protected Object` `_detectBindAndClose(byte[] src, int offset, int length)`
`protected Object` `_detectBindAndClose(DataFormatReaders.Match match, boolean forceClosing)`
`protected JsonNode` `_detectBindAndCloseAsTree(InputStream in)`

`protected

`<T> MappingIterator<T>`

`

`_detectBindAndReadValues(DataFormatReaders.Match match, boolean forceClosing)`

`protected JsonDeserializer<Object>` `_findRootDeserializer(DeserializationContext ctxt, JavaType valueType)` Method called to locate deserializer for the passed root-level value.
`protected static JsonToken` `_initForReading(JsonParser jp)`
`protected InputStream` `_inputStream(File f)`
`protected InputStream` `_inputStream(URL src)`
`protected JsonDeserializer<Object>` `_prefetchRootDeserializer(DeserializationConfig config, JavaType valueType)` Method called to locate deserializer ahead of time, if permitted by configuration.
`protected void` `_reportUndetectableSource(Object src)`
`protected void` `_reportUnkownFormat(DataFormatReaders detector, DataFormatReaders.Match match)` Method called to indicate that format detection failed to detect format of given input
`protected Object` `_unwrapAndDeserialize(JsonParser jp, DeserializationContext ctxt, JavaType rootType, JsonDeserializer<Object> deser)`
`protected ObjectReader` `_with(DeserializationConfig newConfig)`
`JsonNode` `createArrayNode()`
`protected DefaultDeserializationContext` `createDeserializationContext(JsonParser jp, DeserializationConfig cfg)` Internal helper method called to create an instance of `DeserializationContext` for deserializing a single root value.
`JsonNode` `createObjectNode()`
`JsonFactory` `getFactory()`
`JsonFactory` `getJsonFactory()` Deprecated. Since 2.1: Use `getFactory()` instead
`TypeFactory` `getTypeFactory()`
`boolean` `isEnabled(DeserializationFeature f)`
`boolean` `isEnabled(JsonParser.Feature f)`
`boolean` `isEnabled(MapperFeature f)`
`JsonNode` `readTree(InputStream in)` Method that reads content from given input source, using configuration of this reader, and binds it as JSON Tree.

`

`<T extends TreeNode> T`

`

`readTree(JsonParser jp)`
Convenience method that binds content read using given parser, using configuration of this reader, except that content is bound as JSON tree instead of configured root value type.

`JsonNode` `readTree(Reader r)` Method that reads content from given input source, using configuration of this reader, and binds it as JSON Tree.
`JsonNode` `readTree(String json)` Method that reads content from given JSON input String, using configuration of this reader, and binds it as JSON Tree.

`

`<T> T`

`

`readValue(byte[] src)`
Method that binds content read from given byte array, using configuration of this reader.

`

`<T> T`

`

`readValue(byte[] src, int offset, int length)`
Method that binds content read from given byte array, using configuration of this reader.

`

`<T> T`

`

`readValue(File src)`

`

`<T> T`

`

`readValue(InputStream src)`
Method that binds content read from given input source, using configuration of this reader.

`

`<T> T`

`

`readValue(JsonNode src)`
Convenience method for converting results from given JSON tree into given value type.

`

`<T> T`

`

`readValue(JsonParser jp)`
Method that binds content read using given parser, using configuration of this reader, including expected result type.

`

`<T> T`

`

`readValue(JsonParser jp, Class<T> valueType)`
Convenience method that binds content read using given parser, using configuration of this reader, except that expected value type is specified with the call (instead of currently configured root type).

`

`<T> T`

`

`readValue(JsonParser jp, JavaType valueType)`
Type-safe overloaded method, basically alias for `readValue(JsonParser, ResolvedType)`.

`

`<T> T`

`

`readValue(JsonParser jp, ResolvedType valueType)`
Convenience method that binds content read using given parser, using configuration of this reader, except that expected value type is specified with the call (instead of currently configured root type).

`

`<T> T`

`

`readValue(JsonParser jp, TypeReference<?> valueTypeRef)`
Convenience method that binds content read using given parser, using configuration of this reader, except that expected value type is specified with the call (instead of currently configured root type).

`

`<T> T`

`

`readValue(Reader src)`
Method that binds content read from given input source, using configuration of this reader.

`

`<T> T`

`

`readValue(String src)`
Method that binds content read from given JSON string, using configuration of this reader.

`

`<T> T`

`

`readValue(URL src)`
Method that binds content read from given input source, using configuration of this reader.

`

`<T> MappingIterator<T>`

`

`readValues(byte[] src)`
Overloaded version of `readValue(InputStream)`.

`

`<T> MappingIterator<T>`

`

`readValues(byte[] src, int offset, int length)`
Overloaded version of `readValue(InputStream)`.

`

`<T> MappingIterator<T>`

`

`readValues(File src)`
Overloaded version of `readValue(InputStream)`.

`

`<T> MappingIterator<T>`

`

`readValues(InputStream src)`
Method for reading sequence of Objects from parser stream.

`

`<T> MappingIterator<T>`

`

`readValues(JsonParser jp)`
Method for reading sequence of Objects from parser stream.

`

`<T> Iterator<T>`

`

`readValues(JsonParser jp, Class<T> valueType)`
Convenience method that is equivalent to:

`

`<T> Iterator<T>`

`

`readValues(JsonParser jp, JavaType valueType)`
Convenience method that is equivalent to:

`

`<T> Iterator<T>`

`

`readValues(JsonParser jp, ResolvedType valueType)`
Convenience method that is equivalent to:

`

`<T> Iterator<T>`

`

`readValues(JsonParser jp, TypeReference<?> valueTypeRef)`
Convenience method that is equivalent to:

`

`<T> MappingIterator<T>`

`

`readValues(Reader src)`
Overloaded version of `readValue(InputStream)`.

`

`<T> MappingIterator<T>`

`

`readValues(String json)`
Overloaded version of `readValue(InputStream)`.

`

`<T> MappingIterator<T>`

`

`readValues(URL src)`
Overloaded version of `readValue(InputStream)`.

`JsonParser` `treeAsTokens(TreeNode n)`

`

`<T> T`

`

`treeToValue(TreeNode n, Class<T> valueType)`

`Version` `version()` Method that will return version information stored in and read from jar that contains this class.
`ObjectReader` `with(Base64Variant defaultBase64)`
`ObjectReader` `with(DeserializationConfig config)`
`ObjectReader` `with(DeserializationFeature feature)` Method for constructing a new reader instance that is configured with specified feature enabled.
`ObjectReader` `with(DeserializationFeature first, DeserializationFeature... other)` Method for constructing a new reader instance that is configured with specified features enabled.
`ObjectReader` `with(FormatSchema schema)` Method for constructing a new instance with configuration that passes specified `FormatSchema` to `JsonParser` that is constructed for parsing content.
`ObjectReader` `with(InjectableValues injectableValues)` Method for constructing a new instance with configuration that uses passed `InjectableValues` to provide injectable values.
`ObjectReader` `with(JsonFactory f)` Method for constructing a new reader instance with configuration that uses passed `JsonFactory` for constructing underlying Readers.
`ObjectReader` `with(JsonNodeFactory f)` Method for constructing a new reader instance with configuration that uses passed `JsonNodeFactory` for constructing `JsonNode` instances.
`ObjectReader` `with(Locale l)`
`ObjectReader` `with(TimeZone tz)`
`ObjectReader` `withFeatures(DeserializationFeature... features)` Method for constructing a new reader instance that is configured with specified features enabled.
`ObjectReader` `withFormatDetection(DataFormatReaders readers)` Fluent factory method for constructing a reader that will try to auto-detect underlying data format, using specified `DataFormatReaders`.
`ObjectReader` `withFormatDetection(ObjectReader... readers)` Fluent factory method for constructing a reader that will try to auto-detect underlying data format, using specified list of `JsonFactory` instances, and default `DataFormatReaders` settings (for customized `DataFormatReaders`, you can construct instance yourself).
`ObjectReader` `withHandler(DeserializationProblemHandler h)`
`ObjectReader` `without(DeserializationFeature feature)` Method for constructing a new reader instance that is configured with specified feature disabled.
`ObjectReader` `without(DeserializationFeature first, DeserializationFeature... other)` Method for constructing a new reader instance that is configured with specified features disabled.
`ObjectReader` `withoutFeatures(DeserializationFeature... features)` Method for constructing a new reader instance that is configured with specified features disabled.
`ObjectReader` `withRootName(String rootName)` Method for constructing a new instance with configuration that specifies what root name to expect for "root name unwrapping".
`ObjectReader` `withType(Class<?> valueType)` Method for constructing a new reader instance that is configured to data bind into specified type.
`ObjectReader` `withType(JavaType valueType)` Method for constructing a new reader instance that is configured to data bind into specified type.
`ObjectReader` `withType(Type valueType)` Method for constructing a new reader instance that is configured to data bind into specified type.
`ObjectReader` `withType(TypeReference<?> valueTypeRef)` Method for constructing a new reader instance that is configured to data bind into specified type.
`ObjectReader` `withValueToUpdate(Object value)` Method for constructing a new instance with configuration that updates passed Object (as root value), instead of constructing a new value.
`ObjectReader` `withView(Class<?> activeView)` Method for constructing a new instance with configuration that uses specified View for filtering.
`void` `writeValue(JsonGenerator jgen, Object value)`

Methods inherited from class java.lang.Object
`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

Field Detail

### _config

    protected final DeserializationConfig _config

  General serialization configuration settings; while immutable, can use copy-constructor to create modified instances as necessary.

### _context

    protected final DefaultDeserializationContext _context

  Blueprint instance of deserialization context; used for creating actual instance when needed.

### _jsonFactory

    protected final JsonFactory _jsonFactory

  Factory used for constructing `JsonGenerator`s

### _unwrapRoot

    protected final boolean _unwrapRoot

  Flag that indicates whether root values are expected to be unwrapped or not

### _valueType

    protected final JavaType _valueType

  Declared type of value to instantiate during deserialization. Defines which deserializer to use; as well as base type of instance to construct if an updatable value is not configured to be used (subject to changes by embedded type information, for polymorphic types). If `_valueToUpdate` is non-null, only used for locating deserializer.

### _rootDeserializer

    protected final JsonDeserializer<Object> _rootDeserializer

  We may pre-fetch deserializer as soon as `_valueType` is known, and if so, reuse it afterwards. This allows avoiding further deserializer lookups and increases performance a bit on cases where readers are reused.

  Since:
    2.1

### _valueToUpdate

    protected final Object _valueToUpdate

  Instance to update with data binding; if any. If null, a new instance is created, if non-null, properties of this value object will be updated instead. Note that value can be of almost any type, except not `ArrayType`; array types can not be modified because array size is immutable.

### _schema

    protected final FormatSchema _schema

  When using data format that uses a schema, schema is passed to parser.

### _injectableValues

    protected final InjectableValues _injectableValues

  Values that can be injected during deserialization, if any.

### _dataFormatReaders

    protected final DataFormatReaders _dataFormatReaders

  Optional detector used for auto-detecting data format that byte-based input uses.

  NOTE: If defined non-null, `readValue()` methods that take `Reader` or `String` input will fail with exception, because format-detection only works on byte-sources. Also, if format can not be detect reliably (as per detector settings), a `JsonParseException` will be thrown).

  Since:
    2.1

### _rootDeserializers

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

  Root-level cached deserializers

### _rootNames

    protected final RootNameLookup _rootNames

  Cache for root names used when root-wrapping is enabled.

Constructor Detail

### ObjectReader

    protected ObjectReader(ObjectMapper mapper,
                           DeserializationConfig config)

  Constructor used by `ObjectMapper` for initial instantiation

### ObjectReader

    protected ObjectReader(ObjectMapper mapper,
                           DeserializationConfig config,
                           JavaType valueType,
                           Object valueToUpdate,
                           FormatSchema schema,
                           InjectableValues injectableValues)

  Constructor called when a root deserializer should be fetched based on other configuration.

### ObjectReader

    protected ObjectReader(ObjectReader base,
                           DeserializationConfig config,
                           JavaType valueType,
                           JsonDeserializer<Object> rootDeser,
                           Object valueToUpdate,
                           FormatSchema schema,
                           InjectableValues injectableValues,
                           DataFormatReaders dataFormatReaders)

  Copy constructor used for building variations.

### ObjectReader

    protected ObjectReader(ObjectReader base,
                           DeserializationConfig config)

  Copy constructor used when modifying simple feature flags

### ObjectReader

    protected ObjectReader(ObjectReader base,
                           JsonFactory f)

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`

### with

    public ObjectReader with(DeserializationConfig config)

### with

    public ObjectReader with(DeserializationFeature feature)

  Method for constructing a new reader instance that is configured with specified feature enabled.

### with

    public ObjectReader with(DeserializationFeature first,
                             DeserializationFeature... other)

  Method for constructing a new reader instance that is configured with specified features enabled.

### withFeatures

    public ObjectReader withFeatures(DeserializationFeature... features)

  Method for constructing a new reader instance that is configured with specified features enabled.

### without

    public ObjectReader without(DeserializationFeature feature)

  Method for constructing a new reader instance that is configured with specified feature disabled.

### without

    public ObjectReader without(DeserializationFeature first,
                                DeserializationFeature... other)

  Method for constructing a new reader instance that is configured with specified features disabled.

### withoutFeatures

    public ObjectReader withoutFeatures(DeserializationFeature... features)

  Method for constructing a new reader instance that is configured with specified features disabled.

### with

    public ObjectReader with(InjectableValues injectableValues)

  Method for constructing a new instance with configuration that uses passed `InjectableValues` to provide injectable values.

  Note that the method does NOT change state of this reader, but rather construct and returns a newly configured instance.

### with

    public ObjectReader with(JsonNodeFactory f)

  Method for constructing a new reader instance with configuration that uses passed `JsonNodeFactory` for constructing `JsonNode` instances.

  Note that the method does NOT change state of this reader, but rather construct and returns a newly configured instance.

### with

    public ObjectReader with(JsonFactory f)

  Method for constructing a new reader instance with configuration that uses passed `JsonFactory` for constructing underlying Readers.

  NOTE: only factories that DO NOT REQUIRE SPECIAL MAPPERS (that is, ones that return `false` for `JsonFactory.requiresCustomCodec()`) can be used: trying to use one that requires custom codec will throw exception

  Since:
    2.1

### withRootName

    public ObjectReader withRootName(String rootName)

  Method for constructing a new instance with configuration that specifies what root name to expect for "root name unwrapping". See `DeserializationConfig.withRootName(String)` for details.

  Note that the method does NOT change state of this reader, but rather construct and returns a newly configured instance.

### with

    public ObjectReader with(FormatSchema schema)

  Method for constructing a new instance with configuration that passes specified `FormatSchema` to `JsonParser` that is constructed for parsing content.

  Note that the method does NOT change state of this reader, but rather construct and returns a newly configured instance.

### withType

    public ObjectReader withType(JavaType valueType)

  Method for constructing a new reader instance that is configured to data bind into specified type.

  Note that the method does NOT change state of this reader, but rather construct and returns a newly configured instance.

### withType

    public ObjectReader withType(Class<?> valueType)

  Method for constructing a new reader instance that is configured to data bind into specified type.

  Note that the method does NOT change state of this reader, but rather construct and returns a newly configured instance.

### withType

    public ObjectReader withType(Type valueType)

  Method for constructing a new reader instance that is configured to data bind into specified type.

  Note that the method does NOT change state of this reader, but rather construct and returns a newly configured instance.

### withType

    public ObjectReader withType(TypeReference<?> valueTypeRef)

  Method for constructing a new reader instance that is configured to data bind into specified type.

  Note that the method does NOT change state of this reader, but rather construct and returns a newly configured instance.

### withValueToUpdate

    public ObjectReader withValueToUpdate(Object value)

  Method for constructing a new instance with configuration that updates passed Object (as root value), instead of constructing a new value.

  Note that the method does NOT change state of this reader, but rather construct and returns a newly configured instance.

### withView

    public ObjectReader withView(Class<?> activeView)

  Method for constructing a new instance with configuration that uses specified View for filtering.

  Note that the method does NOT change state of this reader, but rather construct and returns a newly configured instance.

### with

    public ObjectReader with(Locale l)

### with

    public ObjectReader with(TimeZone tz)

### withHandler

    public ObjectReader withHandler(DeserializationProblemHandler h)

### with

    public ObjectReader with(Base64Variant defaultBase64)

### withFormatDetection

    public ObjectReader withFormatDetection(ObjectReader... readers)

  Fluent factory method for constructing a reader that will try to auto-detect underlying data format, using specified list of `JsonFactory` instances, and default `DataFormatReaders` settings (for customized `DataFormatReaders`, you can construct instance yourself). to construct appropriate `JsonParser` for actual parsing.

  Note: since format detection only works with byte sources, it is possible to get a failure from some 'readValue()' methods. Also, if input can not be reliably (enough) detected as one of specified types, an exception will be thrown.

  Note: not all `JsonFactory` types can be passed: specifically, ones that require "custom codec" (like XML factory) will not work. Instead, use method that takes `ObjectReader` instances instead of factories.

  Parameters:
    `readers` - Data formats accepted, in decreasing order of priority (that is, matches checked in listed order, first match wins)
  Returns:
    Newly configured writer instance
  Since:
    2.1

### withFormatDetection

    public ObjectReader withFormatDetection(DataFormatReaders readers)

  Fluent factory method for constructing a reader that will try to auto-detect underlying data format, using specified `DataFormatReaders`.

  NOTE: since format detection only works with byte sources, it is possible to get a failure from some 'readValue()' methods. Also, if input can not be reliably (enough) detected as one of specified types, an exception will be thrown.

  Parameters:
    `readers` - DataFormatReaders to use for detecting underlying format.
  Returns:
    Newly configured writer instance
  Since:
    2.1

### isEnabled

    public boolean isEnabled(DeserializationFeature f)

### isEnabled

    public boolean isEnabled(MapperFeature f)

### isEnabled

    public boolean isEnabled(JsonParser.Feature f)

### getFactory

    public JsonFactory getFactory()

  Overrides:
    `getFactory` in class `ObjectCodec`

### getJsonFactory

    @Deprecated
    public JsonFactory getJsonFactory()

  Deprecated. Since 2.1: Use `getFactory()` instead

  Specified by:
    `getJsonFactory` in class `ObjectCodec`

### getTypeFactory

    public TypeFactory getTypeFactory()

### readValue

    public <T> T readValue(JsonParser jp)
                throws IOException,
                       JsonProcessingException

  Method that binds content read using given parser, using configuration of this reader, including expected result type. Value return is either newly constructed, or root value that was specified with `withValueToUpdate(Object)`.

  NOTE: this method never tries to auto-detect format, since actual (data-format specific) parser is given.

  Throws:
    `IOException`
    `JsonProcessingException`

### readValue

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

  Convenience method that binds content read using given parser, using configuration of this reader, except that expected value type is specified with the call (instead of currently configured root type). Value return is either newly constructed, or root value that was specified with `withValueToUpdate(Object)`.

  NOTE: this method never tries to auto-detect format, since actual (data-format specific) parser is given.

  Specified by:
    `readValue` in class `ObjectCodec`
  Throws:
    `IOException`
    `JsonProcessingException`

### readValue

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

  Convenience method that binds content read using given parser, using configuration of this reader, except that expected value type is specified with the call (instead of currently configured root type). Value return is either newly constructed, or root value that was specified with `withValueToUpdate(Object)`.

  NOTE: this method never tries to auto-detect format, since actual (data-format specific) parser is given.

  Specified by:
    `readValue` in class `ObjectCodec`
  Throws:
    `IOException`
    `JsonProcessingException`

### readValue

    public <T> T readValue(JsonParser jp,
                           ResolvedType valueType)
                throws IOException,
                       JsonProcessingException

  Convenience method that binds content read using given parser, using configuration of this reader, except that expected value type is specified with the call (instead of currently configured root type). Value return is either newly constructed, or root value that was specified with `withValueToUpdate(Object)`.

  NOTE: this method never tries to auto-detect format, since actual (data-format specific) parser is given.

  Specified by:
    `readValue` in class `ObjectCodec`
  Throws:
    `IOException`
    `JsonProcessingException`

### readValue

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

  Type-safe overloaded method, basically alias for `readValue(JsonParser, ResolvedType)`.

  NOTE: this method never tries to auto-detect format, since actual (data-format specific) parser is given.

  Throws:
    `IOException`
    `JsonProcessingException`

### readTree

    public <T extends TreeNode> T readTree(JsonParser jp)
                                throws IOException,
                                       JsonProcessingException

  Convenience method that binds content read using given parser, using configuration of this reader, except that content is bound as JSON tree instead of configured root value type.

  Note: if an object was specified with `withValueToUpdate(java.lang.Object)`, it will be ignored.

  NOTE: this method never tries to auto-detect format, since actual (data-format specific) parser is given.

  Specified by:
    `readTree` in class `ObjectCodec`
  Throws:
    `IOException`
    `JsonProcessingException`

### readValues

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

  Convenience method that is equivalent to:

         withType(valueType).readValues(jp);

  NOTE: this method never tries to auto-detect format, since actual (data-format specific) parser is given.

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

### readValues

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

  Convenience method that is equivalent to:

         withType(valueTypeRef).readValues(jp);

  NOTE: this method never tries to auto-detect format, since actual (data-format specific) parser is given.

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

### readValues

    public <T> Iterator<T> readValues(JsonParser jp,
                                      ResolvedType valueType)
                           throws IOException,
                                  JsonProcessingException

  Convenience method that is equivalent to:

         withType(valueType).readValues(jp);

  NOTE: this method never tries to auto-detect format, since actual (data-format specific) parser is given.

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

### readValues

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

  Convenience method that is equivalent to:

         withType(valueType).readValues(jp);

  NOTE: this method never tries to auto-detect format, since actual (data-format specific) parser is given.

  Throws:
    `IOException`
    `JsonProcessingException`

### readValue

    public <T> T readValue(InputStream src)
                throws IOException,
                       JsonProcessingException

  Method that binds content read from given input source, using configuration of this reader. Value return is either newly constructed, or root value that was specified with `withValueToUpdate(Object)`.

  Throws:
    `IOException`
    `JsonProcessingException`

### readValue

    public <T> T readValue(Reader src)
                throws IOException,
                       JsonProcessingException

  Method that binds content read from given input source, using configuration of this reader. Value return is either newly constructed, or root value that was specified with `withValueToUpdate(Object)`.

  Throws:
    `IOException`
    `JsonProcessingException`

### readValue

    public <T> T readValue(String src)
                throws IOException,
                       JsonProcessingException

  Method that binds content read from given JSON string, using configuration of this reader. Value return is either newly constructed, or root value that was specified with `withValueToUpdate(Object)`.

  Throws:
    `IOException`
    `JsonProcessingException`

### readValue

    public <T> T readValue(byte[] src)
                throws IOException,
                       JsonProcessingException

  Method that binds content read from given byte array, using configuration of this reader. Value return is either newly constructed, or root value that was specified with `withValueToUpdate(Object)`.

  Throws:
    `IOException`
    `JsonProcessingException`

### readValue

    public <T> T readValue(byte[] src,
                           int offset,
                           int length)
                throws IOException,
                       JsonProcessingException

  Method that binds content read from given byte array, using configuration of this reader. Value return is either newly constructed, or root value that was specified with `withValueToUpdate(Object)`.

  Throws:
    `IOException`
    `JsonProcessingException`

### readValue

    public <T> T readValue(File src)
                throws IOException,
                       JsonProcessingException

  Throws:
    `IOException`
    `JsonProcessingException`

### readValue

    public <T> T readValue(URL src)
                throws IOException,
                       JsonProcessingException

  Method that binds content read from given input source, using configuration of this reader. Value return is either newly constructed, or root value that was specified with `withValueToUpdate(Object)`.

  Throws:
    `IOException`
    `JsonProcessingException`

### readValue

    public <T> T readValue(JsonNode src)
                throws IOException,
                       JsonProcessingException

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

         objectReader.readValue(src.traverse())

  Throws:
    `IOException`
    `JsonProcessingException`

### readTree

    public JsonNode readTree(InputStream in)
                      throws IOException,
                             JsonProcessingException

  Method that reads content from given input source, using configuration of this reader, and binds it as JSON Tree.

  Note that if an object was specified with a call to `withValueToUpdate(Object)` it will just be ignored; result is always a newly constructed `JsonNode` instance.

  Throws:
    `IOException`
    `JsonProcessingException`

### readTree

    public JsonNode readTree(Reader r)
                      throws IOException,
                             JsonProcessingException

  Method that reads content from given input source, using configuration of this reader, and binds it as JSON Tree.

  Note that if an object was specified with a call to `withValueToUpdate(Object)` it will just be ignored; result is always a newly constructed `JsonNode` instance.

  Throws:
    `IOException`
    `JsonProcessingException`

### readTree

    public JsonNode readTree(String json)
                      throws IOException,
                             JsonProcessingException

  Method that reads content from given JSON input String, using configuration of this reader, and binds it as JSON Tree.

  Note that if an object was specified with a call to `withValueToUpdate(Object)` it will just be ignored; result is always a newly constructed `JsonNode` instance.

  Throws:
    `IOException`
    `JsonProcessingException`

### readValues

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

  Method for reading sequence of Objects from parser stream.

  Sequence can be either root-level "unwrapped" sequence (without surrounding JSON array), or a sequence contained in a JSON Array. In either case `JsonParser` must point to the first token of the first element, OR not point to any token (in which case it is advanced to the next token). This means, specifically, that for wrapped sequences, parser MUST NOT point to the surrounding `START_ARRAY` but rather to the token following it.

  Throws:
    `IOException`
    `JsonProcessingException`

### readValues

    public <T> MappingIterator<T> readValues(InputStream src)
                                  throws IOException,
                                         JsonProcessingException

  Method for reading sequence of Objects from parser stream.

  Sequence can be either wrapped or unwrapped root-level sequence: wrapped means that the elements are enclosed in JSON Array; and unwrapped that elements are directly accessed at main level. Assumption is that iff the first token of the document is `START_ARRAY`, we have a wrapped sequence; otherwise unwrapped. For wrapped sequences, leading `START_ARRAY` is skipped, so that for both cases, underlying `JsonParser` will point to what is expected to be the first token of the first element.

  Note that the wrapped vs unwrapped logic means that it is NOT possible to use this method for reading an unwrapped sequence of elements written as JSON Arrays: to read such sequences, one has to use `readValues(JsonParser)`, making sure parser points to the first token of the first element (i.e. the second `START_ARRAY` which is part of the first element).

  Throws:
    `IOException`
    `JsonProcessingException`

### readValues

    public <T> MappingIterator<T> readValues(Reader src)
                                  throws IOException,
                                         JsonProcessingException

  Overloaded version of `readValue(InputStream)`.

  Throws:
    `IOException`
    `JsonProcessingException`

### readValues

    public <T> MappingIterator<T> readValues(String json)
                                  throws IOException,
                                         JsonProcessingException

  Overloaded version of `readValue(InputStream)`.

  Parameters:
    `json` - String that contains JSON content to parse
  Throws:
    `IOException`
    `JsonProcessingException`

### readValues

    public <T> MappingIterator<T> readValues(byte[] src,
                                             int offset,
                                             int length)
                                  throws IOException,
                                         JsonProcessingException

  Overloaded version of `readValue(InputStream)`.

  Throws:
    `IOException`
    `JsonProcessingException`

### readValues

    public final <T> MappingIterator<T> readValues(byte[] src)
                                        throws IOException,
                                               JsonProcessingException

  Overloaded version of `readValue(InputStream)`.

  Throws:
    `IOException`
    `JsonProcessingException`

### readValues

    public <T> MappingIterator<T> readValues(File src)
                                  throws IOException,
                                         JsonProcessingException

  Overloaded version of `readValue(InputStream)`.

  Throws:
    `IOException`
    `JsonProcessingException`

### readValues

    public <T> MappingIterator<T> readValues(URL src)
                                  throws IOException,
                                         JsonProcessingException

  Overloaded version of `readValue(InputStream)`.

  Parameters:
    `src` - URL to read to access JSON content to parse.
  Throws:
    `IOException`
    `JsonProcessingException`

### createArrayNode

    public JsonNode createArrayNode()

  Specified by:
    `createArrayNode` in class `ObjectCodec`

### createObjectNode

    public JsonNode createObjectNode()

  Specified by:
    `createObjectNode` in class `ObjectCodec`

### treeAsTokens

    public JsonParser treeAsTokens(TreeNode n)

  Specified by:
    `treeAsTokens` in class `ObjectCodec`

### treeToValue

    public <T> T treeToValue(TreeNode n,
                             Class<T> valueType)
                  throws JsonProcessingException

  Specified by:
    `treeToValue` in class `ObjectCodec`
  Throws:
    `JsonProcessingException`

### writeValue

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

  Specified by:
    `writeValue` in class `ObjectCodec`
  Throws:
    `IOException`
    `JsonProcessingException`

### _bind

    protected Object _bind(JsonParser jp,
                           Object valueToUpdate)
                    throws IOException,
                           JsonParseException,
                           JsonMappingException

  Actual implementation of value reading+binding operation.

  Throws:
    `IOException`
    `JsonParseException`
    `JsonMappingException`

### _bindAndClose

    protected Object _bindAndClose(JsonParser jp,
                                   Object valueToUpdate)
                            throws IOException,
                                   JsonParseException,
                                   JsonMappingException

  Throws:
    `IOException`
    `JsonParseException`
    `JsonMappingException`

### _bindAsTree

    protected JsonNode _bindAsTree(JsonParser jp)
                            throws IOException,
                                   JsonParseException,
                                   JsonMappingException

  Throws:
    `IOException`
    `JsonParseException`
    `JsonMappingException`

### _bindAndCloseAsTree

    protected JsonNode _bindAndCloseAsTree(JsonParser jp)
                                    throws IOException,
                                           JsonParseException,
                                           JsonMappingException

  Throws:
    `IOException`
    `JsonParseException`
    `JsonMappingException`

### _bindAndReadValues

    protected <T> MappingIterator<T> _bindAndReadValues(JsonParser p,
                                                        Object valueToUpdate)
                                             throws IOException,
                                                    JsonProcessingException

  Throws:
    `IOException`
    `JsonProcessingException`
  Since:
    2.1

### _initForReading

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

  Throws:
    `IOException`
    `JsonParseException`
    `JsonMappingException`

### _findRootDeserializer

    protected final JsonDeserializer<Object> _findRootDeserializer(DeserializationContext ctxt,
                                                                   JavaType valueType)
                                                            throws JsonMappingException

  Method called to locate deserializer for the passed root-level value.

  Throws:
    `JsonMappingException`

### _prefetchRootDeserializer

    protected final JsonDeserializer<Object> _prefetchRootDeserializer(DeserializationConfig config,
                                                                       JavaType valueType)

  Method called to locate deserializer ahead of time, if permitted by configuration. Method also is NOT to throw an exception if access fails.

### _unwrapAndDeserialize

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

  Throws:
    `IOException`
    `JsonParseException`
    `JsonMappingException`

### _detectBindAndClose

    protected Object _detectBindAndClose(byte[] src,
                                         int offset,
                                         int length)
                                  throws IOException

  Throws:
    `IOException`

### _detectBindAndClose

    protected Object _detectBindAndClose(DataFormatReaders.Match match,
                                         boolean forceClosing)
                                  throws IOException

  Throws:
    `IOException`

### _detectBindAndReadValues

    protected <T> MappingIterator<T> _detectBindAndReadValues(DataFormatReaders.Match match,
                                                              boolean forceClosing)
                                                   throws IOException,
                                                          JsonProcessingException

  Throws:
    `IOException`
    `JsonProcessingException`

### _detectBindAndCloseAsTree

    protected JsonNode _detectBindAndCloseAsTree(InputStream in)
                                          throws IOException

  Throws:
    `IOException`

### _reportUnkownFormat

    protected void _reportUnkownFormat(DataFormatReaders detector,
                                       DataFormatReaders.Match match)
                                throws JsonProcessingException

  Method called to indicate that format detection failed to detect format of given input

  Throws:
    `JsonProcessingException`

### createDeserializationContext

    protected final DefaultDeserializationContext createDeserializationContext(JsonParser jp,
                                                                               DeserializationConfig cfg)

  Internal helper method called to create an instance of `DeserializationContext` for deserializing a single root value. Can be overridden if a custom context is needed.

### _with

    protected ObjectReader _with(DeserializationConfig newConfig)

### _reportUndetectableSource

    protected void _reportUndetectableSource(Object src)
                                      throws JsonProcessingException

  Throws:
    `JsonProcessingException`

### _inputStream

    protected InputStream _inputStream(URL src)
                                throws IOException

  Throws:
    `IOException`

### _inputStream

    protected InputStream _inputStream(File f)
                                throws IOException

  Throws:
    `IOException`

Copyright © 2012 FasterXML. All Rights Reserved.