calabash-android 0.0.1

data/test-server/instrumentation-backend/src/sh/calaba/org/codehaus/jackson/map/ObjectReader.java

@@ -0,0 +1,958 @@
+package sh.calaba.org.codehaus.jackson.map;
+
+import java.io.EOFException;
+import java.io.File;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.Reader;
+import java.net.URL;
+import java.util.Iterator;
+import java.util.concurrent.ConcurrentHashMap;
+
+import sh.calaba.org.codehaus.jackson.FormatSchema;
+import sh.calaba.org.codehaus.jackson.JsonFactory;
+import sh.calaba.org.codehaus.jackson.JsonGenerator;
+import sh.calaba.org.codehaus.jackson.JsonNode;
+import sh.calaba.org.codehaus.jackson.JsonParseException;
+import sh.calaba.org.codehaus.jackson.JsonParser;
+import sh.calaba.org.codehaus.jackson.JsonProcessingException;
+import sh.calaba.org.codehaus.jackson.JsonToken;
+import sh.calaba.org.codehaus.jackson.ObjectCodec;
+import sh.calaba.org.codehaus.jackson.Version;
+import sh.calaba.org.codehaus.jackson.Versioned;
+import sh.calaba.org.codehaus.jackson.io.SerializedString;
+import sh.calaba.org.codehaus.jackson.map.deser.StdDeserializationContext;
+import sh.calaba.org.codehaus.jackson.map.type.SimpleType;
+import sh.calaba.org.codehaus.jackson.node.JsonNodeFactory;
+import sh.calaba.org.codehaus.jackson.node.NullNode;
+import sh.calaba.org.codehaus.jackson.node.TreeTraversingParser;
+import sh.calaba.org.codehaus.jackson.type.JavaType;
+import sh.calaba.org.codehaus.jackson.type.TypeReference;
+import sh.calaba.org.codehaus.jackson.util.VersionUtil;
+
+/**
+ * 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 "fluid" (aka 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 {@link ObjectMapper} and can be
+ * reused.
+ * 
+ * @author tatu
+ * @since 1.6
+ */
+public class ObjectReader
+    extends ObjectCodec
+    implements Versioned
+{
+    private final static JavaType JSON_NODE_TYPE = SimpleType.constructUnsafe(JsonNode.class);
+
+    /*
+    /**********************************************************
+    /* Immutable configuration from ObjectMapper
+    /**********************************************************
+     */
+
+    /**
+     * General serialization configuration settings; while immutable,
+     * can use copy-constructor to create modified instances as necessary.
+     */
+    protected final DeserializationConfig _config;
+
+    /**
+     * Flag that indicates whether root values are expected to be unwrapped
+     * or not
+     * 
+     * @since 1.9
+     */
+    protected final boolean _unwrapRoot;
+    
+    /**
+     * Root-level cached deserializers
+     */
+    final protected ConcurrentHashMap<JavaType, JsonDeserializer<Object>> _rootDeserializers;
+   
+    protected final DeserializerProvider _provider;
+
+    /**
+     * Factory used for constructing {@link JsonGenerator}s
+     */
+    protected final JsonFactory _jsonFactory;
+    
+    /*
+    /**********************************************************
+    /* Configuration that can be changed during building
+    /**********************************************************
+     */   
+
+    /**
+     * 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 {@link #_valueToUpdate} is non-null, only used for
+     * locating deserializer.
+     */
+    protected final JavaType _valueType;
+
+    /**
+     * 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
+     * {@link sh.calaba.org.codehaus.jackson.map.type.ArrayType}; array
+     * types can not be modified because array size is immutable.
+     */
+    protected final Object _valueToUpdate;
+
+    /**
+     * When using data format that uses a schema, schema is passed
+     * to parser.
+     * 
+     * @since 1.8
+     */
+    protected final FormatSchema _schema;
+
+    /**
+     * Values that can be injected during deserialization, if any.
+     * 
+     * @since 1.9
+     */
+    protected final InjectableValues _injectableValues;
+    
+    /*
+    /**********************************************************
+    /* Life-cycle
+    /**********************************************************
+     */
+
+    /**
+     * Constructor used by {@link ObjectMapper} for initial instantiation
+     * 
+     * @since 1.8
+     */
+    protected ObjectReader(ObjectMapper mapper, DeserializationConfig config)
+    {
+        this(mapper, config, null, null, null, null);
+    }
+
+    protected ObjectReader(ObjectMapper mapper, DeserializationConfig config,
+            JavaType valueType, Object valueToUpdate, FormatSchema schema,
+            InjectableValues injectableValues)
+    {
+        _config = config;
+        _rootDeserializers = mapper._rootDeserializers;
+        _provider = mapper._deserializerProvider;
+        _jsonFactory = mapper._jsonFactory;
+        _valueType = valueType;
+        _valueToUpdate = valueToUpdate;
+        if (valueToUpdate != null && valueType.isArrayType()) {
+            throw new IllegalArgumentException("Can not update an array value");
+        }
+        _schema = schema;
+        _injectableValues = injectableValues;
+        _unwrapRoot = config.isEnabled(DeserializationConfig.Feature.UNWRAP_ROOT_VALUE);
+    }
+    
+    /**
+     * Copy constructor used for building variations.
+     */
+    protected ObjectReader(ObjectReader base, DeserializationConfig config,
+            JavaType valueType, Object valueToUpdate, FormatSchema schema,
+            InjectableValues injectableValues)
+    {
+        _config = config;
+
+        _rootDeserializers = base._rootDeserializers;
+        _provider = base._provider;
+        _jsonFactory = base._jsonFactory;
+
+        _valueType = valueType;
+        _valueToUpdate = valueToUpdate;
+        if (valueToUpdate != null && valueType.isArrayType()) {
+            throw new IllegalArgumentException("Can not update an array value");
+        }
+        _schema = schema;
+        _injectableValues = injectableValues;
+        _unwrapRoot = config.isEnabled(DeserializationConfig.Feature.UNWRAP_ROOT_VALUE);
+    }
+
+    /**
+     * Method that will return version information stored in and read from jar
+     * that contains this class.
+     * 
+     * @since 1.6
+     */
+    @Override
+    public Version version() {
+        return VersionUtil.versionFor(getClass());
+    }
+
+    /**
+     * Method for constructing a new reader instance that is configured
+     * to data bind into specified type.
+     *<p>
+     * Note that the method does NOT change state of this reader, but
+     * rather construct and returns a newly configured instance.
+     */
+    public ObjectReader withType(JavaType valueType)
+    {
+        if (valueType == _valueType) return this;
+        // type is stored here, no need to make a copy of config
+        return new ObjectReader(this, _config, valueType, _valueToUpdate,
+                _schema, _injectableValues);
+    }    
+
+    /**
+     * Method for constructing a new reader instance that is configured
+     * to data bind into specified type.
+     *<p>
+     * Note that the method does NOT change state of this reader, but
+     * rather construct and returns a newly configured instance.
+     */
+    public ObjectReader withType(Class<?> valueType)
+    {
+        return withType(_config.constructType(valueType));
+    }    
+
+    /**
+     * Method for constructing a new reader instance that is configured
+     * to data bind into specified type.
+     *<p>
+     * Note that the method does NOT change state of this reader, but
+     * rather construct and returns a newly configured instance.
+     */
+    public ObjectReader withType(java.lang.reflect.Type valueType)
+    {
+        return withType(_config.getTypeFactory().constructType(valueType));
+    }    
+
+    /**
+     * Method for constructing a new reader instance that is configured
+     * to data bind into specified type.
+     *<p>
+     * Note that the method does NOT change state of this reader, but
+     * rather construct and returns a newly configured instance.
+     * 
+     * @since 1.8
+     */
+    public ObjectReader withType(TypeReference<?> valueTypeRef)
+    {
+        return withType(_config.getTypeFactory().constructType(valueTypeRef.getType()));
+    }    
+    
+    /**
+     * Method for constructing a new reader instance with configuration that uses
+     * passed {@link JsonNodeFactory} for constructing {@link JsonNode}
+     * instances.
+     *<p>
+     * Note that the method does NOT change state of this reader, but
+     * rather construct and returns a newly configured instance.
+     */
+    public ObjectReader withNodeFactory(JsonNodeFactory f)
+    {
+        // node factory is stored within config, so need to copy that first
+        if (f == _config.getNodeFactory()) return this;
+        return new ObjectReader(this, _config.withNodeFactory(f), _valueType, _valueToUpdate,
+                _schema, _injectableValues);
+    }
+
+    /**
+     * Method for constructing a new instance with configuration that
+     * updates passed Object (as root value), instead of constructing 
+     * a new value.
+     *<p>
+     * Note that the method does NOT change state of this reader, but
+     * rather construct and returns a newly configured instance.
+     */
+    public ObjectReader withValueToUpdate(Object value)
+    {
+        if (value == _valueToUpdate) return this;
+        if (value == null) {
+            throw new IllegalArgumentException("cat not update null value");
+        }
+        JavaType t = (_valueType == null) ? _config.constructType(value.getClass()) : _valueType;
+        return new ObjectReader(this, _config, t, value,
+                _schema, _injectableValues);
+    }    
+
+    /**
+     * Method for constructing a new instance with configuration that
+     * passes specified {@link FormatSchema} to {@link JsonParser} that
+     * is constructed for parsing content.
+     *<p>
+     * Note that the method does NOT change state of this reader, but
+     * rather construct and returns a newly configured instance.
+     * 
+     * @since 1.8
+     */
+    public ObjectReader withSchema(FormatSchema schema)
+    {
+        if (_schema == schema) {
+            return this;
+        }
+        return new ObjectReader(this, _config, _valueType, _valueToUpdate,
+                schema, _injectableValues);
+    }
+
+    /**
+     * Method for constructing a new instance with configuration that uses
+     * passed {@link InjectableValues} to provide injectable values.
+     *<p>
+     * Note that the method does NOT change state of this reader, but
+     * rather construct and returns a newly configured instance.
+     * 
+     * @since 1.9
+     */
+    public ObjectReader withInjectableValues(InjectableValues injectableValues)
+    {
+        if (_injectableValues == injectableValues) {
+            return this;
+        }
+        return new ObjectReader(this, _config, _valueType, _valueToUpdate,
+                _schema, injectableValues);
+    }
+    
+    /*
+    /**********************************************************
+    /* Deserialization methods; basic ones to support ObjectCodec first
+    /* (ones that take JsonParser)
+    /**********************************************************
+     */
+
+    /**
+     * 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 {@link #withValueToUpdate(Object)}.
+     */
+    @SuppressWarnings("unchecked")
+    public <T> T readValue(JsonParser jp)
+        throws IOException, JsonProcessingException
+    {
+        return (T) _bind(jp);
+    }
+
+    /**
+     * 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 {@link #withValueToUpdate(Object)}.
+     */
+    @SuppressWarnings("unchecked")
+    @Override
+    public <T> T readValue(JsonParser jp, Class<T> valueType)
+        throws IOException, JsonProcessingException
+    {
+        return (T) withType(valueType).readValue(jp);
+    }
+
+    /**
+     * 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 {@link #withValueToUpdate(Object)}.
+     */
+    @SuppressWarnings("unchecked")
+    @Override
+    public <T> T readValue(JsonParser jp, TypeReference<?> valueTypeRef)
+        throws IOException, JsonProcessingException
+    {
+        return (T) withType(valueTypeRef).readValue(jp);
+    }
+
+    /**
+     * 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 {@link #withValueToUpdate(Object)}.
+     */
+    @SuppressWarnings("unchecked")
+    @Override
+    public <T> T readValue(JsonParser jp, JavaType valueType) throws IOException, JsonProcessingException {
+        return (T) withType(valueType).readValue(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.
+     *<p>
+     * Note: if an object was specified with {@link #withValueToUpdate}, it
+     * will be ignored.
+     */
+    @Override
+    public JsonNode readTree(JsonParser jp)
+        throws IOException, JsonProcessingException
+    {
+        return _bindAsTree(jp);
+    }
+
+    /**
+     * Convenience method that is equivalent to:
+     *<pre>
+     *   withType(valueType).readValues(jp);
+     *</pre>
+     */
+    @Override
+    public <T> Iterator<T> readValues(JsonParser jp, Class<T> valueType)
+        throws IOException, JsonProcessingException {
+        return withType(valueType).readValues(jp);
+    }
+
+    /**
+     * Convenience method that is equivalent to:
+     *<pre>
+     *   withType(valueTypeRef).readValues(jp);
+     *</pre>
+     */
+    @Override
+    public <T> Iterator<T> readValues(JsonParser jp, TypeReference<?> valueTypeRef)
+        throws IOException, JsonProcessingException {
+        return withType(valueTypeRef).readValues(jp);
+    }
+    
+    /**
+     * Convenience method that is equivalent to:
+     *<pre>
+     *   withType(valueType).readValues(jp);
+     *</pre>
+     */
+    @Override
+    public <T> Iterator<T> readValues(JsonParser jp, JavaType valueType)
+        throws IOException, JsonProcessingException {
+        return withType(valueType).readValues(jp);
+    }
+    
+    /*
+    /**********************************************************
+    /* Deserialization methods; others similar to what ObjectMapper has
+    /**********************************************************
+     */
+
+    /**
+     * 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 {@link #withValueToUpdate(Object)}.
+     */
+    @SuppressWarnings("unchecked")
+    public <T> T readValue(InputStream src)
+        throws IOException, JsonProcessingException
+    {
+        return (T) _bindAndClose(_jsonFactory.createJsonParser(src));
+    }
+
+    /**
+     * 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 {@link #withValueToUpdate(Object)}.
+     */
+    @SuppressWarnings("unchecked")
+    public <T> T readValue(Reader src)
+        throws IOException, JsonProcessingException
+    {
+        return (T) _bindAndClose(_jsonFactory.createJsonParser(src));
+    }
+
+    /**
+     * 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 {@link #withValueToUpdate(Object)}.
+     */
+    @SuppressWarnings("unchecked")
+    public <T> T readValue(String src)
+        throws IOException, JsonProcessingException
+    {
+        return (T) _bindAndClose(_jsonFactory.createJsonParser(src));
+    }
+
+    /**
+     * 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 {@link #withValueToUpdate(Object)}.
+     */
+    @SuppressWarnings("unchecked")
+    public <T> T readValue(byte[] src)
+        throws IOException, JsonProcessingException
+    {
+        return (T) _bindAndClose(_jsonFactory.createJsonParser(src));
+    }
+
+    /**
+     * 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 {@link #withValueToUpdate(Object)}.
+     */
+    @SuppressWarnings("unchecked")
+    public <T> T readValue(byte[] src, int offset, int length)
+        throws IOException, JsonProcessingException
+    {
+        return (T) _bindAndClose(_jsonFactory.createJsonParser(src, offset, length));
+    }
+    
+    @SuppressWarnings("unchecked")
+    public <T> T readValue(File src)
+        throws IOException, JsonProcessingException
+    {
+        return (T) _bindAndClose(_jsonFactory.createJsonParser(src));
+    }
+
+    /**
+     * 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 {@link #withValueToUpdate(Object)}.
+     */
+    @SuppressWarnings("unchecked")
+    public <T> T readValue(URL src)
+        throws IOException, JsonProcessingException
+    {
+        return (T) _bindAndClose(_jsonFactory.createJsonParser(src));
+    }
+
+    /**
+     * Convenience method for converting results from given JSON tree into given
+     * value type. Basically short-cut for:
+     *<pre>
+     *   objectReader.readValue(src.traverse())
+     *</pre>
+     */
+    @SuppressWarnings("unchecked")
+    public <T> T readValue(JsonNode src)
+        throws IOException, JsonProcessingException
+    {
+        return (T) _bindAndClose(treeAsTokens(src));
+    }
+    
+    /**
+     * Method that reads content from given input source,
+     * using configuration of this reader, and binds it as JSON Tree.
+     *<p>
+     * Note that if an object was specified with a call to
+     * {@link #withValueToUpdate(Object)}
+     * it will just be ignored; result is always a newly constructed
+     * {@link JsonNode} instance.
+     */
+    public JsonNode readTree(InputStream in)
+        throws IOException, JsonProcessingException
+    {
+        return _bindAndCloseAsTree(_jsonFactory.createJsonParser(in));
+    }
+    
+    /**
+     * Method that reads content from given input source,
+     * using configuration of this reader, and binds it as JSON Tree.
+     *<p>
+     * Note that if an object was specified with a call to
+     * {@link #withValueToUpdate(Object)}
+     * it will just be ignored; result is always a newly constructed
+     * {@link JsonNode} instance.
+     */
+    public JsonNode readTree(Reader r)
+        throws IOException, JsonProcessingException
+    {
+        return _bindAndCloseAsTree(_jsonFactory.createJsonParser(r));
+    }
+
+    /**
+     * Method that reads content from given JSON input String,
+     * using configuration of this reader, and binds it as JSON Tree.
+     *<p>
+     * Note that if an object was specified with a call to
+     * {@link #withValueToUpdate(Object)}
+     * it will just be ignored; result is always a newly constructed
+     * {@link JsonNode} instance.
+     */
+    public JsonNode readTree(String content)
+        throws IOException, JsonProcessingException
+    {
+        return _bindAndCloseAsTree(_jsonFactory.createJsonParser(content));
+    }
+
+    /*
+    /**********************************************************
+    /* Deserialization methods; reading sequence of values
+    /**********************************************************
+     */
+    
+    /**
+     * Method for reading sequence of Objects from parser stream.
+     * 
+     * @since 1.8
+     */
+    public <T> MappingIterator<T> readValues(JsonParser jp)
+        throws IOException, JsonProcessingException
+    {
+        DeserializationContext ctxt = _createDeserializationContext(jp, _config);
+        // false -> do not close as caller gave parser instance
+        return new MappingIterator<T>(_valueType, jp, ctxt,
+                _findRootDeserializer(_config, _valueType),
+                false, _valueToUpdate);
+    }
+    
+    /**
+     * Method for reading sequence of Objects from parser stream.
+     * 
+     * @since 1.8
+     */
+    public <T> MappingIterator<T> readValues(InputStream src)
+        throws IOException, JsonProcessingException
+    {
+        JsonParser jp = _jsonFactory.createJsonParser(src);
+        if (_schema != null) {
+            jp.setSchema(_schema);
+        }
+        DeserializationContext ctxt = _createDeserializationContext(jp, _config);
+        return new MappingIterator<T>(_valueType, jp, ctxt, 
+                _findRootDeserializer(_config, _valueType),
+                true, _valueToUpdate);
+    }
+
+    /**
+     * Method for reading sequence of Objects from parser stream.
+     * 
+     * @since 1.8
+     */
+    public <T> MappingIterator<T> readValues(Reader src)
+        throws IOException, JsonProcessingException
+    {
+        JsonParser jp = _jsonFactory.createJsonParser(src);
+        if (_schema != null) {
+            jp.setSchema(_schema);
+        }
+        DeserializationContext ctxt = _createDeserializationContext(jp, _config);
+        return new MappingIterator<T>(_valueType, jp, ctxt,
+                _findRootDeserializer(_config, _valueType), true, _valueToUpdate);
+    }
+    
+    /**
+     * Method for reading sequence of Objects from parser stream.
+     * 
+     * @since 1.8
+     */
+    public <T> MappingIterator<T> readValues(String json)
+        throws IOException, JsonProcessingException
+    {
+        JsonParser jp = _jsonFactory.createJsonParser(json);
+        if (_schema != null) {
+            jp.setSchema(_schema);
+        }
+        DeserializationContext ctxt = _createDeserializationContext(jp, _config);
+        return new MappingIterator<T>(_valueType, jp, ctxt,
+                _findRootDeserializer(_config, _valueType), true, _valueToUpdate);
+    }
+
+    /**
+     * Method for reading sequence of Objects from parser stream.
+     * 
+     * @since 1.8
+     */
+    public <T> MappingIterator<T> readValues(byte[] src, int offset, int length)
+        throws IOException, JsonProcessingException
+    {
+        JsonParser jp = _jsonFactory.createJsonParser(src, offset, length);
+        if (_schema != null) {
+            jp.setSchema(_schema);
+        }
+        DeserializationContext ctxt = _createDeserializationContext(jp, _config);
+        return new MappingIterator<T>(_valueType, jp, ctxt,
+                _findRootDeserializer(_config, _valueType), true, _valueToUpdate);
+    }
+
+    /**
+     * Since 1.9.3
+     */
+    public final <T> MappingIterator<T> readValues(byte[] src)
+            throws IOException, JsonProcessingException {
+        return readValues(src, 0, src.length);
+    }
+    
+    /**
+     * Method for reading sequence of Objects from parser stream.
+     * 
+     * @since 1.8
+     */
+    public <T> MappingIterator<T> readValues(File src)
+        throws IOException, JsonProcessingException
+    {
+        JsonParser jp = _jsonFactory.createJsonParser(src);
+        if (_schema != null) {
+            jp.setSchema(_schema);
+        }
+        DeserializationContext ctxt = _createDeserializationContext(jp, _config);
+        return new MappingIterator<T>(_valueType, jp, ctxt,
+                _findRootDeserializer(_config, _valueType), true, _valueToUpdate);
+    }
+
+    /**
+     * Method for reading sequence of Objects from parser stream.
+     * 
+     * @since 1.8
+     */
+    public <T> MappingIterator<T> readValues(URL src)
+        throws IOException, JsonProcessingException
+    {
+        JsonParser jp = _jsonFactory.createJsonParser(src);
+        if (_schema != null) {
+            jp.setSchema(_schema);
+        }
+        DeserializationContext ctxt = _createDeserializationContext(jp, _config);
+        return new MappingIterator<T>(_valueType, jp, ctxt,
+                _findRootDeserializer(_config, _valueType), true, _valueToUpdate);
+    }
+    
+    /*
+    /**********************************************************
+    /* Helper methods
+    /**********************************************************
+     */
+
+    /**
+     * Actual implementation of value reading+binding operation.
+     */
+    protected Object _bind(JsonParser jp)
+        throws IOException, JsonParseException, JsonMappingException
+    {
+        /* First: may need to read the next token, to initialize state (either
+         * before first read from parser, or after previous token has been cleared)
+         */
+        Object result;
+        JsonToken t = _initForReading(jp);
+        if (t == JsonToken.VALUE_NULL) {
+            if (_valueToUpdate == null) {
+                result = _findRootDeserializer(_config, _valueType).getNullValue();
+            } else {
+                result = _valueToUpdate;
+            }
+        } else if (t == JsonToken.END_ARRAY || t == JsonToken.END_OBJECT) {
+            result = _valueToUpdate;
+        } else { // pointing to event other than null
+            DeserializationContext ctxt = _createDeserializationContext(jp, _config);
+            JsonDeserializer<Object> deser = _findRootDeserializer(_config, _valueType);
+            if (_unwrapRoot) {
+                result = _unwrapAndDeserialize(jp, ctxt, _valueType, deser);
+            } else {
+                if (_valueToUpdate == null) {
+                    result = deser.deserialize(jp, ctxt);
+                } else {
+                    deser.deserialize(jp, ctxt, _valueToUpdate);
+                    result = _valueToUpdate;
+                }
+            }
+        }
+        // Need to consume the token too
+        jp.clearCurrentToken();
+        return result;
+    }
+    
+    protected Object _bindAndClose(JsonParser jp)
+        throws IOException, JsonParseException, JsonMappingException
+    {
+        if (_schema != null) {
+            jp.setSchema(_schema);
+        }
+        try {
+            Object result;
+            JsonToken t = _initForReading(jp);
+            if (t == JsonToken.VALUE_NULL) {
+                if (_valueToUpdate == null) {
+                    result = _findRootDeserializer(_config, _valueType).getNullValue();
+                } else {
+                    result = _valueToUpdate;
+                }
+            } else if (t == JsonToken.END_ARRAY || t == JsonToken.END_OBJECT) {
+                result = _valueToUpdate;
+            } else {
+                DeserializationContext ctxt = _createDeserializationContext(jp, _config);
+                JsonDeserializer<Object> deser = _findRootDeserializer(_config, _valueType);
+                if (_unwrapRoot) {
+                    result = _unwrapAndDeserialize(jp, ctxt, _valueType, deser);
+                } else {
+                    if (_valueToUpdate == null) {
+                        result = deser.deserialize(jp, ctxt);
+                    } else {
+                        deser.deserialize(jp, ctxt, _valueToUpdate);
+                        result = _valueToUpdate;                    
+                    }
+                }
+            }
+            return result;
+        } finally {
+            try {
+                jp.close();
+            } catch (IOException ioe) { }
+        }
+    }
+
+    protected JsonNode _bindAsTree(JsonParser jp)
+        throws IOException, JsonParseException, JsonMappingException
+    {
+        JsonNode result;
+        JsonToken t = _initForReading(jp);
+        if (t == JsonToken.VALUE_NULL || t == JsonToken.END_ARRAY || t == JsonToken.END_OBJECT) {
+            result = NullNode.instance;
+        } else {
+            DeserializationContext ctxt = _createDeserializationContext(jp, _config);
+            JsonDeserializer<Object> deser = _findRootDeserializer(_config, JSON_NODE_TYPE);
+            if (_unwrapRoot) {
+                result = (JsonNode) _unwrapAndDeserialize(jp, ctxt, JSON_NODE_TYPE, deser);
+            } else {
+                result = (JsonNode) deser.deserialize(jp, ctxt);
+            }
+        }
+        // Need to consume the token too
+        jp.clearCurrentToken();
+        return result;
+    }
+    
+    protected JsonNode _bindAndCloseAsTree(JsonParser jp)
+        throws IOException, JsonParseException, JsonMappingException
+    {
+        if (_schema != null) {
+            jp.setSchema(_schema);
+        }
+        try {
+            return _bindAsTree(jp);
+        } finally {
+            try {
+                jp.close();
+            } catch (IOException ioe) { }
+        }
+    }
+    
+    protected static JsonToken _initForReading(JsonParser jp)
+        throws IOException, JsonParseException, JsonMappingException
+    {
+        /* First: must point to a token; if not pointing to one, advance.
+         * This occurs before first read from JsonParser, as well as
+         * after clearing of current token.
+         */
+        JsonToken t = jp.getCurrentToken();
+        if (t == null) { // and then we must get something...
+            t = jp.nextToken();
+            if (t == null) { // [JACKSON-99] Should throw EOFException?
+                throw new EOFException("No content to map to Object due to end of input");
+            }
+        }
+        return t;
+    }
+
+    /**
+     * Method called to locate deserializer for the passed root-level value.
+     */
+    protected JsonDeserializer<Object> _findRootDeserializer(DeserializationConfig cfg, JavaType valueType)
+        throws JsonMappingException
+    {
+        // Sanity check: must have actual type...
+        if (valueType == null) {
+            throw new JsonMappingException("No value type configured for ObjectReader");
+        }
+        
+        // First: have we already seen it?
+        JsonDeserializer<Object> deser = _rootDeserializers.get(valueType);
+        if (deser != null) {
+            return deser;
+        }
+
+        // Nope: need to ask provider to resolve it
+        deser = _provider.findTypedValueDeserializer(cfg, valueType, null);
+        if (deser == null) { // can this happen?
+            throw new JsonMappingException("Can not find a deserializer for type "+valueType);
+        }
+        _rootDeserializers.put(valueType, deser);
+        return deser;
+    }
+    
+    protected DeserializationContext _createDeserializationContext(JsonParser jp, DeserializationConfig cfg) {
+        // 04-Jan-2010, tatu: we do actually need the provider too... (for polymorphic deser)
+        return new StdDeserializationContext(cfg, jp, _provider, _injectableValues);
+    }
+
+    protected Object _unwrapAndDeserialize(JsonParser jp, DeserializationContext ctxt,
+            JavaType rootType, JsonDeserializer<Object> deser)
+        throws IOException, JsonParseException, JsonMappingException
+    {
+        SerializedString rootName = _provider.findExpectedRootName(ctxt.getConfig(), rootType);
+        if (jp.getCurrentToken() != JsonToken.START_OBJECT) {
+            throw JsonMappingException.from(jp, "Current token not START_OBJECT (needed to unwrap root name '"
+                    +rootName+"'), but "+jp.getCurrentToken());
+        }
+        if (jp.nextToken() != JsonToken.FIELD_NAME) {
+            throw JsonMappingException.from(jp, "Current token not FIELD_NAME (to contain expected root name '"
+                    +rootName+"'), but "+jp.getCurrentToken());
+        }
+        String actualName = jp.getCurrentName();
+        if (!rootName.getValue().equals(actualName)) {
+            throw JsonMappingException.from(jp, "Root name '"+actualName+"' does not match expected ('"+rootName
+                    +"') for type "+rootType);
+        }
+        // ok, then move to value itself....
+        jp.nextToken();
+        Object result;
+        if (_valueToUpdate == null) {
+            result = deser.deserialize(jp, ctxt);
+        } else {
+            deser.deserialize(jp, ctxt, _valueToUpdate);
+            result = _valueToUpdate;                    
+        }
+        // and last, verify that we now get matching END_OBJECT
+        if (jp.nextToken() != JsonToken.END_OBJECT) {
+            throw JsonMappingException.from(jp, "Current token not END_OBJECT (to match wrapper object with root name '"
+                    +rootName+"'), but "+jp.getCurrentToken());
+        }
+        return result;
+    }
+    
+    /*
+    /**********************************************************
+    /* Implementation of rest of ObjectCodec methods
+    /**********************************************************
+     */
+    
+    @Override
+    public JsonNode createArrayNode() {
+        return _config.getNodeFactory().arrayNode();
+    }
+
+    @Override
+    public JsonNode createObjectNode() {
+        return _config.getNodeFactory().objectNode();
+    }
+
+    @Override
+    public JsonParser treeAsTokens(JsonNode n) {
+        return new TreeTraversingParser(n, this);
+    }
+
+    @Override
+    public <T> T treeToValue(JsonNode n, Class<T> valueType)
+            throws IOException, JsonProcessingException
+    {
+        return readValue(treeAsTokens(n), valueType);
+    }
+
+    /**
+     * NOTE: NOT implemented for {@link ObjectReader}.
+     */
+    @Override
+    public void writeTree(JsonGenerator jgen, JsonNode rootNode) throws IOException, JsonProcessingException
+    {
+        throw new UnsupportedOperationException("Not implemented for ObjectReader");
+    }
+
+    @Override
+    public void writeValue(JsonGenerator jgen, Object value) throws IOException, JsonProcessingException
+    {
+        throw new UnsupportedOperationException("Not implemented for ObjectReader");
+    }
+}