calabash-android 0.0.1

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

@@ -0,0 +1,277 @@
+package sh.calaba.org.codehaus.jackson.map.deser;
+
+import java.util.*;
+
+import sh.calaba.org.codehaus.jackson.map.*;
+import sh.calaba.org.codehaus.jackson.map.deser.impl.BeanPropertyMap;
+import sh.calaba.org.codehaus.jackson.map.deser.impl.ValueInjector;
+import sh.calaba.org.codehaus.jackson.map.introspect.AnnotatedMember;
+import sh.calaba.org.codehaus.jackson.map.introspect.BasicBeanDescription;
+import sh.calaba.org.codehaus.jackson.map.util.Annotations;
+import sh.calaba.org.codehaus.jackson.type.JavaType;
+
+/**
+ * Builder class used for aggregating deserialization information about
+ * a POJO, in order to build a {@link JsonDeserializer} for deserializing
+ * intances.
+ * 
+ * @since 1.7
+ */
+public class BeanDeserializerBuilder
+{
+    /*
+    /**********************************************************
+    /* General information about POJO
+    /**********************************************************
+     */
+
+    final protected BasicBeanDescription _beanDesc;
+    
+    /*
+    /**********************************************************
+    /* Accumulated information about properties
+    /**********************************************************
+     */
+    
+    /**
+     * Properties to deserialize collected so far.
+     *<p>
+     * Note: since 1.9.1, LinkedHashMap has been used, since preservation
+     * of order is actually important for some use cases.
+     */
+    final protected HashMap<String, SettableBeanProperty> _properties = new LinkedHashMap<String, SettableBeanProperty>();
+
+    /**
+     * Value injectors for deserialization
+     * 
+     * @since 1.9
+     */
+    protected List<ValueInjector> _injectables;
+    
+    /**
+     * Back-reference properties this bean contains (if any)
+     */
+    protected HashMap<String, SettableBeanProperty> _backRefProperties;
+
+    /**
+     * Set of names of properties that are recognized but are to be ignored for deserialization
+     * purposes (meaning no exception is thrown, value is just skipped).
+     */
+    protected HashSet<String> _ignorableProps;
+    
+    /**
+     * Object that will handle value instantiation for the bean type.
+     * 
+     * @since 1.9
+     */
+    protected ValueInstantiator _valueInstantiator;
+
+    /**
+     * Fallback setter used for handling any properties that are not
+     * mapped to regular setters. If setter is not null, it will be
+     * called once for each such property.
+     */
+    protected SettableAnyProperty _anySetter;
+
+    /**
+     * Flag that can be set to ignore and skip unknown properties.
+     * If set, will not throw an exception for unknown properties.
+     */
+    protected boolean _ignoreAllUnknown;
+    
+    /*
+    /**********************************************************
+    /* Life-cycle: construction
+    /**********************************************************
+     */
+    
+    public BeanDeserializerBuilder(BasicBeanDescription beanDesc)
+    { 
+        _beanDesc = beanDesc;
+    }
+
+    /**
+     * Copy constructor for sub-classes to use, when constructing
+     * custom builder instances
+     * 
+     * @since 1.9
+     */
+    protected BeanDeserializerBuilder(BeanDeserializerBuilder src)
+    {
+        _beanDesc = src._beanDesc;
+        _anySetter = src._anySetter;
+        _ignoreAllUnknown = src._ignoreAllUnknown;
+
+        // let's make copy of properties
+        _properties.putAll(src._properties);
+        _backRefProperties = _copy(src._backRefProperties);
+        // Hmmh. Should we create defensive copies here? For now, not yet
+        _ignorableProps = src._ignorableProps;
+        _valueInstantiator = src._valueInstantiator;
+    }
+
+    private static HashMap<String, SettableBeanProperty> _copy(HashMap<String, SettableBeanProperty> src)
+    {
+        if (src == null) {
+            return null;
+        }
+        return new HashMap<String, SettableBeanProperty>(src);
+    }
+    
+    /*
+    /**********************************************************
+    /* Life-cycle: state modification (adders, setters)
+    /**********************************************************
+     */
+
+    /**
+     * Method for adding a new property or replacing a property.
+     */
+    public void addOrReplaceProperty(SettableBeanProperty prop, boolean allowOverride)
+    {
+        _properties.put(prop.getName(), prop);
+    }
+
+    /**
+     * Method to add a property setter. Will ensure that there is no
+     * unexpected override; if one is found will throw a
+     * {@link IllegalArgumentException}.
+     */
+    public void addProperty(SettableBeanProperty prop)
+    {
+        SettableBeanProperty old =  _properties.put(prop.getName(), prop);
+        if (old != null && old != prop) { // should never occur...
+            throw new IllegalArgumentException("Duplicate property '"+prop.getName()+"' for "+_beanDesc.getType());
+        }
+    }
+
+    /**
+     * Method called to add a property that represents so-called back reference;
+     * reference that "points back" to object that has forward reference to
+     * currently built bean.
+     */
+    public void  addBackReferenceProperty(String referenceName, SettableBeanProperty prop)
+    {
+        if (_backRefProperties == null) {
+            _backRefProperties = new HashMap<String, SettableBeanProperty>(4);
+        }
+        _backRefProperties.put(referenceName, prop);
+        // also: if we had property with same name, actually remove it
+        if (_properties != null) {
+            _properties.remove(prop.getName());
+        }
+    }
+
+    /**
+     * @since 1.9
+     */
+    public void addInjectable(String propertyName, JavaType propertyType,
+            Annotations contextAnnotations, AnnotatedMember member,
+            Object valueId)
+    {
+        if (_injectables == null) {
+            _injectables = new ArrayList<ValueInjector>();
+        }
+        _injectables.add(new ValueInjector(propertyName, propertyType,
+                contextAnnotations, member, valueId));
+    }
+    
+    /**
+     * Method that will add property name as one of properties that can
+     * be ignored if not recognized.
+     */
+    public void addIgnorable(String propName)
+    {
+        if (_ignorableProps == null) {
+            _ignorableProps = new HashSet<String>();
+        }
+        _ignorableProps.add(propName);
+    }
+
+    /**
+     * Method called by deserializer factory, when a "creator property"
+     * (something that is passed via constructor- or factory method argument;
+     * instead of setter or field).
+     *<p>
+     * Default implementation does not do anything; we may need to revisit this
+     * decision if these properties need to be available through accessors.
+     * For now, however, we just have to ensure that we don't try to resolve
+     * types that masked setter/field has (see [JACKSON-700] for details).
+     * 
+     * @since 1.9.2
+     */
+    public void addCreatorProperty(BeanPropertyDefinition propDef)
+    {
+        // do nothing
+    }
+    
+    public void setAnySetter(SettableAnyProperty s)
+    {
+        if (_anySetter != null && s != null) {
+            throw new IllegalStateException("_anySetter already set to non-null");
+        }
+        _anySetter = s;
+    }
+
+    public void setIgnoreUnknownProperties(boolean ignore) {
+        _ignoreAllUnknown = ignore;
+    }
+
+    /**
+     * @since 1.9
+     */
+    public void setValueInstantiator(ValueInstantiator inst) {
+        _valueInstantiator = inst;
+    }
+    
+    /*
+    /**********************************************************
+    /* Public accessors
+    /**********************************************************
+     */
+    
+    /**
+     * Method that allows accessing all properties that this
+     * builder currently contains.
+     *<p>
+     * Note that properties are returned in order that properties
+     * are ordered (explictly, or by rule), which is the serialization
+     * order.
+     * 
+     * @since 1.8.3
+     */
+    public Iterator<SettableBeanProperty> getProperties() {
+        return _properties.values().iterator();
+    }
+    
+    public boolean hasProperty(String propertyName) {
+        return _properties.containsKey(propertyName);
+    }
+    
+    public SettableBeanProperty removeProperty(String name)
+    {
+        return _properties.remove(name);
+    }
+
+    /**
+     * @since 1.9
+     */
+    public ValueInstantiator getValueInstantiator() {
+        return _valueInstantiator;
+    }
+    
+    /*
+    /**********************************************************
+    /* Build method(s)
+    /**********************************************************
+     */
+
+    public JsonDeserializer<?> build(BeanProperty forProperty)
+    {
+        BeanPropertyMap propertyMap = new BeanPropertyMap(_properties.values());
+        propertyMap.assignIndexes();
+        return new BeanDeserializer(_beanDesc, forProperty,
+                _valueInstantiator, propertyMap, _backRefProperties, _ignorableProps, _ignoreAllUnknown,
+                _anySetter, _injectables);
+    }
+}

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

