calabash-android 0.0.1

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

@@ -0,0 +1,326 @@
+package sh.calaba.org.codehaus.jackson.map.deser;
+
+import java.io.IOException;
+import java.text.DateFormat;
+import java.text.ParseException;
+import java.util.*;
+
+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.map.*;
+import sh.calaba.org.codehaus.jackson.map.exc.UnrecognizedPropertyException;
+import sh.calaba.org.codehaus.jackson.map.util.ArrayBuilders;
+import sh.calaba.org.codehaus.jackson.map.util.ClassUtil;
+import sh.calaba.org.codehaus.jackson.map.util.LinkedNode;
+import sh.calaba.org.codehaus.jackson.map.util.ObjectBuffer;
+import sh.calaba.org.codehaus.jackson.type.JavaType;
+
+/**
+ * Default implementation of {@link DeserializationContext}.
+ */
+public class StdDeserializationContext
+    extends DeserializationContext
+{
+    /**
+     * Let's limit length of error messages, for cases where underlying data
+     * may be very large -- no point in spamming logs with megs of meaningless
+     * data.
+     */
+    final static int MAX_ERROR_STR_LEN = 500;
+
+    // // // Configuration
+
+    /**
+     * Currently active parser used for deserialization.
+     * May be different from the outermost parser
+     * when content is buffered.
+     */
+    protected JsonParser _parser;
+
+    /**
+     * @since 1.5
+     */
+    protected final DeserializerProvider _deserProvider;
+
+    /**
+     * @since 1.9
+     */
+    protected final InjectableValues _injectableValues;
+    
+    // // // Helper object recycling
+
+    protected ArrayBuilders _arrayBuilders;
+
+    protected ObjectBuffer _objectBuffer;
+
+    protected DateFormat _dateFormat;
+
+    /*
+    /**********************************************************
+    /* Life-cycle
+    /**********************************************************
+     */
+
+    public StdDeserializationContext(DeserializationConfig config, JsonParser jp,
+            DeserializerProvider prov, InjectableValues injectableValues)
+    {
+    	super(config);
+        _parser = jp;
+        _deserProvider = prov;
+        _injectableValues = injectableValues;
+    }
+
+    /*
+    /**********************************************************
+    /* Public API, accessors
+    /**********************************************************
+     */
+
+    @Override
+    public DeserializerProvider getDeserializerProvider() {
+        return _deserProvider;
+    }
+
+    /**
+     * Method for accessing the currently active parser.
+     * May be different from the outermost parser
+     * when content is buffered.
+     *<p>
+     * Use of this method is discouraged: if code has direct access
+     * to the active parser, that should be used instead.
+     */
+    @Override
+    public JsonParser getParser() { return _parser; }
+
+    @Override
+    public Object findInjectableValue(Object valueId,
+            BeanProperty forProperty, Object beanInstance)
+    {
+        if (_injectableValues == null) {
+            throw new IllegalStateException("No 'injectableValues' configured, can not inject value with id ["+valueId+"]");
+        }
+        return _injectableValues.findInjectableValue(valueId, this, forProperty, beanInstance);
+    }
+    
+    /*
+    /**********************************************************
+    /* Public API, helper object recycling
+    /**********************************************************
+     */
+
+    @Override
+    public final ObjectBuffer leaseObjectBuffer()
+    {
+        ObjectBuffer buf = _objectBuffer;
+        if (buf == null) {
+            buf = new ObjectBuffer();
+        } else {
+            _objectBuffer = null;
+        }
+        return buf;
+    }
+
+    @Override
+    public final void returnObjectBuffer(ObjectBuffer buf)
+    {
+        /* Already have a reusable buffer? Let's retain bigger one
+         * (or if equal, favor newer one, shorter life-cycle)
+         */
+        if (_objectBuffer == null
+            || buf.initialCapacity() >= _objectBuffer.initialCapacity()) {
+            _objectBuffer = buf;
+        }
+    }
+
+    @Override
+    public final ArrayBuilders getArrayBuilders()
+    {
+        if (_arrayBuilders == null) {
+            _arrayBuilders = new ArrayBuilders();
+        }
+        return _arrayBuilders;
+    }
+
+    /*
+    /**********************************************************
+    /* Parsing methods that may use reusable/recyclable objects
+    /**********************************************************
+     */
+
+    @Override
+    public Date parseDate(String dateStr)
+        throws IllegalArgumentException
+    {
+        try {
+            return getDateFormat().parse(dateStr);
+        } catch (ParseException pex) {
+            throw new IllegalArgumentException(pex.getMessage());
+        }
+    }
+
+    @Override
+    public Calendar constructCalendar(Date d)
+    {
+        /* 08-Jan-2008, tatu: not optimal, but should work for the
+         *   most part; let's revise as needed.
+         */
+        Calendar c = Calendar.getInstance();
+        c.setTime(d);
+        return c;
+    }
+    /*
+    /**********************************************************
+    /* Public API, problem handling, reporting
+    /**********************************************************
+     */
+
+    /**
+     * Method deserializers can call to inform configured {@link DeserializationProblemHandler}s
+     * of an unrecognized property.
+     * 
+     * @since 1.5
+     */
+    @Override
+    public boolean handleUnknownProperty(JsonParser jp, JsonDeserializer<?> deser, Object instanceOrClass, String propName)
+        throws IOException, JsonProcessingException
+    {
+        LinkedNode<DeserializationProblemHandler> h = _config.getProblemHandlers();
+        if (h != null) {
+            /* 04-Jan-2009, tatu: Ugh. Need to mess with currently active parser
+             *   since parser is not explicitly passed to handler... that was a mistake
+             */
+            JsonParser oldParser = _parser;
+            _parser = jp;
+            try {
+                while (h != null) {
+                    // Can bail out if it's handled
+                    if (h.value().handleUnknownProperty(this, deser, instanceOrClass, propName)) {
+                        return true;
+                    }
+                    h = h.next();
+                }
+            } finally {
+                _parser = oldParser;
+            }
+        }
+        return false;
+    }
+
+    @Override
+    public JsonMappingException mappingException(Class<?> targetClass) {
+        return mappingException(targetClass, _parser.getCurrentToken());
+    }
+
+    @Override
+    public JsonMappingException mappingException(Class<?> targetClass, JsonToken token)
+    {
+        String clsName = _calcName(targetClass);
+        return JsonMappingException.from(_parser, "Can not deserialize instance of "+clsName+" out of "+token+" token");
+    }
+    
+    @Override
+    public JsonMappingException instantiationException(Class<?> instClass, Throwable t)
+    {
+        return JsonMappingException.from(_parser,
+                "Can not construct instance of "+instClass.getName()+", problem: "+t.getMessage(),
+                t);
+    }
+
+    @Override
+    public JsonMappingException instantiationException(Class<?> instClass, String msg)
+    {
+        return JsonMappingException.from(_parser, "Can not construct instance of "+instClass.getName()+", problem: "+msg);
+    }
+    
+    /**
+     * Method that will construct an exception suitable for throwing when
+     * some String values are acceptable, but the one encountered is not
+     */
+    @Override
+    public JsonMappingException weirdStringException(Class<?> instClass, String msg)
+    {
+        return JsonMappingException.from(_parser, "Can not construct instance of "+instClass.getName()+" from String value '"+_valueDesc()+"': "+msg);
+    }
+    
+    @Override
+    public JsonMappingException weirdNumberException(Class<?> instClass, String msg)
+    {
+        return JsonMappingException.from(_parser, "Can not construct instance of "+instClass.getName()+" from number value ("+_valueDesc()+"): "+msg);
+    }
+
+    @Override
+    public JsonMappingException weirdKeyException(Class<?> keyClass, String keyValue, String msg)
+    {
+        return JsonMappingException.from(_parser, "Can not construct Map key of type "+keyClass.getName()+" from String \""+_desc(keyValue)+"\": "+msg);
+    }
+
+    @Override
+    public JsonMappingException wrongTokenException(JsonParser jp, JsonToken expToken, String msg)
+    {
+        return JsonMappingException.from(jp, "Unexpected token ("+jp.getCurrentToken()+"), expected "+expToken+": "+msg);
+    }
+    
+    @Override
+    public JsonMappingException unknownFieldException(Object instanceOrClass, String fieldName)
+    {
+        return UnrecognizedPropertyException.from(_parser, instanceOrClass, fieldName);
+    }
+
+    @Override
+    public JsonMappingException unknownTypeException(JavaType type, String id)
+    {
+        return JsonMappingException.from(_parser, "Could not resolve type id '"+id+"' into a subtype of "+type);
+    }
+
+    /*
+    /**********************************************************
+    /* Overridable internal methods
+    /**********************************************************
+     */
+
+    protected DateFormat getDateFormat()
+    {
+        if (_dateFormat == null) {
+            // must create a clone since Formats are not thread-safe:
+            _dateFormat = (DateFormat)_config.getDateFormat().clone();
+        }
+        return _dateFormat;
+    }
+
+    protected String determineClassName(Object instance)
+    {
+        return ClassUtil.getClassDescription(instance);
+    }
+    
+    /*
+    /**********************************************************
+    /* Other internal methods
+    /**********************************************************
+     */
+
+    protected String _calcName(Class<?> cls)
+    {
+        if (cls.isArray()) {
+            return _calcName(cls.getComponentType())+"[]";
+        }
+        return cls.getName();
+    }
+    
+    protected String _valueDesc()
+    {
+        try {
+            return _desc(_parser.getText());
+        } catch (Exception e) {
+            return "[N/A]";
+        }
+    }
+    protected String _desc(String desc)
+    {
+        // !!! should we quote it? (in case there are control chars, linefeeds)
+        if (desc.length() > MAX_ERROR_STR_LEN) {
+            desc = desc.substring(0, MAX_ERROR_STR_LEN) + "]...[" + desc.substring(desc.length() - MAX_ERROR_STR_LEN);
+        }
+        return desc;
+    }
+}

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

