calabash-android 0.5.2 → 0.5.3

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

@@ -1,364 +0,0 @@
-package sh.calaba.org.codehaus.jackson.map.introspect;
-
-import java.lang.reflect.Method;
-import java.lang.reflect.Modifier;
-import java.util.*;
-
-import sh.calaba.org.codehaus.jackson.map.AnnotationIntrospector;
-import sh.calaba.org.codehaus.jackson.map.ClassIntrospector;
-import sh.calaba.org.codehaus.jackson.map.DeserializationConfig;
-import sh.calaba.org.codehaus.jackson.map.MapperConfig;
-import sh.calaba.org.codehaus.jackson.map.SerializationConfig;
-import sh.calaba.org.codehaus.jackson.map.type.SimpleType;
-import sh.calaba.org.codehaus.jackson.map.util.ClassUtil;
-import sh.calaba.org.codehaus.jackson.type.JavaType;
-
-public class BasicClassIntrospector
-    extends ClassIntrospector<BasicBeanDescription>
-{
-    /* We keep a small set of pre-constructed descriptions to use for
-     * common non-structured values, such as Numbers and Strings.
-     * This is strictly performance optimization to reduce what is
-     * usually one-time cost, but seems useful for some cases considering
-     * simplicity.
-     */
-    
-    protected final static BasicBeanDescription STRING_DESC;
-    static {
-        AnnotatedClass ac = AnnotatedClass.constructWithoutSuperTypes(String.class, null, null);
-        STRING_DESC = BasicBeanDescription.forOtherUse(null, SimpleType.constructUnsafe(String.class), ac);
-    }
-    protected final static BasicBeanDescription BOOLEAN_DESC;
-    static {
-        AnnotatedClass ac = AnnotatedClass.constructWithoutSuperTypes(Boolean.TYPE, null, null);
-        BOOLEAN_DESC = BasicBeanDescription.forOtherUse(null, SimpleType.constructUnsafe(Boolean.TYPE), ac);
-    }
-    protected final static BasicBeanDescription INT_DESC;
-    static {
-        AnnotatedClass ac = AnnotatedClass.constructWithoutSuperTypes(Integer.TYPE, null, null);
-        INT_DESC = BasicBeanDescription.forOtherUse(null, SimpleType.constructUnsafe(Integer.TYPE), ac);
-    }
-    protected final static BasicBeanDescription LONG_DESC;
-    static {
-        AnnotatedClass ac = AnnotatedClass.constructWithoutSuperTypes(Long.TYPE, null, null);
-        LONG_DESC = BasicBeanDescription.forOtherUse(null, SimpleType.constructUnsafe(Long.TYPE), ac);
-    }
-
-    
-    // // // Then static filter singletons
-    
-    /**
-     * @since 1.8
-     * @deprecated Since 1.9 just don't use
-     */
-    @Deprecated
-    public final static GetterMethodFilter DEFAULT_GETTER_FILTER = new GetterMethodFilter();
-
-    /**
-     * @since 1.8
-     * @deprecated Since 1.9 just don't use
-     */
-    @Deprecated
-    public final static SetterMethodFilter DEFAULT_SETTER_FILTER = new SetterMethodFilter();
-
-    /**
-     * @since 1.8
-     * @deprecated Since 1.9 just don't use
-     */
-    @Deprecated
-    public final static SetterAndGetterMethodFilter DEFAULT_SETTER_AND_GETTER_FILTER = new SetterAndGetterMethodFilter();
-
-    protected final static MethodFilter MINIMAL_FILTER = new MinimalMethodFilter();
-    
-    /*
-    /**********************************************************
-    /* Life cycle
-    /**********************************************************
-     */
-
-    public final static BasicClassIntrospector instance = new BasicClassIntrospector();
-
-    public BasicClassIntrospector() { }
-    
-    /*
-    /**********************************************************
-    /* Factory method impls
-    /**********************************************************
-     */
-
-    @Override
-    public BasicBeanDescription forSerialization(SerializationConfig cfg,
-            JavaType type, MixInResolver r)
-    {
-        // minor optimization: for JDK types do minimal introspection
-        BasicBeanDescription desc = _findCachedDesc(type);
-        if (desc == null) {
-            desc = BasicBeanDescription.forSerialization(collectProperties(cfg, type, r, true));
-        }
-        return desc;
-    }
-
-    @Override
-    public BasicBeanDescription forDeserialization(DeserializationConfig cfg,
-            JavaType type, MixInResolver r)
-    {
-        // minor optimization: for JDK types do minimal introspection
-        BasicBeanDescription desc = _findCachedDesc(type);
-        if (desc == null) {
-            desc = BasicBeanDescription.forDeserialization(collectProperties(cfg, type, r, false));
-        }
-        return desc;
-    }
-
-    @Override
-    public BasicBeanDescription forCreation(DeserializationConfig cfg,
-            JavaType type, MixInResolver r)
-    {
-        BasicBeanDescription desc = _findCachedDesc(type);
-        if (desc == null) {
-            desc = BasicBeanDescription.forDeserialization(collectProperties(cfg, type, r, false));
-        }
-        return desc;
-    }
-
-    @Override
-    public BasicBeanDescription forClassAnnotations(MapperConfig<?> cfg,
-            JavaType type, MixInResolver r)
-    {
-        boolean useAnnotations = cfg.isAnnotationProcessingEnabled();
-        AnnotationIntrospector ai =  cfg.getAnnotationIntrospector();
-        AnnotatedClass ac = AnnotatedClass.construct(type.getRawClass(), (useAnnotations ? ai : null), r);
-        return BasicBeanDescription.forOtherUse(cfg, type, ac);
-    }
-
-    @Override
-    public BasicBeanDescription forDirectClassAnnotations(MapperConfig<?> cfg,
-            JavaType type, MixInResolver r)
-    {
-        boolean useAnnotations = cfg.isAnnotationProcessingEnabled();
-        AnnotationIntrospector ai =  cfg.getAnnotationIntrospector();
-        AnnotatedClass ac = AnnotatedClass.constructWithoutSuperTypes(type.getRawClass(),
-                (useAnnotations ? ai : null), r);
-        return BasicBeanDescription.forOtherUse(cfg, type, ac);
-    }
-    
-    /*
-    /**********************************************************
-    /* Overridable helper methods
-    /**********************************************************
-     */
-
-    /**
-     * @since 1.9
-     */
-    public POJOPropertiesCollector collectProperties(MapperConfig<?> config,
-            JavaType type, MixInResolver r, boolean forSerialization)
-    {
-        AnnotatedClass ac = classWithCreators(config, type, r);
-        ac.resolveMemberMethods(MINIMAL_FILTER);
-        ac.resolveFields();
-        return constructPropertyCollector(config, ac, type, forSerialization).collect();
-    }
-
-    /**
-     * Overridable method called for creating {@link POJOPropertiesCollector} instance
-     * to use; override is needed if a custom sub-class is to be used.
-     * 
-     * @since 1.9
-     */
-    protected POJOPropertiesCollector constructPropertyCollector(MapperConfig<?> config,
-            AnnotatedClass ac, JavaType type,
-            boolean forSerialization)
-    {
-        return new POJOPropertiesCollector(config, forSerialization, type, ac);
-    }
-    
-    /**
-     * @since 1.9
-     */
-    public AnnotatedClass classWithCreators(MapperConfig<?> config,
-            JavaType type, MixInResolver r)
-    {
-        boolean useAnnotations = config.isAnnotationProcessingEnabled();
-        AnnotationIntrospector ai = config.getAnnotationIntrospector();
-        AnnotatedClass ac = AnnotatedClass.construct(type.getRawClass(), (useAnnotations ? ai : null), r);
-        ac.resolveMemberMethods(MINIMAL_FILTER);
-        // true -> include all creators, not just default constructor
-        ac.resolveCreators(true);
-        return ac;
-    }
-    
-    /**
-     * Method called to see if type is one of core JDK types
-     * that we have cached for efficiency.
-     * 
-     * @since 1.9
-     */
-    protected BasicBeanDescription _findCachedDesc(JavaType type)
-    {
-        Class<?> cls = type.getRawClass();
-        if (cls == String.class) {
-            return STRING_DESC;
-        }
-        if (cls == Boolean.TYPE) {
-            return BOOLEAN_DESC;
-        }
-        if (cls == Integer.TYPE) {
-            return INT_DESC;
-        }
-        if (cls == Long.TYPE) {
-            return LONG_DESC;
-        }
-        return null;
-    }
-    
-    /**
-     * Helper method for getting access to filter that only guarantees
-     * that methods used for serialization are to be included.
-     * 
-     * @deprecated Since 1.9 just don't use
-     */
-    @Deprecated
-    protected MethodFilter getSerializationMethodFilter(SerializationConfig cfg)
-    {
-    	return DEFAULT_GETTER_FILTER;
-    }
-
-    /**
-     * Helper method for getting access to filter that only guarantees
-     * that methods used for deserialization are to be included.
-     * 
-     * @deprecated Since 1.9 just don't use
-     */
-    @Deprecated
-    protected MethodFilter getDeserializationMethodFilter(DeserializationConfig cfg)
-    {
-        /* [JACKSON-88]: may also need to include getters (at least for
-         * Collection and Map types)
-         */
-        if (cfg.isEnabled(DeserializationConfig.Feature.USE_GETTERS_AS_SETTERS)) {
-            return DEFAULT_SETTER_AND_GETTER_FILTER;
-            
-        }
-    	return DEFAULT_SETTER_FILTER;
-    }
-
-    /*
-    /**********************************************************
-    /* Helper classes
-    /**********************************************************
-     */
-
-    /**
-     * Going forward, we will only do very minimal filtering;
-     * mostly just gets rid of static methods really.
-     * 
-     * @since 1.9
-     */
-    private static class MinimalMethodFilter
-        implements MethodFilter
-    {
-        @Override
-        public boolean includeMethod(Method m)
-        {
-            if (Modifier.isStatic(m.getModifiers())) {
-                return false;
-            }
-            int pcount = m.getParameterTypes().length;
-            return (pcount <= 2);
-        }
-    }
-    
-    /**
-     * Filter used to only include methods that have signature that is
-     * compatible with "getters": take no arguments, are non-static,
-     * and return something.
-     * 
-     * @deprecated Since 1.9 just don't use
-     */
-    @Deprecated
-    public static class GetterMethodFilter
-        implements MethodFilter
-    {
-        private GetterMethodFilter() { }
-    
-        @Override
-        public boolean includeMethod(Method m)
-        {
-            return ClassUtil.hasGetterSignature(m);
-        }
-    }
-
-    /**
-     * Filter used to only include methods that have signature that is
-     * compatible with "setters": take one and only argument and
-     * are non-static.
-     *<p>
-     * Actually, also need to include 2-arg  methods to support
-     * "any setters"; as well as 0-arg getters as long as they
-     * return Collection or Map type.
-     * 
-     * @deprecated Since 1.9 just don't use
-     */
-    @Deprecated
-    public static class SetterMethodFilter
-        implements MethodFilter
-    {
-        @Override
-        public boolean includeMethod(Method m)
-        {
-            // First: we can't use static methods
-            if (Modifier.isStatic(m.getModifiers())) {
-                return false;
-            }
-            int pcount = m.getParameterTypes().length;
-            // Ok; multiple acceptable parameter counts:
-            switch (pcount) {
-            case 1:
-                // Regular setters take just one param, so include:
-                return true;
-            case 2:
-                /* 2-arg version only for "AnySetters"; they are not
-                 * auto-detected, and need to have an annotation.
-                 * However, due to annotation inheritance we do, we
-                 * don't yet know if sub-classes might have annotations...
-                 * so shouldn't leave out any methods quite yet.
-                 */
-                //if (m.getAnnotation(JsonAnySetter.class) != null) { ... }
-
-                return true;
-            }
-            return false;
-        }
-    }
-    
-    /**
-     * Filter used if some getters (namely, once needed for "setterless
-     * collection injection") are also needed, not just setters.
-     * 
-     * @deprecated Since 1.9 just don't use
-     */
-    @Deprecated
-    public final static class SetterAndGetterMethodFilter
-        extends SetterMethodFilter
-    {
-        @SuppressWarnings("deprecation")
-        @Override
-        public boolean includeMethod(Method m)
-        {
-            if (super.includeMethod(m)) {
-                return true;
-            }
-            if (!ClassUtil.hasGetterSignature(m)) {
-                return false;
-            }
-            // but furthermore, only accept Collections & Maps, for now
-            Class<?> rt = m.getReturnType();
-            if (Collection.class.isAssignableFrom(rt)
-                || Map.class.isAssignableFrom(rt)) {
-                return true; 
-            }
-            return false;
-        }
-    }
-}

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

