calabash-android 0.4.7.pre4 → 0.4.7.pre6

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

@@ -1,1485 +0,0 @@
-package sh.calaba.org.codehaus.jackson.map;
-
-import java.lang.annotation.Annotation;
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.Collections;
-import java.util.List;
-
-import sh.calaba.org.codehaus.jackson.map.annotate.JsonSerialize;
-import sh.calaba.org.codehaus.jackson.map.deser.ValueInstantiator;
-import sh.calaba.org.codehaus.jackson.map.introspect.Annotated;
-import sh.calaba.org.codehaus.jackson.map.introspect.AnnotatedClass;
-import sh.calaba.org.codehaus.jackson.map.introspect.AnnotatedConstructor;
-import sh.calaba.org.codehaus.jackson.map.introspect.AnnotatedField;
-import sh.calaba.org.codehaus.jackson.map.introspect.AnnotatedMember;
-import sh.calaba.org.codehaus.jackson.map.introspect.AnnotatedMethod;
-import sh.calaba.org.codehaus.jackson.map.introspect.AnnotatedParameter;
-import sh.calaba.org.codehaus.jackson.map.introspect.NopAnnotationIntrospector;
-import sh.calaba.org.codehaus.jackson.map.introspect.VisibilityChecker;
-import sh.calaba.org.codehaus.jackson.map.jsontype.NamedType;
-import sh.calaba.org.codehaus.jackson.map.jsontype.TypeResolverBuilder;
-import sh.calaba.org.codehaus.jackson.type.JavaType;
-
-/**
- * Abstract class that defines API used for introspecting annotation-based
- * configuration for serialization and deserialization. Separated
- * so that different sets of annotations can be supported, and support
- * plugged-in dynamically.
- *<p>
- * NOTE: due to rapid addition of new methods (and changes to existing methods),
- * it is <b>strongly</b> recommended that custom implementations should not directly
- * extend this class, but rather extend {@link NopAnnotationIntrospector}.
- * This way added methods will not break backwards compatibility of custom annotation
- * introspectors.
- */
-public abstract class AnnotationIntrospector
-{    
-    /*
-    /**********************************************************
-    /* Helper types
-    /**********************************************************
-     */
-
-    /**
-     * Value type used with managed and back references; contains type and
-     * logic name, used to link related references
-     * 
-     * @since 1.6
-     */
-    public static class ReferenceProperty
-    {
-        public enum Type {
-            /**
-             * Reference property that Jackson manages and that is serialized normally (by serializing
-             * reference object), but is used for resolving back references during
-             * deserialization.
-             * Usually this can be defined by using
-             * {@link sh.calaba.org.codehaus.jackson.annotate.JsonManagedReference}
-             */
-            MANAGED_REFERENCE
-    
-            /**
-             * Reference property that Jackson manages by suppressing it during serialization,
-             * and reconstructing during deserialization.
-             * Usually this can be defined by using
-             * {@link sh.calaba.org.codehaus.jackson.annotate.JsonBackReference}
-             */
-            ,BACK_REFERENCE
-            ;
-        }
-
-        private final Type _type;
-        private final String _name;
-
-        public ReferenceProperty(Type t, String n) {
-            _type = t;
-            _name = n;
-        }
-
-        public static ReferenceProperty managed(String name) { return new ReferenceProperty(Type.MANAGED_REFERENCE, name); }
-        public static ReferenceProperty back(String name) { return new ReferenceProperty(Type.BACK_REFERENCE, name); }
-        
-        public Type getType() { return _type; }
-        public String getName() { return _name; }
-
-        public boolean isManagedReference() { return _type == Type.MANAGED_REFERENCE; }
-        public boolean isBackReference() { return _type == Type.BACK_REFERENCE; }
-    }
-    
-    /*
-    /**********************************************************
-    /* Factory methods
-    /**********************************************************
-     */
-    
-    /**
-     * Factory method for accessing "no operation" implementation
-     * of introspector: instance that will never find any annotation-based
-     * configuration.
-     * 
-     * @since 1.3
-     */
-    public static AnnotationIntrospector nopInstance() {
-        return NopAnnotationIntrospector.instance;
-    }
-
-    public static AnnotationIntrospector pair(AnnotationIntrospector a1, AnnotationIntrospector a2) {
-        return new Pair(a1, a2);
-    }
-
-    /*
-    /**********************************************************
-    /* Access to possibly chained introspectors (1.7)
-    /**********************************************************
-     */
-
-    /**
-     * Method that can be used to collect all "real" introspectors that
-     * this introspector contains, if any; or this introspector
-     * if it is not a container. Used to get access to all container
-     * introspectors in their priority order.
-     *<p>
-     * Default implementation returns a Singleton list with this introspector
-     * as contents.
-     * This usually works for sub-classes, except for proxy or delegating "container
-     * introspectors" which need to override implementation.
-     */
-    public Collection<AnnotationIntrospector> allIntrospectors() {
-        return Collections.singletonList(this);
-    }
-    
-    /**
-     * Method that can be used to collect all "real" introspectors that
-     * this introspector contains, if any; or this introspector
-     * if it is not a container. Used to get access to all container
-     * introspectors in their priority order.
-     *<p>
-     * Default implementation adds this introspector in result; this usually
-     * works for sub-classes, except for proxy or delegating "container
-     * introspectors" which need to override implementation.
-     */
-    public Collection<AnnotationIntrospector> allIntrospectors(Collection<AnnotationIntrospector> result) {
-        result.add(this);
-        return result;
-    }
-    
-    /*
-    /**********************************************************
-    /* Generic annotation properties, lookup
-    /**********************************************************
-    */
-
-    /**
-     * Method called by framework to determine whether given annotation
-     * is handled by this introspector.
-     */
-    public abstract boolean isHandled(Annotation ann);
-    
-    /*
-    /**********************************************************
-    /* General class annotations
-    /**********************************************************
-    */
-
-    /**
-     * Method that checks whether specified class has annotations
-     * that indicate that it is (or is not) cachable. Exact
-     * semantics depend on type of class annotated and using
-     * class (factory or provider).
-     *<p>
-     * Currently only used
-     * with deserializers, to determine whether provider
-     * should cache instances, and if no annotations are found,
-     * assumes non-cachable instances.
-     *
-     * @return True, if class is considered cachable within context,
-     *   False if not, and null if introspector does not care either
-     *   way.
-     */
-    public Boolean findCachability(AnnotatedClass ac) {
-        return null;
-    }
-
-    /**
-     * Method for locating name used as "root name" (for use by
-     * some serializers when outputting root-level object -- mostly
-     * for XML compatibility purposes) for given class, if one
-     * is defined. Returns null if no declaration found; can return
-     * explicit empty String, which is usually ignored as well as null.
-     *
-     * @since 1.3
-     */
-    public abstract String findRootName(AnnotatedClass ac);
-
-    /**
-     * Method for finding list of properties to ignore for given class
-     * (null is returned if not specified).
-     * List of property names is applied
-     * after other detection mechanisms, to filter out these specific
-     * properties from being serialized and deserialized.
-     * 
-     * @since 1.4
-     */
-    public abstract String[] findPropertiesToIgnore(AnnotatedClass ac);
-
-    /**
-     * Method for checking whether an annotation indicates that all unknown properties
-     * 
-     * @since 1.4
-     */
-    public abstract Boolean findIgnoreUnknownProperties(AnnotatedClass ac);
-
-    /**
-     * Method for checking whether properties that have specified type
-     * (class, not generics aware) should be completely ignored for
-     * serialization and deserialization purposes.
-     * 
-     * @param ac Type to check
-     * 
-     * @return Boolean.TRUE if properties of type should be ignored;
-     *   Boolean.FALSE if they are not to be ignored, null for default
-     *   handling (which is 'do not ignore')
-     *   
-     * @since 1.7
-     */
-    public Boolean isIgnorableType(AnnotatedClass ac) {
-        return null;
-    }
-
-    /**
-     * Method for finding if annotated class has associated filter; and if so,
-     * to return id that is used to locate filter.
-     * 
-     * @return Id of the filter to use for filtering properties of annotated
-     *    class, if any; or null if none found.
-     */
-    public Object findFilterId(AnnotatedClass ac) {
-        return null;
-    }
-    
-    /*
-    /**********************************************************
-    /* Property auto-detection
-    /**********************************************************
-     */
-
-    /**
-     * Method for checking if annotations indicate changes to minimum visibility levels
-     * needed for auto-detecting property elements (fields, methods, constructors).
-     * A baseline checker is given, and introspector is to either return it as is (if
-     * no annotations are found), or build and return a derived instance (using checker's build
-     * methods).
-     *
-     *  @since 1.5
-     */
-    public VisibilityChecker<?> findAutoDetectVisibility(AnnotatedClass ac, VisibilityChecker<?> checker) {
-        return checker;
-    }
-    
-    /*
-    /**********************************************************
-    /* Class annotations for Polymorphic type handling (1.5+)
-    /**********************************************************
-    */
-    
-    /**
-     * Method for checking if given class has annotations that indicate
-     * that specific type resolver is to be used for handling instances.
-     * This includes not only
-     * instantiating resolver builder, but also configuring it based on
-     * relevant annotations (not including ones checked with a call to
-     * {@link #findSubtypes}
-     * 
-     * @param config Configuration settings in effect (for serialization or deserialization)
-     * @param ac Annotated class to check for annotations
-     * @param baseType Base java type of value for which resolver is to be found
-     * 
-     * @return Type resolver builder for given type, if one found; null if none
-     * 
-     * @since 1.5 -- although changed in 1.8 to pass configuration object
-     */
-    public TypeResolverBuilder<?> findTypeResolver(MapperConfig<?> config,
-            AnnotatedClass ac, JavaType baseType) {
-        return null;
-    }
-
-    /**
-     * Method for checking if given property entity (field or method) has annotations
-     * that indicate that specific type resolver is to be used for handling instances.
-     * This includes not only
-     * instantiating resolver builder, but also configuring it based on
-     * relevant annotations (not including ones checked with a call to
-     * {@link #findSubtypes}
-     * 
-     * @param config Configuration settings in effect (for serialization or deserialization)
-     * @param am Annotated member (field or method) to check for annotations
-     * @param baseType Base java type of property for which resolver is to be found
-     * 
-     * @return Type resolver builder for properties of given entity, if one found;
-     *    null if none
-     * 
-     * @since 1.5 -- although changed in 1.8 to pass configuration object
-     */
-    public TypeResolverBuilder<?> findPropertyTypeResolver(MapperConfig<?> config,
-            AnnotatedMember am, JavaType baseType) {
-        return null;
-    }
-
-    /**
-     * Method for checking if given structured property entity (field or method that
-     * has nominal value of Map, Collection or array type) has annotations
-     * that indicate that specific type resolver is to be used for handling type
-     * information of contained values.
-     * This includes not only
-     * instantiating resolver builder, but also configuring it based on
-     * relevant annotations (not including ones checked with a call to
-     * {@link #findSubtypes}
-     * 
-     * @param config Configuration settings in effect (for serialization or deserialization)
-     * @param am Annotated member (field or method) to check for annotations
-     * @param containerType Type of property for which resolver is to be found (must be a container type)
-     * 
-     * @return Type resolver builder for values contained in properties of given entity,
-     *    if one found; null if none
-     * 
-     * @since 1.5 -- although changed in 1.8 to pass configuration object
-     */    
-    public TypeResolverBuilder<?> findPropertyContentTypeResolver(MapperConfig<?> config,
-            AnnotatedMember am, JavaType containerType) {
-        return null;
-    }
-
-    /**
-     * Method for locating annotation-specified subtypes related to annotated
-     * entity (class, method, field). Note that this is only guaranteed to be
-     * a list of directly
-     * declared subtypes, no recursive processing is guarantees (i.e. caller
-     * has to do it if/as necessary)
-     * 
-     * @param a Annotated entity (class, field/method) to check for annotations
-     * 
-     * @since 1.5
-     */
-    public List<NamedType> findSubtypes(Annotated a) {
-        return null;
-    }
-
-    /**
-     * Method for checking if specified type has explicit name.
-     * 
-     * @param ac Class to check for type name annotations
-     * 
-     * @since 1.5
-     */
-    public String findTypeName(AnnotatedClass ac) {
-        return null;
-    }
-
-    /*
-    /**********************************************************
-    /* General member (field, method/constructor) annotations
-    /**********************************************************
-     */
-
-    /**
-     * Note: defined as non-abstract to reduce fragility between
-     * versions.
-     * 
-     * @since 1.6
-     */
-    public ReferenceProperty findReferenceType(AnnotatedMember member) {
-        return null;
-    }
-
-    /**
-     * Method called to check whether given property is marked to be "unwrapped"
-     * when being serialized (and appropriately handled in reverse direction,
-     * i.e. expect unwrapped representation during deserialization)
-     * 
-     * @since 1.9
-     */
-    public Boolean shouldUnwrapProperty(AnnotatedMember member) {
-        return null;
-    }
-
-    /**
-     * Method called to check whether given property is marked to
-     * be ignored; but NOT to determine if it should necessarily
-     * be ignored, since that may depend on other factors.
-     *<p>
-     * Default implementation calls existing 'isIgnored' methods
-     * such as {@link #isIgnorableField(AnnotatedField)} and
-     * {@link #isIgnorableMethod(AnnotatedMethod)}.
-     * 
-     * @since 1.9
-     */
-    public boolean hasIgnoreMarker(AnnotatedMember m)
-    {
-        /* For maximum backwards compatibility, we better call
-         * existing methods.
-         */
-        /* TODO: For 2.0, replace with simple 'return false;'
-         */
-        if (m instanceof AnnotatedMethod) {
-            return isIgnorableMethod((AnnotatedMethod) m);
-        }
-        if (m instanceof AnnotatedField) {
-            return isIgnorableField((AnnotatedField) m);
-        }
-        if (m instanceof AnnotatedConstructor) {
-            return isIgnorableConstructor((AnnotatedConstructor) m);
-        }
-        return false;
-    }
-
-    /**
-     * Method called to find out whether given member expectes a value
-     * to be injected, and if so, what is the identifier of the value
-     * to use during injection.
-     * Type if identifier needs to be compatible with provider of
-     * values (of type {@link InjectableValues}); often a simple String
-     * id is used.
-     * 
-     * @param m Member to check
-     * 
-     * @return Identifier of value to inject, if any; null if no injection
-     *   indicator is found
-     */
-    public Object findInjectableValueId(AnnotatedMember m) {
-        return null;
-    }
-    
-    /*
-    /**********************************************************
-    /* General method annotations
-    /**********************************************************
-     */
-
-    /**
-     * Method for checking whether there is an annotation that
-     * indicates that given method should be ignored for all
-     * operations (serialization, deserialization).
-     *<p>
-     * Note that this method should <b>ONLY</b> return true for such
-     * explicit ignoral cases; and not if method just happens not to
-     * be visible for annotation processor.
-     *
-     * @return True, if an annotation is found to indicate that the
-     *    method should be ignored; false if not.
-     */
-    public abstract boolean isIgnorableMethod(AnnotatedMethod m);
-
-    /**
-     * @since 1.2
-     */
-    public abstract boolean isIgnorableConstructor(AnnotatedConstructor c);
-
-    /*
-    /**********************************************************
-    /* General field annotations
-    /**********************************************************
-     */
-
-    /**
-     * Method for checking whether there is an annotation that
-     * indicates that given field should be ignored for all
-     * operations (serialization, deserialization).
-     *
-     * @return True, if an annotation is found to indicate that the
-     *    field should be ignored; false if not.
-     */
-    public abstract boolean isIgnorableField(AnnotatedField f);
-
-    /*
-    /**********************************************************
-    /* Serialization: general annotations
-    /**********************************************************
-     */
-
-    /**
-     * Method for getting a serializer definition on specified method
-     * or field. Type of definition is either instance (of type
-     * {@link JsonSerializer}) or Class (of type
-     * <code>Class<JsonSerializer></code>); if value of different
-     * type is returned, a runtime exception may be thrown by caller.
-     *<p>
-     * Note: this variant was briefly deprecated for 1.7; should not be
-     */
-    public abstract Object findSerializer(Annotated am);
-
-    /**
-     * Method for getting a serializer definition for keys of associated <code>Map</code> property.
-     * Type of definition is either instance (of type
-     * {@link JsonSerializer}) or Class (of type
-     * <code>Class<JsonSerializer></code>); if value of different
-     * type is returned, a runtime exception may be thrown by caller.
-     * 
-     * @since 1.8
-     */
-    public Class<? extends JsonSerializer<?>> findKeySerializer(Annotated am) {
-        return null;
-    }
-
-    /**
-     * Method for getting a serializer definition for content (values) of
-     * associated <code>Collection</code>, <code>array</code> or <code>Map</code> property.
-     * Type of definition is either instance (of type
-     * {@link JsonSerializer}) or Class (of type
-     * <code>Class<JsonSerializer></code>); if value of different
-     * type is returned, a runtime exception may be thrown by caller.
-     * 
-     * @since 1.8
-     */
-    public Class<? extends JsonSerializer<?>> findContentSerializer(Annotated am) {
-        return null;
-    }
-    
-    /**
-     * Method for checking whether given annotated entity (class, method,
-     * field) defines which Bean/Map properties are to be included in
-     * serialization.
-     * If no annotation is found, method should return given second
-     * argument; otherwise value indicated by the annotation
-     *
-     * @return Enumerated value indicating which properties to include
-     *   in serialization
-     */
-    public JsonSerialize.Inclusion findSerializationInclusion(Annotated a, JsonSerialize.Inclusion defValue) {
-        return defValue;
-    }
-
-    /**
-     * Method for accessing annotated type definition that a
-     * method/field can have, to be used as the type for serialization
-     * instead of the runtime type.
-     * Type returned (if any) needs to be widening conversion (super-type).
-     * Declared return type of the method is also considered acceptable.
-     *
-     * @return Class to use instead of runtime type
-     */
-    public abstract Class<?> findSerializationType(Annotated a);
-
-    /**
-     * Method for finding possible widening type definition that a property
-     * value can have, to define less specific key type to use for serialization.
-     * It should be only be used with {@link java.util.Map} types.
-     * 
-     * @return Class specifying more general type to use instead of
-     *   declared type, if annotation found; null if not
-     */
-    public Class<?> findSerializationKeyType(Annotated am, JavaType baseType) {
-        return null;
-    }
-
-    /**
-     * Method for finding possible widening type definition that a property
-     * value can have, to define less specific key type to use for serialization.
-     * It should be only used with structured types (arrays, collections, maps).
-     * 
-     * @return Class specifying more general type to use instead of
-     *   declared type, if annotation found; null if not
-     */
-    public Class<?> findSerializationContentType(Annotated am, JavaType baseType) {
-        return null;
-    }
-    
-    /**
-     * Method for accessing declared typing mode annotated (if any).
-     * This is used for type detection, unless more granular settings
-     * (such as actual exact type; or serializer to use which means
-     * no type information is needed) take precedence.
-     *
-     * @since 1.2
-     *
-     * @return Typing mode to use, if annotation is found; null otherwise
-     */
-    public abstract JsonSerialize.Typing findSerializationTyping(Annotated a);
-
-    /**
-     * Method for checking if annotated serializable property (represented by
-     * field or getter method) has definitions for views it is to be included
-     * in. If null is returned, no view definitions exist and property is always
-     * included; otherwise it will only be included for views included in returned
-     * array. View matches are checked using class inheritance rules (sub-classes
-     * inherit inclusions of super-classes)
-     * 
-     * @param a Annotated serializable property (field or getter method)
-     * @return Array of views (represented by classes) that the property is included in;
-     *    if null, always included (same as returning array containing <code>Object.class</code>)
-     */
-    public abstract Class<?>[] findSerializationViews(Annotated a);
-    
-    /*
-    /**********************************************************
-    /* Serialization: class annotations
-    /**********************************************************
-     */
-
-    /**
-     * Method for accessing defined property serialization order (which may be
-     * partial). May return null if no ordering is defined.
-     * 
-     * @since 1.4
-     */
-    public abstract String[] findSerializationPropertyOrder(AnnotatedClass ac);
-
-    /**
-     * Method for checking whether an annotation indicates that serialized properties
-     * for which no explicit is defined should be alphabetically (lexicograpically)
-     * ordered
-     * 
-     * @since 1.4
-     */
-    public abstract Boolean findSerializationSortAlphabetically(AnnotatedClass ac);
-    
-    /*
-    /**********************************************************
-    /* Serialization: method annotations
-    /**********************************************************
-     */
-
-    /**
-     * Method for checking whether given method has an annotation
-     * that suggests property name associated with method that
-     * may be a "getter". Should return null if no annotation
-     * is found; otherwise a non-null String.
-     * If non-null value is returned, it is used as the property
-     * name, except for empty String ("") which is taken to mean
-     * "use standard bean name detection if applicable;
-     * method name if not".
-     */
-    public abstract String findGettablePropertyName(AnnotatedMethod am);
-
-    /**
-     * Method for checking whether given method has an annotation
-     * that suggests that the return value of annotated method
-     * should be used as "the value" of the object instance; usually
-     * serialized as a primitive value such as String or number.
-     *
-     * @return True if such annotation is found (and is not disabled);
-     *   false if no enabled annotation is found
-     */
-    public abstract boolean hasAsValueAnnotation(AnnotatedMethod am);
-
-    /**
-     * Method for determining the String value to use for serializing
-     * given enumeration entry; used when serializing enumerations
-     * as Strings (the standard method).
-     *
-     * @return Serialized enum value.
-     */
-    public abstract String findEnumValue(Enum<?> value);
-
-    /*
-    /**********************************************************
-    /* Serialization: field annotations
-    /**********************************************************
-     */
-
-    /**
-     * Method for checking whether given member field represent
-     * a serializable logical property; and if so, returns the
-     * name of that property.
-     * Should return null if no annotation is found (indicating it
-     * is not a serializable field); otherwise a non-null String.
-     * If non-null value is returned, it is used as the property
-     * name, except for empty String ("") which is taken to mean
-     * "use the field name as is".
-     */
-    public abstract String findSerializablePropertyName(AnnotatedField af);
-
-    /*
-    /**********************************************************
-    /* Deserialization: general annotations
-    /**********************************************************
-     */
-
-    /**
-     * Method for getting a deserializer definition on specified method
-     * or field.
-     * Type of definition is either instance (of type
-     * {@link JsonDeserializer}) or Class (of type
-     * <code>Class<JsonDeserializer></code>); if value of different
-     * type is returned, a runtime exception may be thrown by caller.
-     *<p>
-     * Note: this variant was briefly deprecated for 1.7; but it turns out
-     * we really should not try to push BeanProperty through at this point
-     */
-    public abstract Object findDeserializer(Annotated am);
-
-    /**
-     * Method for getting a deserializer definition for keys of
-     * associated <code>Map</code> property.
-     * Type of definition is either instance (of type
-     * {@link JsonDeserializer}) or Class (of type
-     * <code>Class<JsonDeserializer></code>); if value of different
-     * type is returned, a runtime exception may be thrown by caller.
-     * 
-     * @since 1.3
-     */
-    public abstract Class<? extends KeyDeserializer> findKeyDeserializer(Annotated am);
-
-    /**
-     * Method for getting a deserializer definition for content (values) of
-     * associated <code>Collection</code>, <code>array</code> or
-     * <code>Map</code> property.
-     * Type of definition is either instance (of type
-     * {@link JsonDeserializer}) or Class (of type
-     * <code>Class<JsonDeserializer></code>); if value of different
-     * type is returned, a runtime exception may be thrown by caller.
-     * 
-     * @since 1.3
-     */
-    public abstract Class<? extends JsonDeserializer<?>> findContentDeserializer(Annotated am);
-
-    /**
-     * Method for accessing annotated type definition that a
-     * method can have, to be used as the type for serialization
-     * instead of the runtime type.
-     * Type must be a narrowing conversion
-     * (i.e.subtype of declared type).
-     * Declared return type of the method is also considered acceptable.
-     *
-     * @param baseType Assumed type before considering annotations
-     * @param propName Logical property name of the property that uses
-     *    type, if known; null for types not associated with property
-     *
-     * @return Class to use for deserialization instead of declared type
-     */
-    public abstract Class<?> findDeserializationType(Annotated am, JavaType baseType,
-            String propName);
-
-    /**
-     * Method for accessing additional narrowing type definition that a
-     * method can have, to define more specific key type to use.
-     * It should be only be used with {@link java.util.Map} types.
-     * 
-     * @param baseKeyType Assumed key type before considering annotations
-     * @param propName Logical property name of the property that uses
-     *    type, if known; null for types not associated with property
-     *
-     * @return Class specifying more specific type to use instead of
-     *   declared type, if annotation found; null if not
-     */
-    public abstract Class<?> findDeserializationKeyType(Annotated am, JavaType baseKeyType,
-            String propName);
-
-    /**
-     * Method for accessing additional narrowing type definition that a
-     * method can have, to define more specific content type to use;
-     * content refers to Map values and Collection/array elements.
-     * It should be only be used with Map, Collection and array types.
-     * 
-     * @param baseContentType Assumed content (value) type before considering annotations
-     * @param propName Logical property name of the property that uses
-     *    type, if known; null for types not associated with property
-     *
-     * @return Class specifying more specific type to use instead of
-     *   declared type, if annotation found; null if not
-     */
-    public abstract Class<?> findDeserializationContentType(Annotated am, JavaType baseContentType,
-            String propName);
-
-    /*
-    /**********************************************************
-    /* Deserialization: class annotations
-    /**********************************************************
-    */
-
-    /**
-     * Method getting {@link ValueInstantiator} to use for given
-     * type (class): return value can either be an instance of
-     * instantiator, or class of instantiator to create.
-     * 
-     * @since 1.9
-     */
-    public Object findValueInstantiator(AnnotatedClass ac) {
-        return null;
-    }
-    
-    /*
-    /**********************************************************
-    /* Deserialization: method annotations
-    /**********************************************************
-     */
-
-    /**
-     * Method for checking whether given method has an annotation
-     * that suggests property name associated with method that
-     * may be a "setter". Should return null if no annotation
-     * is found; otherwise a non-null String.
-     * If non-null value is returned, it is used as the property
-     * name, except for empty String ("") which is taken to mean
-     * "use standard bean name detection if applicable;
-     * method name if not".
-     */
-    public abstract String findSettablePropertyName(AnnotatedMethod am);
-
-    /**
-     * Method for checking whether given method has an annotation
-     * that suggests that the method is to serve as "any setter";
-     * method to be used for setting values of any properties for
-     * which no dedicated setter method is found.
-     *
-     * @return True if such annotation is found (and is not disabled),
-     *   false otherwise
-     */
-    public boolean hasAnySetterAnnotation(AnnotatedMethod am) {
-        return false;
-    }
-
-    /**
-     * Method for checking whether given method has an annotation
-     * that suggests that the method is to serve as "any setter";
-     * method to be used for accessing set of miscellaneous "extra"
-     * properties, often bound with matching "any setter" method.
-     *
-     * @return True if such annotation is found (and is not disabled),
-     *   false otherwise
-     *   
-     * @since 1.6
-     */
-    public boolean hasAnyGetterAnnotation(AnnotatedMethod am) {
-        return false;
-    }
-    
-    /**
-     * Method for checking whether given annotated item (method, constructor)
-     * has an annotation
-     * that suggests that the method is a "creator" (aka factory)
-     * method to be used for construct new instances of deserialized
-     * values.
-     *
-     * @return True if such annotation is found (and is not disabled),
-     *   false otherwise
-     */
-    public boolean hasCreatorAnnotation(Annotated a) {
-        return false;
-    }
-
-    /*
-    /**********************************************************
-    /* Deserialization: field annotations
-    /**********************************************************
-     */
-
-    /**
-     * Method for checking whether given member field represent
-     * a deserializable logical property; and if so, returns the
-     * name of that property.
-     * Should return null if no annotation is found (indicating it
-     * is not a deserializable field); otherwise a non-null String.
-     * If non-null value is returned, it is used as the property
-     * name, except for empty String ("") which is taken to mean
-     * "use the field name as is".
-     */
-    public abstract String findDeserializablePropertyName(AnnotatedField af);
-
-    /*
-    /**********************************************************
-    /* Deserialization: parameter annotations (for
-    /* creator method parameters)
-    /**********************************************************
-     */
-
-    /**
-     * Method for checking whether given set of annotations indicates
-     * property name for associated parameter.
-     * No actual parameter object can be passed since JDK offers no
-     * representation; just annotations.
-     */
-    public abstract String findPropertyNameForParam(AnnotatedParameter param);
-
-    /*
-    /**********************************************************
-    /* Helper classes
-    /**********************************************************
-     */
-
-    /**
-     * Helper class that allows using 2 introspectors such that one
-     * introspector acts as the primary one to use; and second one
-     * as a fallback used if the primary does not provide conclusive
-     * or useful result for a method.
-     *<p>
-     * An obvious consequence of priority is that it is easy to construct
-     * longer chains of introspectors by linking multiple pairs.
-     * Currently most likely combination is that of using the default
-     * Jackson provider, along with JAXB annotation introspector (available
-     * since version 1.1).
-     */
-    public static class Pair
-        extends AnnotationIntrospector
-    {
-        protected final AnnotationIntrospector _primary, _secondary;
-
-        public Pair(AnnotationIntrospector p,
-                    AnnotationIntrospector s)
-        {
-            _primary = p;
-            _secondary = s;
-        }
-
-        /**
-         * Helper method for constructing a Pair from two given introspectors (if
-         * neither is null); or returning non-null introspector if one is null
-         * (and return just null if both are null)
-         * 
-         * @since 1.7
-         */
-        public static AnnotationIntrospector create(AnnotationIntrospector primary,
-                AnnotationIntrospector secondary)
-        {
-            if (primary == null) {
-                return secondary;
-            }
-            if (secondary == null) {
-                return primary;
-            }
-            return new Pair(primary, secondary);
-        }
-
-        @Override
-        public Collection<AnnotationIntrospector> allIntrospectors() {
-            return allIntrospectors(new ArrayList<AnnotationIntrospector>());
-        }
-
-        @Override
-        public Collection<AnnotationIntrospector> allIntrospectors(Collection<AnnotationIntrospector> result)
-        {
-            _primary.allIntrospectors(result);
-            _secondary.allIntrospectors(result);
-            return result;
-        }
-        
-        // // // Generic annotation properties, lookup
-        
-        @Override
-        public boolean isHandled(Annotation ann)
-        {
-            return _primary.isHandled(ann) || _secondary.isHandled(ann);
-        }
-
-        /*
-        /******************************************************
-        /* General class annotations
-        /******************************************************
-         */
-
-        @Override
-        public Boolean findCachability(AnnotatedClass ac)
-        {
-            Boolean result = _primary.findCachability(ac);
-            if (result == null) {
-                result = _secondary.findCachability(ac);
-            }
-            return result;
-        }
-
-        @Override
-        public String findRootName(AnnotatedClass ac)
-        {
-            String name1 = _primary.findRootName(ac);
-            if (name1 == null) {
-                return _secondary.findRootName(ac);
-            } else if (name1.length() > 0) {
-                return name1;
-            }
-            // name1 is empty; how about secondary?
-            String name2 = _secondary.findRootName(ac);
-            return (name2 == null) ? name1 : name2;
-        }
-
-        @Override
-        public String[] findPropertiesToIgnore(AnnotatedClass ac)
-        {
-            String[] result = _primary.findPropertiesToIgnore(ac);
-            if (result == null) {
-                result = _secondary.findPropertiesToIgnore(ac);
-            }
-            return result;            
-        }
-
-        @Override
-        public Boolean findIgnoreUnknownProperties(AnnotatedClass ac)
-        {
-            Boolean result = _primary.findIgnoreUnknownProperties(ac);
-            if (result == null) {
-                result = _secondary.findIgnoreUnknownProperties(ac);
-            }
-            return result;
-        }        
-
-        @Override
-        public Boolean isIgnorableType(AnnotatedClass ac)
-        {
-            Boolean result = _primary.isIgnorableType(ac);
-            if (result == null) {
-                result = _secondary.isIgnorableType(ac);
-            }
-            return result;
-        }
-
-        @Override
-        public Object findFilterId(AnnotatedClass ac)
-        {
-            Object id = _primary.findFilterId(ac);
-            if (id == null) {
-                id = _secondary.findFilterId(ac);
-            }
-            return id;
-        }
-        
-        /*
-        /******************************************************
-        /* Property auto-detection
-        /******************************************************
-        */
-        
-        @Override
-        public VisibilityChecker<?> findAutoDetectVisibility(AnnotatedClass ac,
-            VisibilityChecker<?> checker)
-        {
-            /* Note: to have proper priorities, we must actually call delegatees
-             * in reverse order:
-             */
-            checker = _secondary.findAutoDetectVisibility(ac, checker);
-            return _primary.findAutoDetectVisibility(ac, checker);
-        }
-
-        /*
-        /******************************************************
-        /* Type handling
-        /******************************************************
-        */
-        
-        @Override
-        public TypeResolverBuilder<?> findTypeResolver(MapperConfig<?> config,
-                AnnotatedClass ac, JavaType baseType)
-        {
-            TypeResolverBuilder<?> b = _primary.findTypeResolver(config, ac, baseType);
-            if (b == null) {
-                b = _secondary.findTypeResolver(config, ac, baseType);
-            }
-            return b;
-        }
-
-        @Override
-        public TypeResolverBuilder<?> findPropertyTypeResolver(MapperConfig<?> config,
-                AnnotatedMember am, JavaType baseType)
-        {
-            TypeResolverBuilder<?> b = _primary.findPropertyTypeResolver(config, am, baseType);
-            if (b == null) {
-                b = _secondary.findPropertyTypeResolver(config, am, baseType);
-            }
-            return b;
-        }
-
-        @Override
-        public TypeResolverBuilder<?> findPropertyContentTypeResolver(MapperConfig<?> config,
-                AnnotatedMember am, JavaType baseType)
-        {
-            TypeResolverBuilder<?> b = _primary.findPropertyContentTypeResolver(config, am, baseType);
-            if (b == null) {
-                b = _secondary.findPropertyContentTypeResolver(config, am, baseType);
-            }
-            return b;
-        }
-        
-        @Override
-        public List<NamedType> findSubtypes(Annotated a)
-        {
-            List<NamedType> types1 = _primary.findSubtypes(a);
-            List<NamedType> types2 = _secondary.findSubtypes(a);
-            if (types1 == null || types1.isEmpty()) return types2;
-            if (types2 == null || types2.isEmpty()) return types1;
-            ArrayList<NamedType> result = new ArrayList<NamedType>(types1.size() + types2.size());
-            result.addAll(types1);
-            result.addAll(types2);
-            return result;
-        }
-
-        @Override
-        public String findTypeName(AnnotatedClass ac)
-        {
-            String name = _primary.findTypeName(ac);
-            if (name == null || name.length() == 0) {
-                name = _secondary.findTypeName(ac);                
-            }
-            return name;
-        }
-        
-        // // // General member (field, method/constructor) annotations
-        
-        @Override        
-        public ReferenceProperty findReferenceType(AnnotatedMember member)
-        {
-            ReferenceProperty ref = _primary.findReferenceType(member);
-            if (ref == null) {
-                ref = _secondary.findReferenceType(member);
-            }
-            return ref; 
-        }
-
-        @Override        
-        public Boolean shouldUnwrapProperty(AnnotatedMember member)
-        {
-            Boolean value = _primary.shouldUnwrapProperty(member);
-            if (value == null) {
-                value = _secondary.shouldUnwrapProperty(member);
-            }
-            return value;
-        }
-
-        @Override
-        public Object findInjectableValueId(AnnotatedMember m)
-        {
-            Object value = _primary.findInjectableValueId(m);
-            if (value == null) {
-                value = _secondary.findInjectableValueId(m);
-            }
-            return value;
-        }
-        
-        @Override
-        public boolean hasIgnoreMarker(AnnotatedMember m) {
-            return _primary.hasIgnoreMarker(m) || _secondary.hasIgnoreMarker(m);
-        }
-        
-        // // // General method annotations
-
-        @Override
-        public boolean isIgnorableMethod(AnnotatedMethod m) {
-            return _primary.isIgnorableMethod(m) || _secondary.isIgnorableMethod(m);
-        }
-        
-        @Override
-        public boolean isIgnorableConstructor(AnnotatedConstructor c) {
-            return _primary.isIgnorableConstructor(c) || _secondary.isIgnorableConstructor(c);
-        }
-
-        // // // General field annotations
-
-        @Override
-        public boolean isIgnorableField(AnnotatedField f)
-        {
-            return _primary.isIgnorableField(f) || _secondary.isIgnorableField(f);
-        }
-
-        // // // Serialization: general annotations
-
-        @Override
-        public Object findSerializer(Annotated am)
-        {
-            Object result = _primary.findSerializer(am);
-            if (result == null) {
-                result = _secondary.findSerializer(am);
-            }
-            return result;
-        }
-        
-        @Override
-        public Class<? extends JsonSerializer<?>> findKeySerializer(Annotated a)
-        {
-            Class<? extends JsonSerializer<?>> result = _primary.findKeySerializer(a);
-            if (result == null || result == JsonSerializer.None.class) {
-                result = _secondary.findKeySerializer(a);
-            }
-            return result;
-        }
-
-        @Override
-        public Class<? extends JsonSerializer<?>> findContentSerializer(Annotated a)
-        {
-            Class<? extends JsonSerializer<?>> result = _primary.findContentSerializer(a);
-            if (result == null || result == JsonSerializer.None.class) {
-                result = _secondary.findContentSerializer(a);
-            }
-            return result;
-        }
-        
-        @Override
-        public JsonSerialize.Inclusion findSerializationInclusion(Annotated a,
-                JsonSerialize.Inclusion defValue)
-        {
-            /* This is bit trickier: need to combine results in a meaningful
-             * way. Seems like it should be a disjoint; that is, most
-             * restrictive value should be returned.
-             * For enumerations, comparison is done by indexes, which
-             * works: largest value is the last one, which is the most
-             * restrictive value as well.
-             */
-            /* 09-Mar-2010, tatu: Actually, as per [JACKSON-256], it is probably better to just
-             *    use strict overriding. Simpler, easier to understand.
-             */
-            // note: call secondary first, to give lower priority
-            defValue = _secondary.findSerializationInclusion(a, defValue);
-            defValue = _primary.findSerializationInclusion(a, defValue);
-            return defValue;
-        }
-        
-        @Override
-        public Class<?> findSerializationType(Annotated a)
-        {
-            Class<?> result = _primary.findSerializationType(a);
-            if (result == null) {
-                result = _secondary.findSerializationType(a);
-            }
-            return result;
-        }
-
-        @Override
-        public Class<?> findSerializationKeyType(Annotated am, JavaType baseType)
-        {
-            Class<?> result = _primary.findSerializationKeyType(am, baseType);
-            if (result == null) {
-                result = _secondary.findSerializationKeyType(am, baseType);
-            }
-            return result;
-        }
-
-        @Override
-        public Class<?> findSerializationContentType(Annotated am, JavaType baseType)
-        {
-            Class<?> result = _primary.findSerializationContentType(am, baseType);
-            if (result == null) {
-                result = _secondary.findSerializationContentType(am, baseType);
-            }
-            return result;
-        }
-        
-        @Override
-        public JsonSerialize.Typing findSerializationTyping(Annotated a)
-        {
-            JsonSerialize.Typing result = _primary.findSerializationTyping(a);
-            if (result == null) {
-                result = _secondary.findSerializationTyping(a);
-            }
-            return result;
-        }
-
-        @Override
-        public Class<?>[] findSerializationViews(Annotated a)
-        {
-            /* Theoretically this could be trickier, if multiple introspectors
-             * return non-null entries. For now, though, we'll just consider
-             * first one to return non-null to win.
-             */
-            Class<?>[] result = _primary.findSerializationViews(a);
-            if (result == null) {
-                result = _secondary.findSerializationViews(a);
-            }
-            return result;
-        }
-        
-        // // // Serialization: class annotations
-
-        @Override
-        public String[] findSerializationPropertyOrder(AnnotatedClass ac) {
-            String[] result = _primary.findSerializationPropertyOrder(ac);
-            if (result == null) {
-                result = _secondary.findSerializationPropertyOrder(ac);
-            }
-            return result;            
-        }
-
-        /**
-         * Method for checking whether an annotation indicates that serialized properties
-         * for which no explicit is defined should be alphabetically (lexicograpically)
-         * ordered
-         */
-        @Override
-        public Boolean findSerializationSortAlphabetically(AnnotatedClass ac) {
-            Boolean result = _primary.findSerializationSortAlphabetically(ac);
-            if (result == null) {
-                result = _secondary.findSerializationSortAlphabetically(ac);
-            }
-            return result;            
-        }
-
-        // // // Serialization: method annotations
-        
-        @Override
-        public String findGettablePropertyName(AnnotatedMethod am)
-        {
-            String result = _primary.findGettablePropertyName(am);
-            if (result == null) {
-                result = _secondary.findGettablePropertyName(am);
-            } else if (result.length() == 0) {
-                /* Empty String is a default; can be overridden by
-                 * more explicit answer from secondary entry
-                 */
-                String str2 = _secondary.findGettablePropertyName(am);
-                if (str2 != null) {
-                    result = str2;
-                }
-            }
-            return result;
-        }
-        
-        @Override
-        public boolean hasAsValueAnnotation(AnnotatedMethod am)
-        {
-            return _primary.hasAsValueAnnotation(am) || _secondary.hasAsValueAnnotation(am);
-        }
-        
-        @Override
-        public String findEnumValue(Enum<?> value)
-        {
-            String result = _primary.findEnumValue(value);
-            if (result == null) {
-                result = _secondary.findEnumValue(value);
-            }
-            return result;
-        }        
-
-        // // // Serialization: field annotations
-
-        @Override
-        public String findSerializablePropertyName(AnnotatedField af)
-        {
-            String result = _primary.findSerializablePropertyName(af);
-            if (result == null) {
-                result = _secondary.findSerializablePropertyName(af);
-            } else if (result.length() == 0) {
-                /* Empty String is a default; can be overridden by
-                 * more explicit answer from secondary entry
-                 */
-                String str2 = _secondary.findSerializablePropertyName(af);
-                if (str2 != null) {
-                    result = str2;
-                }
-            }
-            return result;
-        }
-
-        // // // Deserialization: general annotations
-
-        @Override
-        public Object findDeserializer(Annotated am)
-        {
-            Object result = _primary.findDeserializer(am);
-            if (result == null) {
-                result = _secondary.findDeserializer(am);
-            }
-            return result;
-        }
-        
-        @Override
-        public Class<? extends KeyDeserializer> findKeyDeserializer(Annotated am)
-        {
-            Class<? extends KeyDeserializer> result = _primary.findKeyDeserializer(am);
-            if (result == null || result == KeyDeserializer.None.class) {
-                result = _secondary.findKeyDeserializer(am);
-            }
-            return result;
-        }
-
-        @Override
-        public Class<? extends JsonDeserializer<?>> findContentDeserializer(Annotated am)
-        {
-            Class<? extends JsonDeserializer<?>> result = _primary.findContentDeserializer(am);
-            if (result == null || result == JsonDeserializer.None.class) {
-                result = _secondary.findContentDeserializer(am);
-            }
-            return result;
-        }
-        
-        @Override
-        public Class<?> findDeserializationType(Annotated am, JavaType baseType,
-                String propName)
-        {
-            Class<?> result = _primary.findDeserializationType(am, baseType, propName);
-            if (result == null) {
-                result = _secondary.findDeserializationType(am, baseType, propName);
-            }
-            return result;
-        }
-
-        @Override
-        public Class<?> findDeserializationKeyType(Annotated am, JavaType baseKeyType,
-                String propName)
-        {
-            Class<?> result = _primary.findDeserializationKeyType(am, baseKeyType, propName);
-            if (result == null) {
-                result = _secondary.findDeserializationKeyType(am, baseKeyType, propName);
-            }
-            return result;
-        }
-
-        @Override
-        public Class<?> findDeserializationContentType(Annotated am, JavaType baseContentType,
-                String propName)
-        {
-            Class<?> result = _primary.findDeserializationContentType(am, baseContentType, propName);
-            if (result == null) {
-                result = _secondary.findDeserializationContentType(am, baseContentType, propName);
-            }
-            return result;
-        }
-
-        // // // Deserialization: class annotations
-
-        @Override
-        public Object findValueInstantiator(AnnotatedClass ac)
-        {
-            Object result = _primary.findValueInstantiator(ac);
-            if (result == null) {
-                result = _secondary.findValueInstantiator(ac);
-            }
-            return result;
-        }
-
-        // // // Deserialization: method annotations
-
-        @Override
-        public String findSettablePropertyName(AnnotatedMethod am)
-        {
-            String result = _primary.findSettablePropertyName(am);
-            if (result == null) {
-                result = _secondary.findSettablePropertyName(am);
-            } else if (result.length() == 0) {
-                /* Empty String is a default; can be overridden by
-                 * more explicit answer from secondary entry
-                 */
-                String str2 = _secondary.findSettablePropertyName(am);
-                if (str2 != null) {
-                    result = str2;
-                }
-            }
-            return result;
-        }
-        
-        @Override
-        public boolean hasAnySetterAnnotation(AnnotatedMethod am)
-        {
-            return _primary.hasAnySetterAnnotation(am) || _secondary.hasAnySetterAnnotation(am);
-        }
-
-        @Override
-        public boolean hasAnyGetterAnnotation(AnnotatedMethod am)
-        {
-            return _primary.hasAnyGetterAnnotation(am) || _secondary.hasAnyGetterAnnotation(am);
-        }
-        
-        @Override
-        public boolean hasCreatorAnnotation(Annotated a)
-        {
-            return _primary.hasCreatorAnnotation(a) || _secondary.hasCreatorAnnotation(a);
-        }
-        
-        // // // Deserialization: field annotations
-
-        @Override
-        public String findDeserializablePropertyName(AnnotatedField af)
-        {
-            String result = _primary.findDeserializablePropertyName(af);
-            if (result == null) {
-                result = _secondary.findDeserializablePropertyName(af);
-            } else if (result.length() == 0) {
-                /* Empty String is a default; can be overridden by
-                 * more explicit answer from secondary entry
-                 */
-                String str2 = _secondary.findDeserializablePropertyName(af);
-                if (str2 != null) {
-                    result = str2;
-                }
-            }
-            return result;
-        }
-
-        // // // Deserialization: parameter annotations (for creators)
-
-        @Override
-        public String findPropertyNameForParam(AnnotatedParameter param)
-        {
-            String result = _primary.findPropertyNameForParam(param);
-            if (result == null) {
-                result = _secondary.findPropertyNameForParam(param);
-            }
-            return result;
-        }
-    }
-
-}