calabash-android 0.5.2 → 0.5.3

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

@@ -1,326 +0,0 @@
-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

@@ -1,94 +0,0 @@
-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

@@ -1,494 +0,0 @@
-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");
-        }
-    }
-
-}