@@ -1,813 +0,0 @@
-package sh.calaba.org.codehaus.jackson.map.introspect;
-
-import java.lang.annotation.Annotation;
-import java.util.ArrayList;
-import java.util.List;
-
-import sh.calaba.org.codehaus.jackson.annotate.*;
-import sh.calaba.org.codehaus.jackson.map.*;
-import sh.calaba.org.codehaus.jackson.map.annotate.*;
-import sh.calaba.org.codehaus.jackson.map.jsontype.NamedType;
-import sh.calaba.org.codehaus.jackson.map.jsontype.TypeIdResolver;
-import sh.calaba.org.codehaus.jackson.map.jsontype.TypeResolverBuilder;
-import sh.calaba.org.codehaus.jackson.map.jsontype.impl.StdTypeResolverBuilder;
-import sh.calaba.org.codehaus.jackson.map.ser.std.RawSerializer;
-import sh.calaba.org.codehaus.jackson.type.JavaType;
-
-/**
- * {@link AnnotationIntrospector} implementation that handles standard
- * Jackson annotations.
- */
-public class JacksonAnnotationIntrospector
-    extends AnnotationIntrospector
-{
-    public JacksonAnnotationIntrospector() { }
-
-    /*
-    /**********************************************************
-    /* General annotation properties
-    /**********************************************************
-     */
-
-    @Override
-    public boolean isHandled(Annotation ann)
-    {
-        Class<? extends Annotation> acls = ann.annotationType();
-
-        /* 16-May-2009, tatu: used to check this like so...
-           final String JACKSON_PKG_PREFIX = "sh.calaba.org.codehaus.jackson";
-
-           Package pkg = acls.getPackage();
-           return (pkg != null) && (pkg.getName().startsWith(JACKSON_PKG_PREFIX));
-        */
-
-        // but this is more reliable, now that we have tag annotation:
-        return acls.getAnnotation(JacksonAnnotation.class) != null;
-    }
-
-    /*
-    /**********************************************************
-    /* General annotations
-    /**********************************************************
-     */
-
-    @Override
-    public String findEnumValue(Enum<?> value)
-    {
-        return value.name();
-    }
-    
-    /*
-    /**********************************************************
-    /* General class annotations
-    /**********************************************************
-     */
-
-    @Override
-    public Boolean findCachability(AnnotatedClass ac)
-    {
-        JsonCachable ann = ac.getAnnotation(JsonCachable.class);
-        if (ann == null) {
-            return null;
-        }
-        return ann.value() ? Boolean.TRUE : Boolean.FALSE;
-    }
-
-    @Override
-    public String findRootName(AnnotatedClass ac)
-    {
-        JsonRootName ann = ac.getAnnotation(JsonRootName.class);
-        return (ann == null) ? null : ann.value();
-    }
-
-    @Override
-    public String[] findPropertiesToIgnore(AnnotatedClass ac) {
-        JsonIgnoreProperties ignore = ac.getAnnotation(JsonIgnoreProperties.class);
-        return (ignore == null) ? null : ignore.value();
-    }
-
-    @Override
-    public Boolean findIgnoreUnknownProperties(AnnotatedClass ac) {
-        JsonIgnoreProperties ignore = ac.getAnnotation(JsonIgnoreProperties.class);
-        return (ignore == null) ? null : ignore.ignoreUnknown();
-    }
-
-    @Override
-    public Boolean isIgnorableType(AnnotatedClass ac) {
-        JsonIgnoreType ignore = ac.getAnnotation(JsonIgnoreType.class);
-        return (ignore == null) ? null : ignore.value();
-    }
-
-    @Override
-    public Object findFilterId(AnnotatedClass ac)
-    {
-        JsonFilter ann = ac.getAnnotation(JsonFilter.class);
-        if (ann != null) {
-            String id = ann.value();
-            // Empty String is same as not having annotation, to allow overrides
-            if (id.length() > 0) {
-                return id;
-            }
-        }
-        return null;
-    }
-    
-    /*
-    /**********************************************************
-    /* Property auto-detection
-    /**********************************************************
-     */
-    
-    @Override
-    public VisibilityChecker<?> findAutoDetectVisibility(AnnotatedClass ac,
-        VisibilityChecker<?> checker)
-    {
-        JsonAutoDetect ann = ac.getAnnotation(JsonAutoDetect.class);
-        return (ann == null) ? checker : checker.with(ann);
-    }
-
-    /*
-    /**********************************************************
-    /* General member (field, method/constructor) annotations
-    /**********************************************************
-     */
-
-    // @since 1.6
-    @Override        
-    public ReferenceProperty findReferenceType(AnnotatedMember member)
-    {
-        JsonManagedReference ref1 = member.getAnnotation(JsonManagedReference.class);
-        if (ref1 != null) {
-            return AnnotationIntrospector.ReferenceProperty.managed(ref1.value());
-        }
-        JsonBackReference ref2 = member.getAnnotation(JsonBackReference.class);
-        if (ref2 != null) {
-            return AnnotationIntrospector.ReferenceProperty.back(ref2.value());
-        }
-        return null;
-    }
-
-    @Override
-    public Boolean shouldUnwrapProperty(AnnotatedMember member)
-    {
-        JsonUnwrapped ann = member.getAnnotation(JsonUnwrapped.class);
-        // if not enabled, just means annotation is not enabled; not necessarily
-        // that unwrapping should not be done (relevant when using chained introspectors)
-        return (ann != null && ann.enabled()) ? Boolean.TRUE : null;
-    }
-
-    @Override
-    public boolean hasIgnoreMarker(AnnotatedMember m) {
-        return _isIgnorable(m);
-    }
-
-    @Override
-    public Object findInjectableValueId(AnnotatedMember m)
-    {
-        JacksonInject ann = m.getAnnotation(JacksonInject.class);
-        if (ann == null) {
-            return null;
-        }
-        /* Empty String means that we should use name of declared
-         * value class.
-         */
-        String id = ann.value();
-        if (id.length() == 0) {
-            // slight complication; for setters, type 
-            if (!(m instanceof AnnotatedMethod)) {
-                return m.getRawType().getName();
-            }
-            AnnotatedMethod am = (AnnotatedMethod) m;
-            if (am.getParameterCount() == 0) {
-                return m.getRawType().getName();
-            }
-            return am.getParameterClass(0).getName();
-        }
-        return id;
-    }
-    
-    /*
-    /**********************************************************
-    /* Class annotations for PM type handling (1.5+)
-    /**********************************************************
-     */
-
-    @Override
-    public TypeResolverBuilder<?> findTypeResolver(MapperConfig<?> config,
-            AnnotatedClass ac, JavaType baseType)
-    {
-        return _findTypeResolver(config, ac, baseType);
-    }
-
-    /**
-     * Since 1.7, it is possible to use {@link JsonTypeInfo} from a property too.
-     */
-    @Override
-    public TypeResolverBuilder<?> findPropertyTypeResolver(MapperConfig<?> config,
-            AnnotatedMember am, JavaType baseType)
-    {
-        /* As per definition of @JsonTypeInfo, should only apply to contents of container
-         * (collection, map) types, not container types themselves:
-         */
-        if (baseType.isContainerType()) return null;
-        // No per-member type overrides (yet)
-        return _findTypeResolver(config, am, baseType);
-    }
-
-    /**
-     * Since 1.7, it is possible to use {@link JsonTypeInfo} from a property too.
-     */
-    @Override
-    public TypeResolverBuilder<?> findPropertyContentTypeResolver(MapperConfig<?> config,
-            AnnotatedMember am, JavaType containerType)
-    {
-        /* First: let's ensure property is a container type: caller should have
-         * verified but just to be sure
-         */
-        if (!containerType.isContainerType()) {
-            throw new IllegalArgumentException("Must call method with a container type (got "+containerType+")");
-        }
-        return _findTypeResolver(config, am, containerType);
-    }
-    
-    @Override
-    public List<NamedType> findSubtypes(Annotated a)
-    {
-        JsonSubTypes t = a.getAnnotation(JsonSubTypes.class);
-        if (t == null) return null;
-        JsonSubTypes.Type[] types = t.value();
-        ArrayList<NamedType> result = new ArrayList<NamedType>(types.length);
-        for (JsonSubTypes.Type type : types) {
-            result.add(new NamedType(type.value(), type.name()));
-        }
-        return result;
-    }
-
-    @Override        
-    public String findTypeName(AnnotatedClass ac)
-    {
-        JsonTypeName tn = ac.getAnnotation(JsonTypeName.class);
-        return (tn == null) ? null : tn.value();
-    }
-    
-    /*
-    /**********************************************************
-    /* General method annotations
-    /**********************************************************
-    */
-
-    @Override
-    public boolean isIgnorableMethod(AnnotatedMethod m) {
-        return _isIgnorable(m);
-    }
-
-    @Override
-    public boolean isIgnorableConstructor(AnnotatedConstructor c) {
-        return _isIgnorable(c);
-    }
-
-    /*
-    /**********************************************************
-    /* General field annotations
-    /**********************************************************
-     */
-
-    @Override
-    public boolean isIgnorableField(AnnotatedField f) {
-        return _isIgnorable(f);
-    }
-
-    /*
-    /**********************************************************
-    /* Serialization: general annotations
-    /**********************************************************
-    */
-
-    @Override
-    public Object findSerializer(Annotated a)
-    {
-        /* 21-May-2009, tatu: Slight change; primary annotation is now
-         *    @JsonSerialize; @JsonUseSerializer is deprecated
-         */
-        JsonSerialize ann = a.getAnnotation(JsonSerialize.class);
-        if (ann != null) {
-            Class<? extends JsonSerializer<?>> serClass = ann.using();
-            if (serClass != JsonSerializer.None.class) {
-                return serClass;
-            }
-        }
-        
-        /* 18-Oct-2010, tatu: [JACKSON-351] @JsonRawValue handled just here, for now;
-         *  if we need to get raw indicator from other sources need to add
-         *  separate accessor within {@link AnnotationIntrospector} interface.
-         */
-        JsonRawValue annRaw =  a.getAnnotation(JsonRawValue.class);
-        if ((annRaw != null) && annRaw.value()) {
-            // let's construct instance with nominal type:
-            Class<?> cls = a.getRawType();
-            return new RawSerializer<Object>(cls);
-        }       
-        return null;
-    }
-
-    @Override
-    public Class<? extends JsonSerializer<?>> findKeySerializer(Annotated a)
-    {
-        JsonSerialize ann = a.getAnnotation(JsonSerialize.class);
-        if (ann != null) {
-            Class<? extends JsonSerializer<?>> serClass = ann.keyUsing();
-            if (serClass != JsonSerializer.None.class) {
-                return serClass;
-            }
-        }
-        return null;
-    }
-
-    @Override
-    public Class<? extends JsonSerializer<?>> findContentSerializer(Annotated a)
-    {
-        JsonSerialize ann = a.getAnnotation(JsonSerialize.class);
-        if (ann != null) {
-            Class<? extends JsonSerializer<?>> serClass = ann.contentUsing();
-            if (serClass != JsonSerializer.None.class) {
-                return serClass;
-            }
-        }
-        return null;
-    }
-    
-    @SuppressWarnings("deprecation")
-    @Override
-    public JsonSerialize.Inclusion findSerializationInclusion(Annotated a, JsonSerialize.Inclusion defValue)
-    {
-        JsonSerialize ann = a.getAnnotation(JsonSerialize.class);
-        if (ann != null) {
-            return ann.include();
-        }
-        /* 23-May-2009, tatu: Will still support now-deprecated (as of 1.1)
-         *   legacy annotation too:
-         */
-        JsonWriteNullProperties oldAnn = a.getAnnotation(JsonWriteNullProperties.class);
-        if (oldAnn != null) {
-            boolean writeNulls = oldAnn.value();
-            return writeNulls ? JsonSerialize.Inclusion.ALWAYS : JsonSerialize.Inclusion.NON_NULL;
-        }
-        return defValue;
-    }
-
-    @Override
-    public Class<?> findSerializationType(Annotated am)
-    {
-        JsonSerialize ann = am.getAnnotation(JsonSerialize.class);
-        if (ann != null) {
-            Class<?> cls = ann.as();
-            if (cls != NoClass.class) {
-                return cls;
-            }
-        }
-        return null;
-    }
-
-    @Override
-    public Class<?> findSerializationKeyType(Annotated am, JavaType baseType)
-    {
-        JsonSerialize ann = am.getAnnotation(JsonSerialize.class);
-        if (ann != null) {
-            Class<?> cls = ann.keyAs();
-            if (cls != NoClass.class) {
-                return cls;
-            }
-        }
-        return null;
-    }
-
-    @Override
-    public Class<?> findSerializationContentType(Annotated am, JavaType baseType)
-    {
-        JsonSerialize ann = am.getAnnotation(JsonSerialize.class);
-        if (ann != null) {
-            Class<?> cls = ann.contentAs();
-            if (cls != NoClass.class) {
-                return cls;
-            }
-        }
-        return null;
-    }
-    
-    @Override
-    public JsonSerialize.Typing findSerializationTyping(Annotated a)
-    {
-        JsonSerialize ann = a.getAnnotation(JsonSerialize.class);
-        return (ann == null) ? null : ann.typing();
-    }
-
-    @Override
-    public Class<?>[] findSerializationViews(Annotated a)
-    {
-        JsonView ann = a.getAnnotation(JsonView.class);
-        return (ann == null) ? null : ann.value();
-    }
-    
-    /*
-    /**********************************************************
-    /* Serialization: class annotations
-    /**********************************************************
-     */
-
-    @Override
-    public String[] findSerializationPropertyOrder(AnnotatedClass ac) {
-        JsonPropertyOrder order = ac.getAnnotation(JsonPropertyOrder.class);
-        return (order == null) ? null : order.value();
-    }
-
-    @Override
-    public Boolean findSerializationSortAlphabetically(AnnotatedClass ac) {
-        JsonPropertyOrder order = ac.getAnnotation(JsonPropertyOrder.class);
-        return (order == null) ? null : order.alphabetic();
-    }
-
-    /*
-    /**********************************************************
-    /* Serialization: method annotations
-    /**********************************************************
-     */
-
-    @SuppressWarnings("deprecation")
-    @Override
-    public String findGettablePropertyName(AnnotatedMethod am)
-    {
-        /* 22-May-2009, tatu: JsonProperty is the primary annotation
-         *   to check for
-         */
-        JsonProperty pann = am.getAnnotation(JsonProperty.class);
-        if (pann != null) {
-            return pann.value();
-        }
-        /* 22-May-2009, tatu: JsonGetter is deprecated as of 1.1
-         *    but still supported
-         */
-        JsonGetter ann = am.getAnnotation(JsonGetter.class);
-        if (ann != null) {
-            return ann.value();
-        }
-        /* 22-May-2009, tatu: And finally, JsonSerialize implies
-         *   that there is a property, although doesn't define name
-         */
-        // 09-Apr-2010, tatu: Ditto for JsonView
-        if (am.hasAnnotation(JsonSerialize.class) || am.hasAnnotation(JsonView.class)) {
-            return "";
-        }
-        return null;
-    }
-
-    @Override
-    public boolean hasAsValueAnnotation(AnnotatedMethod am)
-    {
-        JsonValue ann = am.getAnnotation(JsonValue.class);
-        // value of 'false' means disabled...
-        return (ann != null && ann.value());
-    }
-
-    /*
-    /**********************************************************
-    /* Serialization: field annotations
-    /**********************************************************
-    */
-
-    @Override
-    public String findSerializablePropertyName(AnnotatedField af)
-    {
-        JsonProperty pann = af.getAnnotation(JsonProperty.class);
-        if (pann != null) {
-            return pann.value();
-        }
-        // Also: having JsonSerialize implies it is such a property
-        // 09-Apr-2010, tatu: Ditto for JsonView
-        if (af.hasAnnotation(JsonSerialize.class) || af.hasAnnotation(JsonView.class)) {
-            return "";
-        }
-        return null;
-    }
-
-    /*
-    /**********************************************************
-    /* Deserialization: general annotations
-    /**********************************************************
-     */
-
-    @Override
-    public Class<? extends JsonDeserializer<?>> findDeserializer(Annotated a)
-    {
-        /* 21-May-2009, tatu: Slight change; primary annotation is now
-         *    @JsonDeserialize; @JsonUseDeserializer is deprecated
-         */
-        JsonDeserialize ann = a.getAnnotation(JsonDeserialize.class);
-        if (ann != null) {
-            Class<? extends JsonDeserializer<?>> deserClass = ann.using();
-            if (deserClass != JsonDeserializer.None.class) {
-                return deserClass;
-            }
-        }
-        // 31-Jan-2010, tatus: @JsonUseDeserializer removed as of 1.5
-        return null;
-    }
-
-    @Override
-    public Class<? extends KeyDeserializer> findKeyDeserializer(Annotated a)
-    {
-        JsonDeserialize ann = a.getAnnotation(JsonDeserialize.class);
-        if (ann != null) {
-            Class<? extends KeyDeserializer> deserClass = ann.keyUsing();
-            if (deserClass != KeyDeserializer.None.class) {
-                return deserClass;
-            }
-        }
-        return null;
-    }
-
-    @Override
-    public Class<? extends JsonDeserializer<?>> findContentDeserializer(Annotated a)
-    {
-        JsonDeserialize ann = a.getAnnotation(JsonDeserialize.class);
-        if (ann != null) {
-            Class<? extends JsonDeserializer<?>> deserClass = ann.contentUsing();
-            if (deserClass != JsonDeserializer.None.class) {
-                return deserClass;
-            }
-        }
-        return null;
-    }
-
-    @Override
-    public Class<?> findDeserializationType(Annotated am, JavaType baseType,
-            String propName)
-    {
-        // Primary annotation, JsonDeserialize
-        JsonDeserialize ann = am.getAnnotation(JsonDeserialize.class);
-        if (ann != null) {
-            Class<?> cls = ann.as();
-            if (cls != NoClass.class) {
-                return cls;
-            }
-        }
-        /* 30-Jun-2011, tatu: Here we used to have support for @JsonClass;
-         *    removed in 1.9
-         */
-        return null;
-    }
-
-    @Override
-    public Class<?> findDeserializationKeyType(Annotated am, JavaType baseKeyType,
-            String propName)
-    {
-        // Primary annotation, JsonDeserialize
-        JsonDeserialize ann = am.getAnnotation(JsonDeserialize.class);
-        if (ann != null) {
-            Class<?> cls = ann.keyAs();
-            if (cls != NoClass.class) {
-                return cls;
-            }
-        }
-        /* 30-Jun-2011, tatu: Here we used to have support for @JsonKeyClass;
-         *    removed in 1.9
-         */
-        return null;
-    }
-
-    @Override
-    public Class<?> findDeserializationContentType(Annotated am, JavaType baseContentType,
-            String propName)
-    {
-        // Primary annotation, JsonDeserialize
-        JsonDeserialize ann = am.getAnnotation(JsonDeserialize.class);
-        if (ann != null) {
-            Class<?> cls = ann.contentAs();
-            if (cls != NoClass.class) {
-                return cls;
-            }
-        }
-        /* 30-Jun-2011, tatu: Here we used to have support for @JsonContentClass;
-         *    removed in 1.9
-         */
-        return null;
-    }
-
-    /*
-    /**********************************************************
-    /* Deserialization: Class annotations
-    /**********************************************************
-     */
-    
-    @Override
-    public Object findValueInstantiator(AnnotatedClass ac)
-    {
-        JsonValueInstantiator ann = ac.getAnnotation(JsonValueInstantiator.class);
-        // no 'null' marker yet, so:
-        return (ann == null) ? null : ann.value();
-    }
-    
-    /*
-    /**********************************************************
-    /* Deserialization: Method annotations
-    /**********************************************************
-     */
-
-    @Override
-    public String findSettablePropertyName(AnnotatedMethod am)
-    {
-        /* 16-Apr-2010, tatu: Existing priority (since 1.1) is that
-         *   @JsonProperty is checked first; and @JsonSetter next.
-         *   This is not quite optimal now that @JsonSetter is un-deprecated.
-         *   However, it is better to have stable behavior rather than
-         *   cause compatibility problems by fine-tuning.
-         */
-        JsonProperty pann = am.getAnnotation(JsonProperty.class);
-        if (pann != null) {
-            return pann.value();
-        }
-        JsonSetter ann = am.getAnnotation(JsonSetter.class);
-        if (ann != null) {
-            return ann.value();
-        }
-        /* 22-May-2009, tatu: And finally, JsonSerialize implies
-         *   that there is a property, although doesn't define name
-         */
-        // 09-Apr-2010, tatu: Ditto for JsonView
-        // 19-Oct-2011, tatu: And JsonBackReference/JsonManagedReference
-    	if (am.hasAnnotation(JsonDeserialize.class)
-    	        || am.hasAnnotation(JsonView.class)
-                || am.hasAnnotation(JsonBackReference.class)
-                || am.hasAnnotation(JsonManagedReference.class)
-    	        ) {
-            return "";
-        }
-        return null;
-    }
-
-    @Override
-    public boolean hasAnySetterAnnotation(AnnotatedMethod am)
-    {
-        /* No dedicated disabling; regular @JsonIgnore used
-         * if needs to be ignored (and if so, is handled prior
-         * to this method getting called)
-         */
-        return am.hasAnnotation(JsonAnySetter.class);
-    }
-
-    @Override
-    public boolean hasAnyGetterAnnotation(AnnotatedMethod am)
-    {
-        /* No dedicated disabling; regular @JsonIgnore used
-         * if needs to be ignored (handled separately
-         */
-        return am.hasAnnotation(JsonAnyGetter.class);
-    }
-    
-    @Override
-    public boolean hasCreatorAnnotation(Annotated a)
-    {
-        /* No dedicated disabling; regular @JsonIgnore used
-         * if needs to be ignored (and if so, is handled prior
-         * to this method getting called)
-         */
-        return a.hasAnnotation(JsonCreator.class);
-    }
-
-    /*
-    /**********************************************************
-    /* Deserialization: field annotations
-    /**********************************************************
-     */
-
-    @Override
-    public String findDeserializablePropertyName(AnnotatedField af)
-    {
-        JsonProperty pann = af.getAnnotation(JsonProperty.class);
-        if (pann != null) {
-            return pann.value();
-        }
-        // Also: having JsonDeserialize implies it is such a property
-        // 09-Apr-2010, tatu: Ditto for JsonView
-        if (af.hasAnnotation(JsonDeserialize.class)
-                || af.hasAnnotation(JsonView.class)
-                || af.hasAnnotation(JsonBackReference.class)
-                || af.hasAnnotation(JsonManagedReference.class)
-                ) {
-            return "";
-        }
-        return null;
-    }
-
-    /*
-    /**********************************************************
-    /* Deserialization: parameters annotations
-    /**********************************************************
-     */
-
-    @Override
-    public String findPropertyNameForParam(AnnotatedParameter param)
-    {
-        if (param != null) {
-            JsonProperty pann = param.getAnnotation(JsonProperty.class);
-            if (pann != null) {
-                return pann.value();
-            }
-            /* And can not use JsonDeserialize as we can not use
-             * name auto-detection (names of local variables including
-             * parameters are not necessarily preserved in bytecode)
-             */
-        }
-        return null;
-    }
-
-    /*
-    /**********************************************************
-    /* Helper methods
-    /**********************************************************
-     */
-
-    protected boolean _isIgnorable(Annotated a)
-    {
-        JsonIgnore ann = a.getAnnotation(JsonIgnore.class);
-        return (ann != null && ann.value());
-    }
-
-    /**
-     * Helper method called to construct and initialize instance of {@link TypeResolverBuilder}
-     * if given annotated element indicates one is needed.
-     */
-    protected TypeResolverBuilder<?> _findTypeResolver(MapperConfig<?> config,
-            Annotated ann, JavaType baseType)
-    {
-        // First: maybe we have explicit type resolver?
-        TypeResolverBuilder<?> b;
-        JsonTypeInfo info = ann.getAnnotation(JsonTypeInfo.class);
-        JsonTypeResolver resAnn = ann.getAnnotation(JsonTypeResolver.class);
-        if (resAnn != null) {
-            /* 14-Aug-2010, tatu: not sure if this can ever happen normally, but unit
-             *    tests were able to trigger this... so let's check:
-             */
-            if (info == null) {
-                return null;
-            }
-            /* let's not try to force access override (would need to pass
-             * settings through if we did, since that's not doable on some
-             * platforms)
-             */
-            b = config.typeResolverBuilderInstance(ann, resAnn.value());
-        } else { // if not, use standard one, if indicated by annotations
-            if (info == null) {
-                return null;
-            }
-            // bit special; must return 'marker' to block use of default typing:
-            if (info.use() == JsonTypeInfo.Id.NONE) {
-                return _constructNoTypeResolverBuilder();
-            }
-            b = _constructStdTypeResolverBuilder();
-        }
-        // Does it define a custom type id resolver?
-        JsonTypeIdResolver idResInfo = ann.getAnnotation(JsonTypeIdResolver.class);
-        TypeIdResolver idRes = (idResInfo == null) ? null
-                : config.typeIdResolverInstance(ann, idResInfo.value());
-        if (idRes != null) { // [JACKSON-359]
-            idRes.init(baseType);
-        }
-        b = b.init(info.use(), idRes);
-        /* 13-Aug-2011, tatu: One complication wrt [JACKSON-453]; external id
-         *   only works for properties; so if declared for a Class, we will need
-         *   to map it to "PROPERTY" instead of "EXTERNAL_PROPERTY"
-         */
-        JsonTypeInfo.As inclusion = info.include();
-        if (inclusion == JsonTypeInfo.As.EXTERNAL_PROPERTY && (ann instanceof AnnotatedClass)) {
-            inclusion = JsonTypeInfo.As.PROPERTY;
-        }
-        b = b.inclusion(inclusion);
-        b = b.typeProperty(info.property());
-        Class<?> defaultImpl = info.defaultImpl();
-        if (defaultImpl != JsonTypeInfo.None.class) {
-            b = b.defaultImpl(defaultImpl);
-        }
-        return b;
-    }
-
-    /**
-     * Helper method for constructing standard {@link TypeResolverBuilder}
-     * implementation.
-     * 
-     * @since 1.7
-     */
-    protected StdTypeResolverBuilder _constructStdTypeResolverBuilder()
-    {
-        return new StdTypeResolverBuilder();
-    }
-
-    /**
-     * Helper method for dealing with "no type info" marker; can't be null
-     * (as it'd be replaced by default typing)
-     * 
-     * @since 1.9.4
-     */
-    protected StdTypeResolverBuilder _constructNoTypeResolverBuilder() {
-        return StdTypeResolverBuilder.noTypeInfoBuilder();
-    }    
-}