@@ -0,0 +1,94 @@
+package sh.calaba.org.codehaus.jackson.map.deser;
+
+import java.io.IOException;
+
+import sh.calaba.org.codehaus.jackson.Base64Variants;
+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.map.DeserializationContext;
+import sh.calaba.org.codehaus.jackson.map.TypeDeserializer;
+import sh.calaba.org.codehaus.jackson.map.annotate.JacksonStdImpl;
+import sh.calaba.org.codehaus.jackson.map.deser.std.StdScalarDeserializer;
+import sh.calaba.org.codehaus.jackson.type.JavaType;
+
+/**
+ * @deprecated Since 1.9, use {@link sh.calaba.org.codehaus.jackson.map.deser.std.StdDeserializer} instead.
+ */
+@Deprecated
+public abstract class StdDeserializer<T>
+    extends sh.calaba.org.codehaus.jackson.map.deser.std.StdDeserializer<T>
+{
+    protected StdDeserializer(Class<?> vc) {
+        super(vc);
+    }
+
+    protected StdDeserializer(JavaType valueType) {
+        super(valueType);
+    }
+
+    /*
+    /**********************************************************
+    /* Deprecated inner classes
+    /**********************************************************
+     */
+
+    /**
+     * @deprecated Since 1.9 use {@link sh.calaba.org.codehaus.jackson.map.deser.std.ClassDeserializer} instead.
+     */
+    @Deprecated
+    @JacksonStdImpl
+    public class ClassDeserializer extends sh.calaba.org.codehaus.jackson.map.deser.std.ClassDeserializer { }
+
+    /**
+     * @deprecated Since 1.9 use {@link sh.calaba.org.codehaus.jackson.map.deser.std.CalendarDeserializer} instead.
+     */
+    @Deprecated
+    @JacksonStdImpl
+    public class CalendarDeserializer extends sh.calaba.org.codehaus.jackson.map.deser.std.CalendarDeserializer { }
+    
+    /**
+     * @deprecated Since 1.9 use {@link sh.calaba.org.codehaus.jackson.map.deser.std.StringDeserializer} instead.
+     */
+    @Deprecated
+    @JacksonStdImpl
+    public final static class StringDeserializer
+        extends StdScalarDeserializer<String>
+    {
+        public StringDeserializer() { super(String.class); }
+
+        @Override
+        public String deserialize(JsonParser jp, DeserializationContext ctxt)
+            throws IOException, JsonProcessingException
+        {
+            JsonToken curr = jp.getCurrentToken();
+            if (curr == JsonToken.VALUE_STRING) {
+                return jp.getText();
+            }
+            if (curr == JsonToken.VALUE_EMBEDDED_OBJECT) {
+                Object ob = jp.getEmbeddedObject();
+                if (ob == null) {
+                    return null;
+                }
+                if (ob instanceof byte[]) {
+                    return Base64Variants.getDefaultVariant().encode((byte[]) ob, false);
+                }
+                return ob.toString();
+            }
+            if (curr.isScalarValue()) {
+                return jp.getText();
+            }
+            throw ctxt.mappingException(_valueClass, curr);
+        }
+
+        @SuppressWarnings("deprecation")
+        @Override
+        public String deserializeWithType(JsonParser jp, DeserializationContext ctxt,
+                TypeDeserializer typeDeserializer)
+            throws IOException, JsonProcessingException
+        {
+            return deserialize(jp, ctxt);
+        }
+    }
+
+}

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

