calabash-android 0.4.7.pre4 → 0.4.7.pre6

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

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

@@ -1,1474 +0,0 @@
-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;
-    }
-}