@@ -0,0 +1,1474 @@
+package sh.calaba.org.codehaus.jackson.map.deser;
+
+import java.util.*;
+
+import sh.calaba.org.codehaus.jackson.JsonNode;
+import sh.calaba.org.codehaus.jackson.map.*;
+import sh.calaba.org.codehaus.jackson.map.deser.impl.CreatorCollector;
+import sh.calaba.org.codehaus.jackson.map.deser.impl.CreatorProperty;
+import sh.calaba.org.codehaus.jackson.map.deser.std.StdKeyDeserializers;
+import sh.calaba.org.codehaus.jackson.map.deser.std.ThrowableDeserializer;
+import sh.calaba.org.codehaus.jackson.map.introspect.*;
+import sh.calaba.org.codehaus.jackson.map.type.*;
+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.EnumResolver;
+import sh.calaba.org.codehaus.jackson.type.JavaType;
+
+/**
+ * Concrete deserializer factory class that adds full Bean deserializer
+ * construction logic using class introspection.
+ *<p>
+ * Since there is no caching, this factory is stateless and a globally
+ * shared singleton instance ({@link #instance}) can be  used by
+ * {@link DeserializerProvider}s).
+ */
+public class BeanDeserializerFactory
+    extends BasicDeserializerFactory
+{
+    /**
+     * Signature of <b>Throwable.initCause</b> method.
+     */
+    private final static Class<?>[] INIT_CAUSE_PARAMS = new Class<?>[] { Throwable.class };
+
+    /*
+    /**********************************************************
+    /* Config class implementation
+    /**********************************************************
+     */
+    
+    /**
+     * Standard configuration settings container class implementation.
+     * 
+     * @since 1.7
+     */
+    public static class ConfigImpl extends Config
+    {
+        protected final static KeyDeserializers[] NO_KEY_DESERIALIZERS = new KeyDeserializers[0];
+        protected final static BeanDeserializerModifier[] NO_MODIFIERS = new BeanDeserializerModifier[0];
+        protected final static AbstractTypeResolver[] NO_ABSTRACT_TYPE_RESOLVERS = new AbstractTypeResolver[0];
+        protected final static ValueInstantiators[] NO_VALUE_INSTANTIATORS = new ValueInstantiators[0];
+        
+        /**
+         * List of providers for additional deserializers, checked before considering default
+         * basic or bean deserializers.
+         * 
+         * @since 1.7
+         */
+        protected final Deserializers[] _additionalDeserializers;
+
+        /**
+         * List of providers for additional key deserializers, checked before considering
+         * standard key deserializers.
+         * 
+         * @since 1.7
+         */
+        protected final KeyDeserializers[] _additionalKeyDeserializers;
+        
+        /**
+         * List of modifiers that can change the way {@link BeanDeserializer} instances
+         * are configured and constructed.
+         */
+        protected final BeanDeserializerModifier[] _modifiers;
+
+        /**
+         * List of objects that may be able to resolve abstract types to
+         * concrete types. Used by functionality like "mr Bean" to materialize
+         * types as needed.
+         * 
+         * @since 1.8
+         */
+        protected final AbstractTypeResolver[] _abstractTypeResolvers;
+
+        /**
+         * List of objects that know how to create instances of POJO types;
+         * possibly using custom construction (non-annoted constructors; factory
+         * methods external to value type etc).
+         * Used to support objects that are created using non-standard methods;
+         * or to support post-constructor functionality.
+         * 
+         * @since 1.9
+         */
+        protected final ValueInstantiators[] _valueInstantiators;
+        
+        /**
+         * Constructor for creating basic configuration with no additional
+         * handlers.
+         */
+        public ConfigImpl() {
+            this(null, null, null, null, null);
+        }
+
+        /**
+         * Copy-constructor that will create an instance that contains defined
+         * set of additional deserializer providers.
+         */
+        protected ConfigImpl(Deserializers[] allAdditionalDeserializers,
+                KeyDeserializers[] allAdditionalKeyDeserializers,
+                BeanDeserializerModifier[] modifiers,
+                AbstractTypeResolver[] atr,
+                ValueInstantiators[] vi)
+        {
+            _additionalDeserializers = (allAdditionalDeserializers == null) ?
+                    NO_DESERIALIZERS : allAdditionalDeserializers;
+            _additionalKeyDeserializers = (allAdditionalKeyDeserializers == null) ?
+                    NO_KEY_DESERIALIZERS : allAdditionalKeyDeserializers;
+            _modifiers = (modifiers == null) ? NO_MODIFIERS : modifiers;
+            _abstractTypeResolvers = (atr == null) ? NO_ABSTRACT_TYPE_RESOLVERS : atr;
+            _valueInstantiators = (vi == null) ? NO_VALUE_INSTANTIATORS : vi;
+        }
+
+        @Override
+        public Config withAdditionalDeserializers(Deserializers additional)
+        {
+            if (additional == null) {
+                throw new IllegalArgumentException("Can not pass null Deserializers");
+            }
+            Deserializers[] all = ArrayBuilders.insertInListNoDup(_additionalDeserializers, additional);
+            return new ConfigImpl(all, _additionalKeyDeserializers, _modifiers,
+                    _abstractTypeResolvers, _valueInstantiators);
+        }
+
+        @Override
+        public Config withAdditionalKeyDeserializers(KeyDeserializers additional)
+        {
+            if (additional == null) {
+                throw new IllegalArgumentException("Can not pass null KeyDeserializers");
+            }
+            KeyDeserializers[] all = ArrayBuilders.insertInListNoDup(_additionalKeyDeserializers, additional);
+            return new ConfigImpl(_additionalDeserializers, all, _modifiers,
+                    _abstractTypeResolvers, _valueInstantiators);
+        }
+        
+        @Override
+        public Config withDeserializerModifier(BeanDeserializerModifier modifier)
+        {
+            if (modifier == null) {
+                throw new IllegalArgumentException("Can not pass null modifier");
+            }
+            BeanDeserializerModifier[] all = ArrayBuilders.insertInListNoDup(_modifiers, modifier);
+            return new ConfigImpl(_additionalDeserializers, _additionalKeyDeserializers, all,
+                    _abstractTypeResolvers, _valueInstantiators);
+        }
+
+        @Override
+        public Config withAbstractTypeResolver(AbstractTypeResolver resolver)
+        {
+            if (resolver == null) {
+                throw new IllegalArgumentException("Can not pass null resolver");
+            }
+            AbstractTypeResolver[] all = ArrayBuilders.insertInListNoDup(_abstractTypeResolvers, resolver);
+            return new ConfigImpl(_additionalDeserializers, _additionalKeyDeserializers, _modifiers,
+                    all, _valueInstantiators);
+        }
+
+        @Override
+        public Config withValueInstantiators(ValueInstantiators instantiators) 
+        {
+            if (instantiators == null) {
+                throw new IllegalArgumentException("Can not pass null resolver");
+            }
+            ValueInstantiators[] all = ArrayBuilders.insertInListNoDup(_valueInstantiators, instantiators);
+            return new ConfigImpl(_additionalDeserializers, _additionalKeyDeserializers, _modifiers,
+                    _abstractTypeResolvers, all);
+        }
+        
+        @Override
+        public boolean hasDeserializers() { return _additionalDeserializers.length > 0; }
+
+        @Override
+        public boolean hasKeyDeserializers() { return _additionalKeyDeserializers.length > 0; }
+        
+        @Override
+        public boolean hasDeserializerModifiers() { return _modifiers.length > 0; }
+
+        @Override
+        public boolean hasAbstractTypeResolvers() { return _abstractTypeResolvers.length > 0; }
+
+        @Override
+        public boolean hasValueInstantiators() { return _valueInstantiators.length > 0; }
+        
+        @Override
+        public Iterable<Deserializers> deserializers() {
+            return ArrayBuilders.arrayAsIterable(_additionalDeserializers);
+        }
+
+        @Override
+        public Iterable<KeyDeserializers> keyDeserializers() {
+            return ArrayBuilders.arrayAsIterable(_additionalKeyDeserializers);
+        }
+        
+        @Override
+        public Iterable<BeanDeserializerModifier> deserializerModifiers() {
+            return ArrayBuilders.arrayAsIterable(_modifiers);
+        }
+
+        @Override
+        public Iterable<AbstractTypeResolver> abstractTypeResolvers() {
+            return ArrayBuilders.arrayAsIterable(_abstractTypeResolvers);
+        }
+
+        @Override
+        public Iterable<ValueInstantiators> valueInstantiators() {
+            return ArrayBuilders.arrayAsIterable(_valueInstantiators);
+        }
+    }
+    
+    /*
+    /**********************************************************
+    /* Life-cycle
+    /**********************************************************
+     */
+    
+    /**
+     * Globally shareable thread-safe instance which has no additional custom deserializers
+     * registered
+     */
+    public final static BeanDeserializerFactory instance = new BeanDeserializerFactory(null);
+
+    /**
+     * Configuration settings for this factory; immutable instance (just like this
+     * factory), new version created via copy-constructor (fluent-style)
+     * 
+     * @since 1.7
+     */
+    protected final Config _factoryConfig;
+
+    @Deprecated
+    public BeanDeserializerFactory() {
+        this(null);
+    }
+
+    /**
+     * @since 1.7
+     */
+    public BeanDeserializerFactory(DeserializerFactory.Config config) {
+        if (config == null) {
+            config = new ConfigImpl();
+        }
+        _factoryConfig = config;
+    }
+
+    @Override
+    public final Config getConfig() {
+        return _factoryConfig;
+    }
+    
+    /**
+     * Method used by module registration functionality, to construct a new bean
+     * deserializer factory
+     * with different configuration settings.
+     * 
+     * @since 1.7
+     */
+    @Override
+    public DeserializerFactory withConfig(DeserializerFactory.Config config)
+    {
+        if (_factoryConfig == config) {
+            return this;
+        }
+
+        /* 22-Nov-2010, tatu: Handling of subtypes is tricky if we do immutable-with-copy-ctor;
+         *    and we pretty much have to here either choose between losing subtype instance
+         *    when registering additional deserializers, or losing deserializers.
+         *    Instead, let's actually just throw an error if this method is called when subtype
+         *    has not properly overridden this method; this to indicate problem as soon as possible.
+         */
+        if (getClass() != BeanDeserializerFactory.class) {
+            throw new IllegalStateException("Subtype of BeanDeserializerFactory ("+getClass().getName()
+                    +") has not properly overridden method 'withAdditionalDeserializers': can not instantiate subtype with "
+                    +"additional deserializer definitions");
+        }
+        return new BeanDeserializerFactory(config);
+    }
+    
+    /*
+    /**********************************************************
+    /* Overrides for super-class methods used for finding
+    /* custom deserializers
+    /**********************************************************
+     */
+
+    @Override
+    public KeyDeserializer createKeyDeserializer(DeserializationConfig config, JavaType type,
+            BeanProperty property)
+        throws JsonMappingException
+    {
+        // First: possible custom deserializers
+        if (_factoryConfig.hasKeyDeserializers()) {
+            BasicBeanDescription beanDesc = config.introspectClassAnnotations(type.getRawClass());
+            for (KeyDeserializers d  : _factoryConfig.keyDeserializers()) {
+                KeyDeserializer deser = d.findKeyDeserializer(type, config, beanDesc, property);
+                if (deser != null) {
+                    return deser;
+                }
+            }
+        }
+        // and if none found, standard ones:
+        // No serializer needed if it's plain old String, or Object/untyped
+        Class<?> raw = type.getRawClass();
+        if (raw == String.class || raw == Object.class) {
+            return StdKeyDeserializers.constructStringKeyDeserializer(config, type);
+        }
+        // Most other keys are of limited number of static types
+        KeyDeserializer kdes = _keyDeserializers.get(type);
+        if (kdes != null) {
+            return kdes;
+        }
+        // And then other one-offs; first, Enum:
+        if (type.isEnumType()) {
+            return _createEnumKeyDeserializer(config, type, property);
+        }
+        // One more thing: can we find ctor(String) or valueOf(String)?
+        kdes = StdKeyDeserializers.findStringBasedKeyDeserializer(config, type);
+        return kdes;
+    }
+
+    private KeyDeserializer _createEnumKeyDeserializer(DeserializationConfig config, JavaType type,
+            BeanProperty property)
+        throws JsonMappingException
+    {
+        BasicBeanDescription beanDesc = config.introspect(type);
+        Class<?> enumClass = type.getRawClass();
+        EnumResolver<?> enumRes = constructEnumResolver(enumClass, config);
+        // [JACKSON-193] May have @JsonCreator for static factory method:
+        for (AnnotatedMethod factory : beanDesc.getFactoryMethods()) {
+            if (config.getAnnotationIntrospector().hasCreatorAnnotation(factory)) {
+                int argCount = factory.getParameterCount();
+                if (argCount == 1) {
+                    Class<?> returnType = factory.getRawType();
+                    // usually should be class, but may be just plain Enum<?> (for Enum.valueOf()?)
+                    if (returnType.isAssignableFrom(enumClass)) {
+                        // note: mostly copied from 'EnumDeserializer.deserializerForCreator(...)'
+                        if (factory.getParameterType(0) != String.class) {
+                            throw new IllegalArgumentException("Parameter #0 type for factory method ("+factory+") not suitable, must be java.lang.String");
+                        }
+                        if (config.canOverrideAccessModifiers()) {
+                            ClassUtil.checkAndFixAccess(factory.getMember());
+                        }
+                        return StdKeyDeserializers.constructEnumKeyDeserializer(enumRes, factory);
+                    }
+                }
+                throw new IllegalArgumentException("Unsuitable method ("+factory+") decorated with @JsonCreator (for Enum type "
+                        +enumClass.getName()+")");
+            }
+        }
+        // [JACKSON-749] Also, need to consider @JsonValue, if one found
+        return StdKeyDeserializers.constructEnumKeyDeserializer(enumRes);
+    }
+    
+    @Override
+    protected JsonDeserializer<?> _findCustomArrayDeserializer(ArrayType type, DeserializationConfig config,
+            DeserializerProvider provider,
+            BeanProperty property,
+            TypeDeserializer elementTypeDeserializer, JsonDeserializer<?> elementDeserializer)
+        throws JsonMappingException
+    {
+        for (Deserializers d  : _factoryConfig.deserializers()) {
+            JsonDeserializer<?> deser = d.findArrayDeserializer(type, config, provider, property,
+                        elementTypeDeserializer, elementDeserializer);
+            if (deser != null) {
+                return deser;
+            }
+        }
+        return null;
+    }
+
+    @Override
+    protected JsonDeserializer<?> _findCustomCollectionDeserializer(CollectionType type, DeserializationConfig config,
+            DeserializerProvider provider, BasicBeanDescription beanDesc,
+            BeanProperty property,
+            TypeDeserializer elementTypeDeserializer, JsonDeserializer<?> elementDeserializer)
+        throws JsonMappingException
+    {
+        for (Deserializers d  : _factoryConfig.deserializers()) {
+            JsonDeserializer<?> deser = d.findCollectionDeserializer(type, config, provider, beanDesc, property,
+                    elementTypeDeserializer, elementDeserializer);
+            if (deser != null) {
+                return deser;
+            }
+        }
+        return null;
+    }
+
+    @Override
+    protected JsonDeserializer<?> _findCustomCollectionLikeDeserializer(CollectionLikeType type, DeserializationConfig config,
+            DeserializerProvider provider, BasicBeanDescription beanDesc,
+            BeanProperty property,
+            TypeDeserializer elementTypeDeserializer, JsonDeserializer<?> elementDeserializer)
+        throws JsonMappingException
+    {
+        for (Deserializers d  : _factoryConfig.deserializers()) {
+            JsonDeserializer<?> deser = d.findCollectionLikeDeserializer(type, config, provider, beanDesc, property,
+                    elementTypeDeserializer, elementDeserializer);
+            if (deser != null) {
+                return deser;
+            }
+        }
+        return null;
+    }
+    
+    @Override
+    protected JsonDeserializer<?> _findCustomEnumDeserializer(Class<?> type, DeserializationConfig config,
+            BasicBeanDescription beanDesc, BeanProperty property)
+        throws JsonMappingException
+    {
+        for (Deserializers d  : _factoryConfig.deserializers()) {
+            JsonDeserializer<?> deser = d.findEnumDeserializer(type, config, beanDesc, property);
+            if (deser != null) {
+                return deser;
+            }
+        }
+        return null;
+    }
+
+    @Override
+    protected JsonDeserializer<?> _findCustomMapDeserializer(MapType type,
+            DeserializationConfig config,
+            DeserializerProvider provider, BasicBeanDescription beanDesc, BeanProperty property,
+            KeyDeserializer keyDeserializer,
+            TypeDeserializer elementTypeDeserializer, JsonDeserializer<?> elementDeserializer)
+        throws JsonMappingException
+    {
+        for (Deserializers d  : _factoryConfig.deserializers()) {
+            JsonDeserializer<?> deser = d.findMapDeserializer(type, config, provider, beanDesc, property,
+                    keyDeserializer, elementTypeDeserializer, elementDeserializer);
+            if (deser != null) {
+                return deser;
+            }
+        }
+        return null;
+    }
+
+    @Override
+    protected JsonDeserializer<?> _findCustomMapLikeDeserializer(MapLikeType type,
+            DeserializationConfig config,
+            DeserializerProvider provider, BasicBeanDescription beanDesc, BeanProperty property,
+            KeyDeserializer keyDeserializer,
+            TypeDeserializer elementTypeDeserializer, JsonDeserializer<?> elementDeserializer)
+        throws JsonMappingException
+    {
+        for (Deserializers d  : _factoryConfig.deserializers()) {
+            JsonDeserializer<?> deser = d.findMapLikeDeserializer(type, config, provider, beanDesc, property,
+                    keyDeserializer, elementTypeDeserializer, elementDeserializer);
+            if (deser != null) {
+                return deser;
+            }
+        }
+        return null;
+    }
+    
+    @Override
+    protected JsonDeserializer<?> _findCustomTreeNodeDeserializer(Class<? extends JsonNode> type,
+            DeserializationConfig config, BeanProperty property)
+        throws JsonMappingException
+    {
+        for (Deserializers d  : _factoryConfig.deserializers()) {
+            JsonDeserializer<?> deser = d.findTreeNodeDeserializer(type, config, property);
+            if (deser != null) {
+                return deser;
+            }
+        }
+        return null;
+    }
+
+    // Note: NOT overriding, superclass has no matching method
+    @SuppressWarnings("unchecked")
+    protected JsonDeserializer<Object> _findCustomBeanDeserializer(JavaType type, DeserializationConfig config,
+            DeserializerProvider provider, BasicBeanDescription beanDesc, BeanProperty property)
+        throws JsonMappingException
+    {
+        for (Deserializers d  : _factoryConfig.deserializers()) {
+            JsonDeserializer<?> deser = d.findBeanDeserializer(type, config, provider, beanDesc, property);
+            if (deser != null) {
+                return (JsonDeserializer<Object>) deser;
+            }
+        }
+        return null;
+    }
+    
+    /*
+    /**********************************************************
+    /* DeserializerFactory API implementation
+    /**********************************************************
+     */
+
+    /**
+     * Method that will find complete abstract type mapping for specified type, doing as
+     * many resolution steps as necessary.
+     */
+    @Override
+    public JavaType mapAbstractType(DeserializationConfig config, JavaType type)
+        throws JsonMappingException
+    {
+        while (true) {
+            JavaType next = _mapAbstractType2(config, type);
+            if (next == null) {
+                return type;
+            }
+            /* Should not have to worry about cycles; but better verify since they will invariably
+             * occur... :-)
+             * (also: guard against invalid resolution to a non-related type)
+             */
+            Class<?> prevCls = type.getRawClass();
+            Class<?> nextCls = next.getRawClass();
+            if ((prevCls == nextCls) || !prevCls.isAssignableFrom(nextCls)) {
+                throw new IllegalArgumentException("Invalid abstract type resolution from "+type+" to "+next+": latter is not a subtype of former");
+            }
+            type = next;
+        }
+    }
+    
+    /**
+     * Value instantiator is created both based on creator annotations,
+     * and on optional externally provided instantiators (registered through
+     * module interface).
+     */
+    @Override
+    public ValueInstantiator findValueInstantiator(DeserializationConfig config,
+            BasicBeanDescription beanDesc)
+        throws JsonMappingException
+    {
+        ValueInstantiator instantiator;
+        // [JACKSON-633] Check @JsonValueInstantiator before anything else
+        AnnotatedClass ac = beanDesc.getClassInfo();
+        Object instDef = config.getAnnotationIntrospector().findValueInstantiator(ac);
+        if (instDef != null) {
+            if (instDef instanceof ValueInstantiator) {
+                instantiator = (ValueInstantiator) instDef;
+            } else {
+                if (!(instDef instanceof Class<?>)) { // sanity check
+                    throw new IllegalStateException("Invalid value instantiator returned for type "+beanDesc+": neither a Class nor ValueInstantiator");
+                }
+                Class<?> cls = (Class<?>) instDef;
+                if (!ValueInstantiator.class.isAssignableFrom(cls)) {
+                    throw new IllegalStateException("Invalid instantiator Class<?> returned for type "+beanDesc+": "
+                            +cls.getName()+" not a ValueInstantiator");
+                }
+                @SuppressWarnings("unchecked")
+                Class<? extends ValueInstantiator> instClass = (Class<? extends ValueInstantiator>) cls;
+                instantiator = config.valueInstantiatorInstance(ac, (Class<? extends ValueInstantiator>)instClass);
+            }
+        } else {
+            instantiator = constructDefaultValueInstantiator(config, beanDesc);
+        }
+        
+        // finally: anyone want to modify ValueInstantiator?
+        if (_factoryConfig.hasValueInstantiators()) {
+            for (ValueInstantiators insts : _factoryConfig.valueInstantiators()) {
+                instantiator = insts.findValueInstantiator(config, beanDesc, instantiator);
+                // let's do sanity check; easier to spot buggy handlers
+                if (instantiator == null) {
+                    throw new JsonMappingException("Broken registered ValueInstantiators (of type "
+                            +insts.getClass().getName()+"): returned null ValueInstantiator");
+                }
+            }
+        }
+        
+        return instantiator;
+    }
+
+    /**
+     * Method that {@link DeserializerProvider}s call to create a new
+     * deserializer for types other than Collections, Maps, arrays and
+     * enums.
+     */
+    @Override
+    public JsonDeserializer<Object> createBeanDeserializer(DeserializationConfig config,
+            DeserializerProvider p, JavaType type, BeanProperty property)
+        throws JsonMappingException
+    {
+        // First things first: abstract types may use defaulting:
+        if (type.isAbstract()) {
+            type = mapAbstractType(config, type);
+        }
+        
+        // First things first: maybe explicit definition via annotations?
+        BasicBeanDescription beanDesc = config.introspect(type);
+        JsonDeserializer<Object> ad = findDeserializerFromAnnotation(config, beanDesc.getClassInfo(), property);
+        if (ad != null) {
+            return ad;
+        }
+        // Or value annotation that indicates more specific type to use:
+        JavaType newType =  modifyTypeByAnnotation(config, beanDesc.getClassInfo(), type, null);
+        if (newType.getRawClass() != type.getRawClass()) {
+            type = newType;
+            beanDesc = config.introspect(type);
+        }
+        // We may also have custom overrides:
+        JsonDeserializer<Object> custom = _findCustomBeanDeserializer(type, config, p, beanDesc, property);
+        if (custom != null) {
+            return custom;
+        }
+        /* One more thing to check: do we have an exception type
+         * (Throwable or its sub-classes)? If so, need slightly
+         * different handling.
+         */
+        if (type.isThrowable()) {
+            return buildThrowableDeserializer(config, type, beanDesc, property);
+        }
+        /* Or, for abstract types, may have alternate means for resolution
+         * (defaulting, materialization)
+         */
+        if (type.isAbstract()) {
+            // [JACKSON-41] (v1.6): Let's make it possible to materialize abstract types.
+            JavaType concreteType = materializeAbstractType(config, beanDesc);
+            if (concreteType != null) {
+                /* important: introspect actual implementation (abstract class or
+                 * interface doesn't have constructors, for one)
+                 */
+                beanDesc = config.introspect(concreteType);
+                return buildBeanDeserializer(config, concreteType, beanDesc, property);
+            }
+        }
+
+        // Otherwise, may want to check handlers for standard types, from superclass:
+        JsonDeserializer<Object> deser = findStdBeanDeserializer(config, p, type, property);
+        if (deser != null) {
+            return deser;
+        }
+
+        // Otherwise: could the class be a Bean class? If not, bail out
+        if (!isPotentialBeanType(type.getRawClass())) {
+            return null;
+        }
+        // Use generic bean introspection to build deserializer
+        return buildBeanDeserializer(config, type, beanDesc, property);
+    }
+
+    /**
+     * Method that will find abstract type mapping for specified type, doing a single
+     * lookup through registered abstract type resolvers; will not do recursive lookups.
+     */
+    protected JavaType _mapAbstractType2(DeserializationConfig config, JavaType type)
+        throws JsonMappingException
+    {
+        Class<?> currClass = type.getRawClass();
+        if (_factoryConfig.hasAbstractTypeResolvers()) {
+            for (AbstractTypeResolver resolver : _factoryConfig.abstractTypeResolvers()) {
+                JavaType concrete = resolver.findTypeMapping(config, type);
+                if (concrete != null && concrete.getRawClass() != currClass) {
+                    return concrete;
+                }
+            }
+        }
+        return null;
+    }
+    
+    protected JavaType materializeAbstractType(DeserializationConfig config,
+            BasicBeanDescription beanDesc)
+        throws JsonMappingException
+    {
+        final JavaType abstractType = beanDesc.getType();
+        
+        /* [JACKSON-502] (1.8): Now it is possible to have multiple resolvers too,
+         *   as they are registered via module interface.
+         */
+        for (AbstractTypeResolver r : _factoryConfig.abstractTypeResolvers()) {
+            JavaType concrete = r.resolveAbstractType(config, abstractType);
+            if (concrete != null) {
+                return concrete;
+            }
+        }
+        return null;
+    }
+    
+    /*
+    /**********************************************************
+    /* Public construction method beyond DeserializerFactory API:
+    /* can be called from outside as well as overridden by
+    /* sub-classes
+    /**********************************************************
+     */
+
+    /**
+     * Method that is to actually build a bean deserializer instance.
+     * All basic sanity checks have been done to know that what we have
+     * may be a valid bean type, and that there are no default simple
+     * deserializers.
+     */
+    @SuppressWarnings("unchecked")
+    public JsonDeserializer<Object> buildBeanDeserializer(DeserializationConfig config,
+            JavaType type, BasicBeanDescription beanDesc, BeanProperty property)
+        throws JsonMappingException
+    {
+        // First: check what creators we can use, if any
+        ValueInstantiator valueInstantiator = findValueInstantiator(config, beanDesc);
+        // ... since often we have nothing to go on, if we have abstract type:
+        if (type.isAbstract()) {
+            if (!valueInstantiator.canInstantiate()) {
+                // and if so, need placeholder deserializer
+                return new AbstractDeserializer(type);
+            }
+        }
+        BeanDeserializerBuilder builder = constructBeanDeserializerBuilder(beanDesc);
+        builder.setValueInstantiator(valueInstantiator);
+         // And then setters for deserializing from JSON Object
+        addBeanProps(config, beanDesc, builder);
+        // managed/back reference fields/setters need special handling... first part
+        addReferenceProperties(config, beanDesc, builder);
+        addInjectables(config, beanDesc, builder);
+
+        // [JACKSON-440]: update builder now that all information is in?
+        if (_factoryConfig.hasDeserializerModifiers()) {
+            for (BeanDeserializerModifier mod : _factoryConfig.deserializerModifiers()) {
+                builder = mod.updateBuilder(config, beanDesc, builder);
+            }
+        }
+        JsonDeserializer<?> deserializer = builder.build(property);
+
+        // [JACKSON-440]: may have modifier(s) that wants to modify or replace serializer we just built:
+        if (_factoryConfig.hasDeserializerModifiers()) {
+            for (BeanDeserializerModifier mod : _factoryConfig.deserializerModifiers()) {
+                deserializer = mod.modifyDeserializer(config, beanDesc, deserializer);
+            }
+        }
+        return (JsonDeserializer<Object>) deserializer;
+        
+    }
+
+    @SuppressWarnings("unchecked")
+    public JsonDeserializer<Object> buildThrowableDeserializer(DeserializationConfig config,
+            JavaType type, BasicBeanDescription beanDesc, BeanProperty property)
+        throws JsonMappingException
+    {
+        // first: construct like a regular bean deserializer...
+        BeanDeserializerBuilder builder = constructBeanDeserializerBuilder(beanDesc);
+        builder.setValueInstantiator(findValueInstantiator(config, beanDesc));
+
+        addBeanProps(config, beanDesc, builder);
+        // (and assume there won't be any back references)
+
+        // But then let's decorate things a bit
+        /* To resolve [JACKSON-95], need to add "initCause" as setter
+         * for exceptions (sub-classes of Throwable).
+         */
+        AnnotatedMethod am = beanDesc.findMethod("initCause", INIT_CAUSE_PARAMS);
+        if (am != null) { // should never be null
+            SettableBeanProperty prop = constructSettableProperty(config, beanDesc, "cause", am);
+            if (prop != null) {
+                /* 21-Aug-2011, tatus: We may actually have found 'cause' property
+                 *   to set (with new 1.9 code)... but let's replace it just in case,
+                 *   otherwise can end up with odd errors.
+                 */
+                builder.addOrReplaceProperty(prop, true);
+            }
+        }
+
+        // And also need to ignore "localizedMessage"
+        builder.addIgnorable("localizedMessage");
+        /* As well as "message": it will be passed via constructor,
+         * as there's no 'setMessage()' method
+        */
+        builder.addIgnorable("message");
+
+        // [JACKSON-440]: update builder now that all information is in?
+        if (_factoryConfig.hasDeserializerModifiers()) {
+            for (BeanDeserializerModifier mod : _factoryConfig.deserializerModifiers()) {
+                builder = mod.updateBuilder(config, beanDesc, builder);
+            }
+        }
+        JsonDeserializer<?> deserializer = builder.build(property);
+        
+        /* At this point it ought to be a BeanDeserializer; if not, must assume
+         * it's some other thing that can handle deserialization ok...
+         */
+        if (deserializer instanceof BeanDeserializer) {
+            deserializer = new ThrowableDeserializer((BeanDeserializer) deserializer);
+        }
+
+        // [JACKSON-440]: may have modifier(s) that wants to modify or replace serializer we just built:
+        if (_factoryConfig.hasDeserializerModifiers()) {
+            for (BeanDeserializerModifier mod : _factoryConfig.deserializerModifiers()) {
+                deserializer = mod.modifyDeserializer(config, beanDesc, deserializer);
+            }
+        }
+        return (JsonDeserializer<Object>) deserializer;
+    }
+
+    /*
+    /**********************************************************
+    /* Helper methods for Bean deserializer construction,
+    /* overridable by sub-classes
+    /**********************************************************
+     */
+
+    /**
+     * Overridable method that constructs a {@link BeanDeserializerBuilder}
+     * which is used to accumulate information needed to create deserializer
+     * instance.
+     * 
+     * @since 1.7
+     */
+    protected BeanDeserializerBuilder constructBeanDeserializerBuilder(BasicBeanDescription beanDesc) {
+        return new BeanDeserializerBuilder(beanDesc);
+    }
+
+    /**
+     * Method that will construct standard default {@link ValueInstantiator}
+     * using annotations (like @JsonCreator) and visibility rules
+     * 
+     * @since 1.9
+     */
+    protected ValueInstantiator constructDefaultValueInstantiator(DeserializationConfig config,
+            BasicBeanDescription beanDesc)
+        throws JsonMappingException
+    {
+        boolean fixAccess = config.isEnabled(DeserializationConfig.Feature.CAN_OVERRIDE_ACCESS_MODIFIERS);
+        CreatorCollector creators =  new CreatorCollector(beanDesc, fixAccess);
+        AnnotationIntrospector intr = config.getAnnotationIntrospector();
+        
+        // First, let's figure out constructor/factory-based instantiation
+        // 23-Jan-2010, tatus: but only for concrete types
+        if (beanDesc.getType().isConcrete()) {
+            AnnotatedConstructor defaultCtor = beanDesc.findDefaultConstructor();
+            if (defaultCtor != null) {
+                if (fixAccess) {
+                    ClassUtil.checkAndFixAccess(defaultCtor.getAnnotated());
+                }
+                creators.setDefaultConstructor(defaultCtor);
+            }
+        }
+
+        // need to construct suitable visibility checker:
+        VisibilityChecker<?> vchecker = config.getDefaultVisibilityChecker();
+        vchecker = config.getAnnotationIntrospector().findAutoDetectVisibility(beanDesc.getClassInfo(), vchecker);
+
+        /* Important: first add factory methods; then constructors, so
+         * latter can override former!
+         */
+        _addDeserializerFactoryMethods(config, beanDesc, vchecker, intr, creators);
+        _addDeserializerConstructors(config, beanDesc, vchecker, intr, creators);
+
+        return creators.constructValueInstantiator(config);
+    }
+
+    protected void _addDeserializerConstructors
+        (DeserializationConfig config, BasicBeanDescription beanDesc, VisibilityChecker<?> vchecker,
+         AnnotationIntrospector intr, CreatorCollector creators)
+        throws JsonMappingException
+    {
+        for (AnnotatedConstructor ctor : beanDesc.getConstructors()) {
+            int argCount = ctor.getParameterCount();
+            if (argCount < 1) {
+                continue;
+            }
+            boolean isCreator = intr.hasCreatorAnnotation(ctor);
+            boolean isVisible =  vchecker.isCreatorVisible(ctor);
+            // some single-arg constructors (String, number) are auto-detected
+            if (argCount == 1) {
+                _handleSingleArgumentConstructor(config, beanDesc, vchecker, intr, creators,
+                        ctor, isCreator, isVisible);
+                continue;
+            }
+            if (!isCreator && !isVisible) {
+            	continue;
+            }
+            // [JACKSON-541] improved handling a bit so:
+            // 2 or more args; all params must have name annotations
+            // ... or @JacksonInject (or equivalent)
+            // But if it was auto-detected and there's no annotations, keep silent (was not meant to be a creator?)
+            boolean annotationFound = false;
+            /* [JACKSON-712] One more possibility; can have 1 or more injectables, and
+             * exactly one non-annotated parameter: if so, it's still delegating.
+             */
+            AnnotatedParameter nonAnnotatedParam = null;
+            int namedCount = 0;
+            int injectCount = 0;
+            CreatorProperty[] properties = new CreatorProperty[argCount];
+            for (int i = 0; i < argCount; ++i) {
+                AnnotatedParameter param = ctor.getParameter(i);
+                String name = (param == null) ? null : intr.findPropertyNameForParam(param);
+                Object injectId = intr.findInjectableValueId(param);
+                if (name != null && name.length() > 0) {
+                    ++namedCount;
+                    properties[i] = constructCreatorProperty(config, beanDesc, name, i, param, injectId);
+                } else if (injectId != null) {
+                    ++injectCount;
+                    properties[i] = constructCreatorProperty(config, beanDesc, name, i, param, injectId);
+                } else if (nonAnnotatedParam == null) {
+                    nonAnnotatedParam = param;
+                }
+            }
+
+            // Ok: if named or injectable, we have more work to do
+            if (isCreator || namedCount > 0 || injectCount > 0) {
+                // simple case; everything covered:
+                if ((namedCount + injectCount) == argCount) {
+                    creators.addPropertyCreator(ctor, properties);
+                } else if ((namedCount == 0) && ((injectCount + 1) == argCount)) {
+                    // secondary: all but one injectable, one un-annotated (un-named)
+                    // [JACKSON-712] SHOULD support; but we won't yet (tricky to do, not impossible)
+                    throw new IllegalArgumentException("Delegated constructor with Injectables not yet supported (see [JACKSON-712]) for "
+                            +ctor);
+                } else { // otherwise, epic fail
+                    throw new IllegalArgumentException("Argument #"+nonAnnotatedParam.getIndex()+" of constructor "+ctor+" has no property name annotation; must have name when multiple-paramater constructor annotated as Creator");
+                }
+            }
+            if (annotationFound) {
+            	creators.addPropertyCreator(ctor, properties);
+            }
+        }
+    }
+
+    protected boolean _handleSingleArgumentConstructor(DeserializationConfig config,
+            BasicBeanDescription beanDesc, VisibilityChecker<?> vchecker,
+            AnnotationIntrospector intr, CreatorCollector creators,
+            AnnotatedConstructor ctor, boolean isCreator, boolean isVisible)
+        throws JsonMappingException
+    {
+        // note: if we do have parameter name, it'll be "property constructor":
+        AnnotatedParameter param = ctor.getParameter(0);
+        String name = intr.findPropertyNameForParam(param);
+        Object injectId = intr.findInjectableValueId(param);
+    
+        if ((injectId != null) || (name != null && name.length() > 0)) { // property-based
+            // We know there's a name and it's only 1 parameter.
+            CreatorProperty[] properties = new CreatorProperty[1];
+            properties[0] = constructCreatorProperty(config, beanDesc, name, 0, param, injectId);
+            creators.addPropertyCreator(ctor, properties);
+            return true;
+        }
+    
+        // otherwise either 'simple' number, String, or general delegate:
+        Class<?> type = ctor.getParameterClass(0);
+        if (type == String.class) {
+            if (isCreator || isVisible) {
+                creators.addStringCreator(ctor);
+            }
+            return true;
+        }
+        if (type == int.class || type == Integer.class) {
+            if (isCreator || isVisible) {
+                creators.addIntCreator(ctor);
+            }
+            return true;
+        }
+        if (type == long.class || type == Long.class) {
+            if (isCreator || isVisible) {
+                creators.addLongCreator(ctor);
+            }
+            return true;
+        }
+        if (type == double.class || type == Double.class) {
+            if (isCreator || isVisible) {
+                creators.addDoubleCreator(ctor);
+            }
+            return true;
+        }
+    
+        // Delegating Creator ok iff it has @JsonCreator (etc)
+        if (isCreator) {
+            creators.addDelegatingCreator(ctor);
+            return true;
+        }
+        return false;
+    }
+    
+    protected void _addDeserializerFactoryMethods
+        (DeserializationConfig config, BasicBeanDescription beanDesc, VisibilityChecker<?> vchecker,
+         AnnotationIntrospector intr, CreatorCollector creators)
+        throws JsonMappingException
+    {
+
+        for (AnnotatedMethod factory : beanDesc.getFactoryMethods()) {
+            int argCount = factory.getParameterCount();
+            if (argCount < 1) {
+                continue;
+            }
+            boolean isCreator = intr.hasCreatorAnnotation(factory);
+            // some single-arg factory methods (String, number) are auto-detected
+            if (argCount == 1) {
+                AnnotatedParameter param = factory.getParameter(0);
+                String name = intr.findPropertyNameForParam(param);
+                Object injectId = intr.findInjectableValueId(param);
+
+                if ((injectId == null) && (name == null || name.length() == 0)) { // not property based
+                    _handleSingleArgumentFactory(config, beanDesc, vchecker, intr, creators,
+                            factory, isCreator);
+                    // otherwise just ignored
+                    continue;
+                }
+                // fall through if there's name
+            } else {
+                // more than 2 args, must be @JsonCreator
+                if (!intr.hasCreatorAnnotation(factory)) {
+                    continue;
+                }
+            }
+            // 1 or more args; all params must have name annotations
+            CreatorProperty[] properties = new CreatorProperty[argCount];
+            for (int i = 0; i < argCount; ++i) {
+                AnnotatedParameter param = factory.getParameter(i);
+                String name = intr.findPropertyNameForParam(param);
+                Object injectableId = intr.findInjectableValueId(param);
+                // At this point, name annotation is NOT optional
+                if ((name == null || name.length() == 0) && (injectableId == null)) {
+                    throw new IllegalArgumentException("Argument #"+i+" of factory method "+factory+" has no property name annotation; must have when multiple-paramater static method annotated as Creator");
+                }
+                properties[i] = constructCreatorProperty(config, beanDesc, name, i, param, injectableId);
+            }
+            creators.addPropertyCreator(factory, properties);
+        }
+    }
+
+    protected boolean _handleSingleArgumentFactory(DeserializationConfig config,
+            BasicBeanDescription beanDesc, VisibilityChecker<?> vchecker,
+            AnnotationIntrospector intr, CreatorCollector creators,
+            AnnotatedMethod factory, boolean isCreator)
+        throws JsonMappingException
+    {
+        Class<?> type = factory.getParameterClass(0);
+        
+        if (type == String.class) {
+            if (isCreator || vchecker.isCreatorVisible(factory)) {
+                creators.addStringCreator(factory);
+            }
+            return true;
+        }
+        if (type == int.class || type == Integer.class) {
+            if (isCreator || vchecker.isCreatorVisible(factory)) {
+                creators.addIntCreator(factory);
+            }
+            return true;
+        }
+        if (type == long.class || type == Long.class) {
+            if (isCreator || vchecker.isCreatorVisible(factory)) {
+                creators.addLongCreator(factory);
+            }
+            return true;
+        }
+        if (type == double.class || type == Double.class) {
+            if (isCreator || vchecker.isCreatorVisible(factory)) {
+                creators.addDoubleCreator(factory);
+            }
+            return true;
+        }
+        if (type == boolean.class || type == Boolean.class) {
+            if (isCreator || vchecker.isCreatorVisible(factory)) {
+                creators.addBooleanCreator(factory);
+            }
+            return true;
+        }
+        if (intr.hasCreatorAnnotation(factory)) {
+            creators.addDelegatingCreator(factory);
+            return true;
+        }
+        return false;
+    }
+    
+    /**
+     * Method that will construct a property object that represents
+     * a logical property passed via Creator (constructor or static
+     * factory method)
+     */
+    protected CreatorProperty constructCreatorProperty(DeserializationConfig config,
+            BasicBeanDescription beanDesc, String name, int index,
+            AnnotatedParameter param,
+            Object injectableValueId)
+        throws JsonMappingException
+    {
+        JavaType t0 = config.getTypeFactory().constructType(param.getParameterType(), beanDesc.bindingsForBeanType());
+        BeanProperty.Std property = new BeanProperty.Std(name, t0, beanDesc.getClassAnnotations(), param);
+        JavaType type = resolveType(config, beanDesc, t0, param, property);
+        if (type != t0) {
+            property = property.withType(type);
+        }
+        // Is there an annotation that specifies exact deserializer?
+        JsonDeserializer<Object> deser = findDeserializerFromAnnotation(config, param, property);
+        // If yes, we are mostly done:
+        type = modifyTypeByAnnotation(config, param, type, name);
+
+        // Type deserializer: either comes from property (and already resolved)
+        TypeDeserializer typeDeser = (TypeDeserializer) type.getTypeHandler();
+        // or if not, based on type being referenced:
+        if (typeDeser == null) {
+            typeDeser = findTypeDeserializer(config, type, property);
+        }
+        CreatorProperty prop = new CreatorProperty(name, type, typeDeser,
+                beanDesc.getClassAnnotations(), param, index, injectableValueId);
+        if (deser != null) {
+            prop = prop.withValueDeserializer(deser);
+        }
+        return prop;
+    }
+    
+    /**
+     * Method called to figure out settable properties for the
+     * bean deserializer to use.
+     *<p>
+     * Note: designed to be overridable, and effort is made to keep interface
+     * similar between versions.
+     */
+    protected void addBeanProps(DeserializationConfig config,
+            BasicBeanDescription beanDesc, BeanDeserializerBuilder builder)
+        throws JsonMappingException
+    {
+        List<BeanPropertyDefinition> props = beanDesc.findProperties();
+        // Things specified as "ok to ignore"? [JACKSON-77]
+        AnnotationIntrospector intr = config.getAnnotationIntrospector();
+        boolean ignoreAny = false;
+        {
+            Boolean B = intr.findIgnoreUnknownProperties(beanDesc.getClassInfo());
+            if (B != null) {
+                ignoreAny = B.booleanValue();
+                builder.setIgnoreUnknownProperties(ignoreAny);
+            }
+        }
+        // Or explicit/implicit definitions?
+        Set<String> ignored = ArrayBuilders.arrayToSet(intr.findPropertiesToIgnore(beanDesc.getClassInfo()));        
+        for (String propName : ignored) {
+            builder.addIgnorable(propName);
+        }
+        AnnotatedMethod anySetter = beanDesc.findAnySetter();
+        // Implicit ones via @JsonIgnore and equivalent?
+        /* 26-Dec-2011, tatu: As per [JACKSON-744], it probably does NOT make
+         *   sense to consider ignorable, esp. now that both getters and setters
+         *   can induce ignoral.
+         */
+        {
+            Collection<String> ignored2 = (anySetter == null) ?
+                    beanDesc.getIgnoredPropertyNames() : beanDesc.getIgnoredPropertyNamesForDeser();
+                    if (ignored2 != null) {
+                for (String propName : ignored2) {
+                    // allow ignoral of similarly named JSON property, but do not force;
+                    // latter means NOT adding this to 'ignored':
+                    builder.addIgnorable(propName);
+                }
+            }
+        }
+        HashMap<Class<?>,Boolean> ignoredTypes = new HashMap<Class<?>,Boolean>();
+        
+        // These are all valid setters, but we do need to introspect bit more
+        for (BeanPropertyDefinition property : props) {
+            String name = property.getName();
+            if (ignored.contains(name)) { // explicit ignoral using @JsonIgnoreProperties needs to block entries
+                continue;
+            }
+            /* [JACKSON-700] If property as passed via constructor parameter, we must
+             *   handle things in special way. Not sure what is the most optimal way...
+             *   for now, let's just call a (new) method in builder, which does nothing.
+             */
+            if (property.hasConstructorParameter()) {
+                // but let's call a method just to allow custom builders to be aware...
+                builder.addCreatorProperty(property);
+                continue;
+            }
+            // primary: have a setter?
+            if (property.hasSetter()) {
+                AnnotatedMethod setter = property.getSetter();
+                // [JACKSON-429] Some types are declared as ignorable as well
+                Class<?> type = setter.getParameterClass(0);
+                if (isIgnorableType(config, beanDesc, type, ignoredTypes)) {
+                    // important: make ignorable, to avoid errors if value is actually seen
+                    builder.addIgnorable(name);
+                    continue;
+                }
+                SettableBeanProperty prop = constructSettableProperty(config, beanDesc, name, setter);
+                if (prop != null) {
+                    builder.addProperty(prop);
+                }
+                continue;
+            }
+            if (property.hasField()) {
+                AnnotatedField field = property.getField();
+                // [JACKSON-429] Some types are declared as ignorable as well
+                Class<?> type = field.getRawType();
+                if (isIgnorableType(config, beanDesc, type, ignoredTypes)) {
+                    // important: make ignorable, to avoid errors if value is actually seen
+                    builder.addIgnorable(name);
+                    continue;
+                }
+                SettableBeanProperty prop = constructSettableProperty(config, beanDesc, name, field);
+                if (prop != null) {
+                    builder.addProperty(prop);
+                }
+            }
+        }
+        // Also, do we have a fallback "any" setter?
+        if (anySetter != null) {
+            builder.setAnySetter(constructAnySetter(config, beanDesc, anySetter));
+        }
+
+        /* As per [JACKSON-88], may also need to consider getters
+         * for Map/Collection properties
+         */
+        /* also, as per [JACKSON-328], should not override fields (or actual setters),
+         * thus these are added AFTER adding fields
+         */
+        if (config.isEnabled(DeserializationConfig.Feature.USE_GETTERS_AS_SETTERS)) {
+            /* Hmmh. We have to assume that 'use getters as setters' also
+             * implies 'yes, do auto-detect these getters'? (if not, we'd
+             * need to add AUTO_DETECT_GETTERS to deser config too, not
+             * just ser config)
+             */
+            for (BeanPropertyDefinition property : props) {
+                if (property.hasGetter()) {
+                    String name = property.getName();
+                    if (builder.hasProperty(name) || ignored.contains(name)) {
+                        continue;
+                    }
+                    AnnotatedMethod getter = property.getGetter();
+                    // should only consider Collections and Maps, for now?
+                    Class<?> rt = getter.getRawType();
+                    if (Collection.class.isAssignableFrom(rt) || Map.class.isAssignableFrom(rt)) {
+                        if (!ignored.contains(name) && !builder.hasProperty(name)) {
+                            builder.addProperty(constructSetterlessProperty(config, beanDesc, name, getter));
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    /**
+     * Method that will find if bean has any managed- or back-reference properties,
+     * and if so add them to bean, to be linked during resolution phase.
+     * 
+     * @since 1.6
+     */
+    protected void addReferenceProperties(DeserializationConfig config,
+            BasicBeanDescription beanDesc, BeanDeserializerBuilder builder)
+        throws JsonMappingException
+    {
+        // and then back references, not necessarily found as regular properties
+        Map<String,AnnotatedMember> refs = beanDesc.findBackReferenceProperties();
+        if (refs != null) {
+            for (Map.Entry<String, AnnotatedMember> en : refs.entrySet()) {
+                String name = en.getKey();
+                AnnotatedMember m = en.getValue();
+                if (m instanceof AnnotatedMethod) {
+                    builder.addBackReferenceProperty(name, constructSettableProperty(
+                            config, beanDesc, m.getName(), (AnnotatedMethod) m));
+                } else {
+                    builder.addBackReferenceProperty(name, constructSettableProperty(
+                            config, beanDesc, m.getName(), (AnnotatedField) m));
+                }
+            }
+        }
+    }
+    
+    /**
+     * Method called locate all members used for value injection (if any),
+     * constructor {@link sh.calaba.org.codehaus.jackson.map.deser.impl.ValueInjector} instances, and add them to builder.
+     * 
+     * @since 1.9
+     */
+    protected void addInjectables(DeserializationConfig config,
+            BasicBeanDescription beanDesc, BeanDeserializerBuilder builder)
+        throws JsonMappingException
+    {
+        Map<Object, AnnotatedMember> raw = beanDesc.findInjectables();
+        if (raw != null) {
+            boolean fixAccess = config.isEnabled(DeserializationConfig.Feature.CAN_OVERRIDE_ACCESS_MODIFIERS);
+            for (Map.Entry<Object, AnnotatedMember> entry : raw.entrySet()) {
+                AnnotatedMember m = entry.getValue();
+                if (fixAccess) {
+                    m.fixAccess(); // to ensure we can call it
+                }
+                builder.addInjectable(m.getName(), beanDesc.resolveType(m.getGenericType()),
+                        beanDesc.getClassAnnotations(), m, entry.getKey());
+            }
+        }
+    }
+
+    /**
+     * Method called to construct fallback {@link SettableAnyProperty}
+     * for handling unknown bean properties, given a method that
+     * has been designated as such setter.
+     */
+    protected SettableAnyProperty constructAnySetter(DeserializationConfig config,
+            BasicBeanDescription beanDesc, AnnotatedMethod setter)
+        throws JsonMappingException
+    {
+        if (config.isEnabled(DeserializationConfig.Feature.CAN_OVERRIDE_ACCESS_MODIFIERS)) {
+            setter.fixAccess(); // to ensure we can call it
+        }
+        // we know it's a 2-arg method, second arg is the value
+        JavaType type = beanDesc.bindingsForBeanType().resolveType(setter.getParameterType(1));
+        BeanProperty.Std property = new BeanProperty.Std(setter.getName(), type, beanDesc.getClassAnnotations(), setter);
+        type = resolveType(config, beanDesc, type, setter, property);
+
+        /* AnySetter can be annotated with @JsonClass (etc) just like a
+         * regular setter... so let's see if those are used.
+         * Returns null if no annotations, in which case binding will
+         * be done at a later point.
+         */
+        JsonDeserializer<Object> deser = findDeserializerFromAnnotation(config, setter, property);
+        if (deser != null) {
+            return new SettableAnyProperty(property, setter, type, deser);
+        }
+        /* Otherwise, method may specify more specific (sub-)class for
+         * value (no need to check if explicit deser was specified):
+         */
+        type = modifyTypeByAnnotation(config, setter, type, property.getName());
+        return new SettableAnyProperty(property, setter, type, null);
+    }
+
+    /**
+     * Method that will construct a regular bean property setter using
+     * the given setter method.
+     *
+     * @param setter Method to use to set property value; or null if none.
+     *    Null only for "setterless" properties
+     *
+     * @return Property constructed, if any; or null to indicate that
+     *   there should be no property based on given definitions.
+     */
+    protected SettableBeanProperty constructSettableProperty(DeserializationConfig config,
+            BasicBeanDescription beanDesc, String name,
+            AnnotatedMethod setter)
+        throws JsonMappingException
+    {
+        // need to ensure method is callable (for non-public)
+        if (config.isEnabled(DeserializationConfig.Feature.CAN_OVERRIDE_ACCESS_MODIFIERS)) {
+            setter.fixAccess();
+        }
+
+        // note: this works since we know there's exactly one argument for methods
+        JavaType t0 = beanDesc.bindingsForBeanType().resolveType(setter.getParameterType(0));
+        BeanProperty.Std property = new BeanProperty.Std(name, t0, beanDesc.getClassAnnotations(), setter);
+        JavaType type = resolveType(config, beanDesc, t0, setter, property);
+        // did type change?
+        if (type != t0) {
+            property = property.withType(type);
+        }
+        
+        /* First: does the Method specify the deserializer to use?
+         * If so, let's use it.
+         */
+        JsonDeserializer<Object> propDeser = findDeserializerFromAnnotation(config, setter, property);
+        type = modifyTypeByAnnotation(config, setter, type, name);
+        TypeDeserializer typeDeser = type.getTypeHandler();
+        SettableBeanProperty prop = new SettableBeanProperty.MethodProperty(name, type, typeDeser,
+                beanDesc.getClassAnnotations(), setter);
+        if (propDeser != null) {
+            prop = prop.withValueDeserializer(propDeser);
+        }
+        // [JACKSON-235]: need to retain name of managed forward references:
+        AnnotationIntrospector.ReferenceProperty ref = config.getAnnotationIntrospector().findReferenceType(setter);
+        if (ref != null && ref.isManagedReference()) {
+            prop.setManagedReferenceName(ref.getName());
+        }
+        return prop;
+    }
+
+    protected SettableBeanProperty constructSettableProperty(DeserializationConfig config,
+            BasicBeanDescription beanDesc, String name, AnnotatedField field)
+        throws JsonMappingException
+    {
+        // need to ensure method is callable (for non-public)
+        if (config.isEnabled(DeserializationConfig.Feature.CAN_OVERRIDE_ACCESS_MODIFIERS)) {
+            field.fixAccess();
+        }
+        JavaType t0 = beanDesc.bindingsForBeanType().resolveType(field.getGenericType());
+        BeanProperty.Std property = new BeanProperty.Std(name, t0, beanDesc.getClassAnnotations(), field);
+        JavaType type = resolveType(config, beanDesc, t0, field, property);
+        // did type change?
+        if (type != t0) {
+            property = property.withType(type);
+        }
+        /* First: does the Method specify the deserializer to use?
+         * If so, let's use it.
+         */
+        JsonDeserializer<Object> propDeser = findDeserializerFromAnnotation(config, field, property);
+        type = modifyTypeByAnnotation(config, field, type, name);
+        TypeDeserializer typeDeser = type.getTypeHandler();
+        SettableBeanProperty prop = new SettableBeanProperty.FieldProperty(name, type, typeDeser,
+                beanDesc.getClassAnnotations(), field);
+        if (propDeser != null) {
+            prop = prop.withValueDeserializer(propDeser);
+        }
+        // [JACKSON-235]: need to retain name of managed forward references:
+        AnnotationIntrospector.ReferenceProperty ref = config.getAnnotationIntrospector().findReferenceType(field);
+        if (ref != null && ref.isManagedReference()) {
+            prop.setManagedReferenceName(ref.getName());
+        }
+        return prop;
+    }
+
+    /**
+     * Method that will construct a regular bean property setter using
+     * the given setter method.
+     *
+     * @param getter Method to use to get property value to modify, null if
+     *    none. Non-null for "setterless" properties.
+     */
+    protected SettableBeanProperty constructSetterlessProperty(DeserializationConfig config,
+            BasicBeanDescription beanDesc, String name, AnnotatedMethod getter)
+        throws JsonMappingException
+    {
+        // need to ensure it is callable now:
+        if (config.isEnabled(DeserializationConfig.Feature.CAN_OVERRIDE_ACCESS_MODIFIERS)) {
+            getter.fixAccess();
+        }
+
+        JavaType type = getter.getType(beanDesc.bindingsForBeanType());
+        /* First: does the Method specify the deserializer to use?
+         * If so, let's use it.
+         */
+        BeanProperty.Std property = new BeanProperty.Std(name, type, beanDesc.getClassAnnotations(), getter);
+        // @TODO: create BeanProperty to pass?
+        JsonDeserializer<Object> propDeser = findDeserializerFromAnnotation(config, getter, property);
+        type = modifyTypeByAnnotation(config, getter, type, name);
+        TypeDeserializer typeDeser = type.getTypeHandler();
+        SettableBeanProperty prop = new SettableBeanProperty.SetterlessProperty(name, type, typeDeser,
+                beanDesc.getClassAnnotations(), getter);
+        if (propDeser != null) {
+            prop = prop.withValueDeserializer(propDeser);
+        }
+        return prop;
+    }
+
+    /*
+    /**********************************************************
+    /* Helper methods for Bean deserializer, other
+    /**********************************************************
+     */
+
+    /**
+     * Helper method used to skip processing for types that we know
+     * can not be (i.e. are never consider to be) beans: 
+     * things like primitives, Arrays, Enums, and proxy types.
+     *<p>
+     * Note that usually we shouldn't really be getting these sort of
+     * types anyway; but better safe than sorry.
+     */
+    protected boolean isPotentialBeanType(Class<?> type)
+    {
+        String typeStr = ClassUtil.canBeABeanType(type);
+        if (typeStr != null) {
+            throw new IllegalArgumentException("Can not deserialize Class "+type.getName()+" (of type "+typeStr+") as a Bean");
+        }
+        if (ClassUtil.isProxyType(type)) {
+            throw new IllegalArgumentException("Can not deserialize Proxy class "+type.getName()+" as a Bean");
+        }
+        /* also: can't deserialize some local classes: static are ok; in-method not;
+         * and with [JACKSON-594], other non-static inner classes are ok
+         */
+        typeStr = ClassUtil.isLocalType(type, true);
+        if (typeStr != null) {
+            throw new IllegalArgumentException("Can not deserialize Class "+type.getName()+" (of type "+typeStr+") as a Bean");
+        }
+    	return true;
+    }
+
+    /**
+     * Helper method that will check whether given raw type is marked as always ignorable
+     * (for purpose of ignoring properties with type)
+     */
+    protected boolean isIgnorableType(DeserializationConfig config, BasicBeanDescription beanDesc,
+            Class<?> type, Map<Class<?>,Boolean> ignoredTypes)
+    {
+        Boolean status = ignoredTypes.get(type);
+        if (status == null) {
+            BasicBeanDescription desc = config.introspectClassAnnotations(type);
+            status = config.getAnnotationIntrospector().isIgnorableType(desc.getClassInfo());
+            // We default to 'false', ie. not ignorable
+            if (status == null) {
+                status = Boolean.FALSE;
+            }
+        }
+        return status;
+    }
+}