@@ -0,0 +1,494 @@
+package sh.calaba.org.codehaus.jackson.map.deser;
+
+import java.io.IOException;
+import java.util.HashMap;
+import java.util.concurrent.ConcurrentHashMap;
+
+import sh.calaba.org.codehaus.jackson.JsonNode;
+import sh.calaba.org.codehaus.jackson.JsonParser;
+import sh.calaba.org.codehaus.jackson.JsonProcessingException;
+import sh.calaba.org.codehaus.jackson.io.SerializedString;
+import sh.calaba.org.codehaus.jackson.map.AbstractTypeResolver;
+import sh.calaba.org.codehaus.jackson.map.AnnotationIntrospector;
+import sh.calaba.org.codehaus.jackson.map.BeanProperty;
+import sh.calaba.org.codehaus.jackson.map.ContextualDeserializer;
+import sh.calaba.org.codehaus.jackson.map.ContextualKeyDeserializer;
+import sh.calaba.org.codehaus.jackson.map.DeserializationConfig;
+import sh.calaba.org.codehaus.jackson.map.DeserializationContext;
+import sh.calaba.org.codehaus.jackson.map.DeserializerFactory;
+import sh.calaba.org.codehaus.jackson.map.DeserializerProvider;
+import sh.calaba.org.codehaus.jackson.map.Deserializers;
+import sh.calaba.org.codehaus.jackson.map.JsonDeserializer;
+import sh.calaba.org.codehaus.jackson.map.JsonMappingException;
+import sh.calaba.org.codehaus.jackson.map.KeyDeserializer;
+import sh.calaba.org.codehaus.jackson.map.KeyDeserializers;
+import sh.calaba.org.codehaus.jackson.map.ResolvableDeserializer;
+import sh.calaba.org.codehaus.jackson.map.TypeDeserializer;
+import sh.calaba.org.codehaus.jackson.map.introspect.AnnotatedClass;
+import sh.calaba.org.codehaus.jackson.map.type.ArrayType;
+import sh.calaba.org.codehaus.jackson.map.type.CollectionLikeType;
+import sh.calaba.org.codehaus.jackson.map.type.CollectionType;
+import sh.calaba.org.codehaus.jackson.map.type.MapLikeType;
+import sh.calaba.org.codehaus.jackson.map.type.MapType;
+import sh.calaba.org.codehaus.jackson.map.util.ClassUtil;
+import sh.calaba.org.codehaus.jackson.map.util.RootNameLookup;
+import sh.calaba.org.codehaus.jackson.type.JavaType;
+
+
+
+/**
+ * Default {@link DeserializerProvider} implementation.
+ * Handles low-level caching (non-root) aspects of deserializer
+ * handling; all construction details are delegated to configured
+ *  {@link DeserializerFactory} instance that the provider owns.
+ */
+public class StdDeserializerProvider
+    extends DeserializerProvider
+{
+    /*
+    /**********************************************************
+    /* Caching
+    /**********************************************************
+     */
+
+    /**
+     * We will also cache some dynamically constructed deserializers;
+     * specifically, ones that are expensive to construct.
+     * This currently means bean and Enum deserializers; array, List and Map
+     * deserializers will not be cached.
+     *<p>
+     * 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.
+     */
+    final protected ConcurrentHashMap<JavaType, JsonDeserializer<Object>> _cachedDeserializers
+        = new ConcurrentHashMap<JavaType, JsonDeserializer<Object>>(64, 0.75f, 2);
+
+    /**
+     * During deserializer construction process we may need to keep track of partially
+     * completed deserializers, to resolve cyclic dependencies. This is the
+     * map used for storing deserializers before they are fully complete.
+     */
+    final protected HashMap<JavaType, JsonDeserializer<Object>> _incompleteDeserializers
+        = new HashMap<JavaType, JsonDeserializer<Object>>(8);
+
+    final protected RootNameLookup _rootNames;
+    
+    /*
+    /**********************************************************
+    /* Configuration
+    /**********************************************************
+     */
+
+    /**
+     * Factory responsible for constructing actual deserializers, if not
+     * one of pre-configured types.
+     */
+    protected DeserializerFactory _factory;
+
+    /*
+    /**********************************************************
+    /* Life-cycle
+    /**********************************************************
+     */
+
+    /**
+     * Default constructor. Equivalent to calling
+     *<pre>
+     *   new StdDeserializerProvider(BeanDeserializerFactory.instance);
+     *</pre>
+     */
+    public StdDeserializerProvider() { this(BeanDeserializerFactory.instance); }
+
+    public StdDeserializerProvider(DeserializerFactory f) {
+        _factory = f;
+        _rootNames = new RootNameLookup();
+    }
+
+    @Override
+    public DeserializerProvider withAdditionalDeserializers(Deserializers d) {
+        return withFactory(_factory.withAdditionalDeserializers(d));
+    }
+
+    @Override
+    public DeserializerProvider withAdditionalKeyDeserializers(KeyDeserializers d) {
+        return withFactory(_factory.withAdditionalKeyDeserializers(d));
+    }
+    
+    @Override
+    public DeserializerProvider withDeserializerModifier(BeanDeserializerModifier modifier) {
+        return withFactory(_factory.withDeserializerModifier(modifier));
+    }
+
+    @Override
+    public DeserializerProvider withAbstractTypeResolver(AbstractTypeResolver resolver) {
+        return withFactory(_factory.withAbstractTypeResolver(resolver));
+    }
+
+    @Override
+    public DeserializerProvider withValueInstantiators(ValueInstantiators instantiators) {
+        return withFactory(_factory.withValueInstantiators(instantiators));
+    }
+
+    @Override
+    public StdDeserializerProvider withFactory(DeserializerFactory factory) {
+        // sanity-check to try to prevent hard-to-debug problems; sub-classes MUST override this method
+        if (this.getClass() != StdDeserializerProvider.class) {
+            throw new IllegalStateException("DeserializerProvider of type "
+                    +this.getClass().getName()+" does not override 'withFactory()' method");
+        }
+        return new StdDeserializerProvider(factory);
+    }
+    
+    /*
+    /**********************************************************
+    /* Abstract methods impls
+    /**********************************************************
+     */
+
+    @Override
+    public JavaType mapAbstractType(DeserializationConfig config, JavaType type)
+            throws JsonMappingException
+    {
+        return _factory.mapAbstractType(config, type);
+    }
+
+    @Override
+    public SerializedString findExpectedRootName(DeserializationConfig config, JavaType type)
+         throws JsonMappingException
+    {
+        return _rootNames.findRootName(type, config);
+    }
+    
+    @SuppressWarnings("unchecked")
+    @Override
+    public JsonDeserializer<Object> findValueDeserializer(DeserializationConfig config,
+            JavaType propertyType, BeanProperty property)
+        throws JsonMappingException
+    {
+        JsonDeserializer<Object> deser = _findCachedDeserializer(propertyType);
+        if (deser != null) {
+            // [JACKSON-385]: need to support contextualization:
+            if (deser instanceof ContextualDeserializer<?>) {
+                JsonDeserializer<?> d = ((ContextualDeserializer<?>) deser).createContextual(config, property);
+                deser = (JsonDeserializer<Object>) d;
+            }
+            return deser;
+        }
+        // If not, need to request factory to construct (or recycle)
+        deser = _createAndCacheValueDeserializer(config, propertyType, property);
+        if (deser == null) {
+            /* Should we let caller handle it? Let's have a helper method
+             * decide it; can throw an exception, or return a valid
+             * deserializer
+             */
+            deser = _handleUnknownValueDeserializer(propertyType);
+        }
+        // [JACKSON-385]: need to support contextualization:
+        if (deser instanceof ContextualDeserializer<?>) {
+            JsonDeserializer<?> d = ((ContextualDeserializer<?>) deser).createContextual(config, property);
+            deser = (JsonDeserializer<Object>) d;
+        }
+        return deser;
+    }
+    
+    @Override
+    public JsonDeserializer<Object> findTypedValueDeserializer(DeserializationConfig config,
+            JavaType type, BeanProperty property)
+        throws JsonMappingException
+    {
+        JsonDeserializer<Object> deser = findValueDeserializer(config, type, property);
+        TypeDeserializer typeDeser = _factory.findTypeDeserializer(config, type, property);
+        if (typeDeser != null) {
+            return new WrappedDeserializer(typeDeser, deser);
+        }
+        return deser;
+    }
+
+    @Override
+    public KeyDeserializer findKeyDeserializer(DeserializationConfig config,
+            JavaType type, BeanProperty property)
+        throws JsonMappingException
+    {
+        KeyDeserializer kd = _factory.createKeyDeserializer(config, type, property);
+        // One more thing: contextuality
+        if (kd instanceof ContextualKeyDeserializer) {
+            kd = ((ContextualKeyDeserializer) kd).createContextual(config, property);
+        }
+        if (kd == null) { // if none found, need to use a placeholder that'll fail
+            return _handleUnknownKeyDeserializer(type);
+        }
+        return kd;
+    }
+
+    /**
+     * Method that can be called to find out whether a deserializer can
+     * be found for given type
+     */
+    @Override
+    public boolean hasValueDeserializerFor(DeserializationConfig config, JavaType type)
+    {
+        /* Note: mostly copied from findValueDeserializer, except for
+         * handling of unknown types
+         */
+        JsonDeserializer<Object> deser = _findCachedDeserializer(type);
+        if (deser == null) {
+            try {
+                deser = _createAndCacheValueDeserializer(config, type, null);
+            } catch (Exception e) {
+                return false;
+            }
+        }
+        return (deser != null);
+    }
+
+    @Override
+    public int cachedDeserializersCount() {
+        return _cachedDeserializers.size();
+    }
+
+    /**
+     * Method that will drop all dynamically constructed deserializers (ones that
+     * are counted as result value for {@link #cachedDeserializersCount}).
+     * This can be used to remove memory usage (in case some deserializers are
+     * only used once or so), or to force re-construction of deserializers after
+     * configuration changes for mapper than owns the provider.
+     * 
+     * @since 1.4
+     */
+    @Override
+    public void flushCachedDeserializers() {
+        _cachedDeserializers.clear();       
+    }
+
+    /*
+    /**********************************************************
+    /* Overridable helper methods
+    /**********************************************************
+     */
+
+    protected JsonDeserializer<Object> _findCachedDeserializer(JavaType type)
+    {
+        if (type == null) {
+            throw new IllegalArgumentException();
+        }
+        return _cachedDeserializers.get(type);
+    }
+
+    /**
+     * Method that will try to create a deserializer for given type,
+     * and resolve and cache it if necessary
+     * 
+     * @param config Configuration
+     * @param type Type of property to deserializer
+     * @param property Property (field, setter, ctor arg) to use deserializer for
+     */
+    protected JsonDeserializer<Object>_createAndCacheValueDeserializer(DeserializationConfig config,
+            JavaType type, BeanProperty property)
+        throws JsonMappingException
+    {
+        /* Only one thread to construct deserializers at any given point in time;
+         * limitations necessary to ensure that only completely initialized ones
+         * are visible and used.
+         */
+        synchronized (_incompleteDeserializers) {
+            // Ok, then: could it be that due to a race condition, deserializer can now be found?
+            JsonDeserializer<Object> deser = _findCachedDeserializer(type);
+            if (deser != null) {
+                return deser;
+            }
+            int count = _incompleteDeserializers.size();
+            // Or perhaps being resolved right now?
+            if (count > 0) {
+                deser = _incompleteDeserializers.get(type);
+                if (deser != null) {
+                    return deser;
+                }
+            }
+            // Nope: need to create and possibly cache
+            try {
+                return _createAndCache2(config, type, property);
+            } finally {
+                // also: any deserializers that have been created are complete by now
+                if (count == 0 && _incompleteDeserializers.size() > 0) {
+                    _incompleteDeserializers.clear();
+                }
+            }
+        }
+    }
+
+    /**
+     * Method that handles actual construction (via factory) and caching (both
+     * intermediate and eventual)
+     */
+    protected JsonDeserializer<Object> _createAndCache2(DeserializationConfig config, JavaType type,
+            BeanProperty property)
+        throws JsonMappingException
+    {
+        JsonDeserializer<Object> deser;
+        try {
+            deser = _createDeserializer(config, type, property);
+        } catch (IllegalArgumentException iae) {
+            /* We better only expose checked exceptions, since those
+             * are what caller is expected to handle
+             */
+            throw new JsonMappingException(iae.getMessage(), null, iae);
+        }
+        if (deser == null) {
+            return null;
+        }
+        /* cache resulting deserializer? always true for "plain" BeanDeserializer
+         * (but can be re-defined for sub-classes by using @JsonCachable!)
+         */
+        // 08-Jun-2010, tatu: Related to [JACKSON-296], need to avoid caching MapSerializers... so:
+        boolean isResolvable = (deser instanceof ResolvableDeserializer);
+        boolean addToCache = (deser.getClass() == BeanDeserializer.class);
+        if (!addToCache) {
+            // 14-Feb-2011, tatu: As per [JACKSON-487], try fully blocking annotation access:
+            if (config.isEnabled(DeserializationConfig.Feature.USE_ANNOTATIONS)) {
+                AnnotationIntrospector aintr = config.getAnnotationIntrospector();
+                // note: pass 'null' to prevent mix-ins from being used
+                AnnotatedClass ac = AnnotatedClass.construct(deser.getClass(), aintr, null);
+                Boolean cacheAnn = aintr.findCachability(ac);
+                if (cacheAnn != null) {
+                    addToCache = cacheAnn.booleanValue();
+                }
+            }
+        }
+        /* we will temporarily hold on to all created deserializers (to
+         * handle cyclic references, and possibly reuse non-cached
+         * deserializers (list, map))
+         */
+        /* 07-Jun-2010, tatu: Danger: [JACKSON-296] was caused by accidental
+         *   resolution of a reference -- couple of ways to prevent this;
+         *   either not add Lists or Maps, or clear references eagerly.
+         *   Let's actually do both; since both seem reasonable.
+         */
+        /* Need to resolve? Mostly done for bean deserializers; required for
+         * resolving cyclic references.
+         */
+        if (isResolvable) {
+            _incompleteDeserializers.put(type, deser);
+            _resolveDeserializer(config, (ResolvableDeserializer)deser);
+            _incompleteDeserializers.remove(type);
+        }
+        if (addToCache) {
+            _cachedDeserializers.put(type, deser);
+        }
+        return deser;
+    }
+
+    /* Refactored so we can isolate the casts that require suppression
+     * of type-safety warnings.
+     */
+    @SuppressWarnings("unchecked")
+    protected JsonDeserializer<Object> _createDeserializer(DeserializationConfig config, 
+            JavaType type, BeanProperty property)
+        throws JsonMappingException
+    {
+        if (type.isEnumType()) {
+            return (JsonDeserializer<Object>) _factory.createEnumDeserializer(config, this, type, property);
+        }
+        if (type.isContainerType()) {
+            if (type.isArrayType()) {
+                return (JsonDeserializer<Object>)_factory.createArrayDeserializer(config, this,
+                        (ArrayType) type, property);
+            }
+            if (type.isMapLikeType()) {
+                MapLikeType mlt = (MapLikeType) type;
+                if (mlt.isTrueMapType()) {
+                    return (JsonDeserializer<Object>)_factory.createMapDeserializer(config, this,
+                            (MapType) mlt, property);
+                }
+                return (JsonDeserializer<Object>)_factory.createMapLikeDeserializer(config, this,
+                        mlt, property);
+            }
+            if (type.isCollectionLikeType()) {
+                CollectionLikeType clt = (CollectionLikeType) type;
+                if (clt.isTrueCollectionType()) {
+                    return (JsonDeserializer<Object>)_factory.createCollectionDeserializer(config, this,
+                            (CollectionType) clt, property);
+                }
+                return (JsonDeserializer<Object>)_factory.createCollectionLikeDeserializer(config, this,
+                        clt, property);
+            }
+        }
+
+        // 02-Mar-2009, tatu: Let's consider JsonNode to be a type of its own
+        if (JsonNode.class.isAssignableFrom(type.getRawClass())) {
+            return (JsonDeserializer<Object>)_factory.createTreeDeserializer(config, this, type, property);
+        }
+        return (JsonDeserializer<Object>)_factory.createBeanDeserializer(config, this, type, property);
+    }
+
+    protected void _resolveDeserializer(DeserializationConfig config, ResolvableDeserializer ser)
+        throws JsonMappingException
+    {
+        ser.resolve(config, this);
+    }
+
+    /*
+    /**********************************************************
+    /* Overridable error reporting methods
+    /**********************************************************
+     */
+
+    protected JsonDeserializer<Object> _handleUnknownValueDeserializer(JavaType type)
+        throws JsonMappingException
+    {
+        // Let's try to figure out the reason, to give better error
+        Class<?> rawClass = type.getRawClass();
+        if (!ClassUtil.isConcrete(rawClass)) {
+            throw new JsonMappingException("Can not find a Value deserializer for abstract type "+type);
+        }
+        throw new JsonMappingException("Can not find a Value deserializer for type "+type);
+    }
+
+    protected KeyDeserializer _handleUnknownKeyDeserializer(JavaType type)
+        throws JsonMappingException
+    {
+        throw new JsonMappingException("Can not find a (Map) Key deserializer for type "+type);
+    }
+
+    /*
+    /**********************************************************
+    /*  Helper classes
+    /**********************************************************
+     */
+
+    /**
+     * Simple deserializer that will call configured type deserializer, passing
+     * in configured data deserializer, and exposing it all as a simple
+     * deserializer.
+     */
+    protected final static class WrappedDeserializer
+        extends JsonDeserializer<Object>
+    {
+        final TypeDeserializer _typeDeserializer;
+        final JsonDeserializer<Object> _deserializer;
+
+        public WrappedDeserializer(TypeDeserializer typeDeser, JsonDeserializer<Object> deser)
+        {
+            super();
+            _typeDeserializer = typeDeser;
+            _deserializer = deser;
+        }
+
+        @Override
+        public Object deserialize(JsonParser jp, DeserializationContext ctxt)
+                throws IOException, JsonProcessingException
+        {
+            return _deserializer.deserializeWithType(jp, ctxt, _typeDeserializer);
+        }
+
+        @Override
+        public Object deserializeWithType(JsonParser jp, DeserializationContext ctxt,
+            TypeDeserializer typeDeserializer)
+                throws IOException, JsonProcessingException
+        {
+            // should never happen? (if it can, could call on that object)
+            throw new IllegalStateException("Type-wrapped deserializer's deserializeWithType should never get called");
+        }
+    }
+
+}