calabash-android 0.5.2 → 0.5.3

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

@@ -1,101 +0,0 @@
-package sh.calaba.org.codehaus.jackson.map.introspect;
-
-import java.lang.annotation.Annotation;
-import java.util.*;
-
-import sh.calaba.org.codehaus.jackson.map.util.Annotations;
-
-/**
- * Simple helper class used to keep track of collection of
- * Jackson Annotations associated with annotatable things
- * (methods, constructors, classes).
- * Note that only Jackson-owned annotations are tracked (for now?).
- */
-public final class AnnotationMap implements Annotations
-{
-    protected HashMap<Class<? extends Annotation>,Annotation> _annotations;
-
-    public AnnotationMap() { }
-    private AnnotationMap(HashMap<Class<? extends Annotation>,Annotation> a) {
-        _annotations = a;
-    }
-
-    @SuppressWarnings("unchecked")
-    @Override
-    public <A extends Annotation> A get(Class<A> cls)
-    {
-        if (_annotations == null) {
-            return null;
-        }
-        return (A) _annotations.get(cls);
-    }
-
-    public static AnnotationMap merge(AnnotationMap primary, AnnotationMap secondary)
-    {
-        if (primary == null || primary._annotations == null || primary._annotations.isEmpty()) {
-            return secondary;
-        }
-        if (secondary == null || secondary._annotations == null || secondary._annotations.isEmpty()) {
-            return primary;
-        }
-        HashMap<Class<? extends Annotation>,Annotation> annotations
-            = new HashMap<Class<? extends Annotation>,Annotation>();
-        // add secondary ones first
-        for (Annotation ann : secondary._annotations.values()) {
-            annotations.put(ann.annotationType(), ann);
-        }
-        // to be overridden by primary ones
-        for (Annotation ann : primary._annotations.values()) {
-            annotations.put(ann.annotationType(), ann);
-        }
-        return new AnnotationMap(annotations);
-    }
-    
-    @Override
-    public int size() {
-        return (_annotations == null) ? 0 : _annotations.size();
-    }
-
-    /**
-     * Method called to add specified annotation in the Map, but
-     * only if it didn't yet exist.
-     */
-    public void addIfNotPresent(Annotation ann)
-    {
-        if (_annotations == null || !_annotations.containsKey(ann.annotationType())) {
-            _add(ann);
-        }
-    }
-
-    /**
-     * Method called to add specified annotation in the Map.
-     */
-    public void add(Annotation ann) {
-        _add(ann);
-    }
-
-    @Override
-    public String toString()
-    {
-        if (_annotations == null) {
-            return "[null]";
-        }
-        return _annotations.toString();
-    }
-
-    /*
-    /**********************************************************
-    /* Helper methods
-    /**********************************************************
-     */
-
-    protected final void _add(Annotation ann)
-    {
-        if (_annotations == null) {
-            _annotations = new HashMap<Class<? extends Annotation>,Annotation>();
-        }
-        _annotations.put(ann.annotationType(), ann);
-    }
-}
-
-

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

@@ -1,615 +0,0 @@
-package sh.calaba.org.codehaus.jackson.map.introspect;
-
-import java.lang.reflect.Constructor;
-import java.lang.reflect.Method;
-import java.util.*;
-
-import sh.calaba.org.codehaus.jackson.map.*;
-import sh.calaba.org.codehaus.jackson.map.annotate.JsonSerialize;
-import sh.calaba.org.codehaus.jackson.map.type.TypeBindings;
-import sh.calaba.org.codehaus.jackson.map.util.Annotations;
-import sh.calaba.org.codehaus.jackson.type.JavaType;
-
-/**
- * Default {@link BeanDescription} implementation.
- * Can theoretically be subclassed to customize
- * some aspects of property introspection.
- */
-public class BasicBeanDescription extends BeanDescription
-{
-    /*
-    /**********************************************************
-    /* General configuration
-    /**********************************************************
-     */
-
-    final protected MapperConfig<?> _config;
-
-    final protected AnnotationIntrospector _annotationIntrospector;
-    
-    /**
-     * Information collected about the class introspected.
-     */
-    final protected AnnotatedClass _classInfo;
-    
-    /**
-     * We may need type bindings for the bean type. If so, we'll
-     * construct it lazily
-     */
-    protected TypeBindings _bindings;
-
-    /*
-    /**********************************************************
-    /* Member information
-    /**********************************************************
-     */
-
-    /**
-     * Properties collected for the POJO.
-     */
-    protected final List<BeanPropertyDefinition> _properties;
-
-    // // for deserialization
-    
-    protected AnnotatedMethod _anySetterMethod;
-
-    protected Map<Object, AnnotatedMember> _injectables;
-    
-    /**
-     * Set of properties that can be ignored during deserialization, due
-     * to being marked as ignored.
-     */
-    protected Set<String> _ignoredPropertyNames;
-
-    /**
-     * @since 1.9.4
-     */
-    protected Set<String> _ignoredPropertyNamesForDeser;
-    
-    // // for serialization
-    
-    protected AnnotatedMethod _jsonValueMethod;
-
-    protected AnnotatedMethod _anyGetterMethod;
-    
-    /*
-    /**********************************************************
-    /* Life-cycle
-    /**********************************************************
-     */
-    
-    /**
-     * @deprecated Since 1.9, should use factory methods instead
-     */
-    @Deprecated
-    public BasicBeanDescription(MapperConfig<?> config, JavaType type,
-            AnnotatedClass ac)
-    {
-        this(config, type, ac, Collections.<BeanPropertyDefinition>emptyList());
-    }
-
-    /**
-     * @since 1.9
-     */
-    protected BasicBeanDescription(MapperConfig<?> config, JavaType type,
-            AnnotatedClass ac, List<BeanPropertyDefinition> properties)
-    {
-    	super(type);
-    	_config = config;
-    	_annotationIntrospector = (config == null) ? null : config.getAnnotationIntrospector();
-    	_classInfo = ac;
-    	_properties = properties;
-    }
-
-    /**
-     * Factory method to use for constructing an instance to use for building
-     * deserializers.
-     * 
-     * @since 1.9
-     */
-    public static BasicBeanDescription forDeserialization(POJOPropertiesCollector coll)
-    {
-        BasicBeanDescription desc = new BasicBeanDescription(coll.getConfig(),
-                coll.getType(), coll.getClassDef(), coll.getProperties());
-        desc._anySetterMethod = coll.getAnySetterMethod();
-        desc._ignoredPropertyNames = coll.getIgnoredPropertyNames();
-        desc._ignoredPropertyNamesForDeser = coll.getIgnoredPropertyNamesForDeser();
-        desc._injectables = coll.getInjectables();
-        return desc;
-    }
-
-    /**
-     * Factory method to use for constructing an instance to use for building
-     * serializers.
-     * 
-     * @since 1.9
-     */
-    public static BasicBeanDescription forSerialization(POJOPropertiesCollector coll)
-    {
-        BasicBeanDescription desc = new BasicBeanDescription(coll.getConfig(),
-                coll.getType(), coll.getClassDef(), coll.getProperties());
-        desc._jsonValueMethod = coll.getJsonValueMethod();
-        desc._anyGetterMethod = coll.getAnyGetterMethod();
-        return desc;
-    }
-
-    /**
-     * Factory method to use for constructing an instance to use for purposes
-     * other than building serializers or deserializers; will only have information
-     * on class, not on properties.
-     * 
-     * @since 1.9
-     */
-    public static BasicBeanDescription forOtherUse(MapperConfig<?> config,
-            JavaType type, AnnotatedClass ac)
-    {
-        return new BasicBeanDescription(config, type,
-                ac, Collections.<BeanPropertyDefinition>emptyList());
-    }
-    
-    /*
-    /**********************************************************
-    /* Simple accessors from BeanDescription
-    /**********************************************************
-     */
-
-    /**        
-     * @since 1.9
-     */
-    @Override
-    public AnnotatedClass getClassInfo() { return _classInfo; }
-    
-    @Override
-    public List<BeanPropertyDefinition> findProperties() {
-        return _properties;
-    }
-
-    /**
-     * Method for locating the getter method that is annotated with
-     * {@link sh.calaba.org.codehaus.jackson.annotate.JsonValue} annotation,
-     * if any. If multiple ones are found,
-     * an error is reported by throwing {@link IllegalArgumentException}
-     */
-    @Override
-    public AnnotatedMethod findJsonValueMethod()
-    {
-        return _jsonValueMethod;
-    }
-
-    @Override
-    public Set<String> getIgnoredPropertyNames() {
-        if (_ignoredPropertyNames == null) {
-            return Collections.emptySet();
-        }
-        return _ignoredPropertyNames;
-    }
-
-    public Set<String> getIgnoredPropertyNamesForDeser() {
-        return _ignoredPropertyNamesForDeser;
-    }
-    
-    /**
-     * Method for checking whether class being described has any
-     * annotations recognized by registered annotation introspector.
-     */
-    @Override
-    public boolean hasKnownClassAnnotations() {
-        return _classInfo.hasAnnotations();
-    }
-
-    @Override
-    public Annotations getClassAnnotations() {
-        return _classInfo.getAnnotations();
-    }
-
-    @Override
-    public TypeBindings bindingsForBeanType()
-    {
-        if (_bindings == null) {
-            _bindings = new TypeBindings(_config.getTypeFactory(), _type);
-        }
-        return _bindings;
-    }
-
-    @Override
-    public JavaType resolveType(java.lang.reflect.Type jdkType) {
-        if (jdkType == null) {
-            return null;
-        }
-        return bindingsForBeanType().resolveType(jdkType);
-    }
-
-    /**
-     * Method that will locate the no-arg constructor for this class,
-     * if it has one, and that constructor has not been marked as
-     * ignorable.
-     * 
-     * @since 1.9
-     */
-    @Override
-    public AnnotatedConstructor findDefaultConstructor()
-    {
-        return _classInfo.getDefaultConstructor();
-    }
-
-    /**
-     * Method used to locate the method of introspected class that
-     * implements {@link sh.calaba.org.codehaus.jackson.annotate.JsonAnySetter}. If no such method exists
-     * null is returned. If more than one are found, an exception
-     * is thrown.
-     * Additional checks are also made to see that method signature
-     * is acceptable: needs to take 2 arguments, first one String or
-     * Object; second any can be any type.
-     */
-    @Override
-    public AnnotatedMethod findAnySetter() throws IllegalArgumentException
-    {
-        if (_anySetterMethod != null) {
-            /* Also, let's be somewhat strict on how field name is to be
-             * passed; String, Object make sense, others not
-             * so much.
-             */
-            /* !!! 18-May-2009, tatu: how about enums? Can add support if
-             *  requested; easy enough for devs to add support within
-             *  method.
-             */
-            Class<?> type = _anySetterMethod.getParameterClass(0);
-            if (type != String.class && type != Object.class) {
-                throw new IllegalArgumentException("Invalid 'any-setter' annotation on method "+_anySetterMethod.getName()+"(): first argument not of type String or Object, but "+type.getName());
-            }
-        }
-        return _anySetterMethod;
-    }
-
-    @Override
-    public Map<Object, AnnotatedMember> findInjectables()
-    {
-        return _injectables;
-    }
-    
-    public List<AnnotatedConstructor> getConstructors()
-    {
-        return _classInfo.getConstructors();
-    }
-    
-    /*
-    /**********************************************************
-    /* Simple accessors, extended
-    /**********************************************************
-     */
-
-    public AnnotatedMethod findMethod(String name, Class<?>[] paramTypes)
-    {
-        return _classInfo.findMethod(name, paramTypes);
-    }
-
-    /**
-     * Method called to create a "default instance" of the bean, currently
-     * only needed for obtaining default field values which may be used for
-     * suppressing serialization of fields that have "not changed".
-     * 
-     * @param fixAccess If true, method is allowed to fix access to the
-     *   default constructor (to be able to call non-public constructor);
-     *   if false, has to use constructor as is.
-     *
-     * @return Instance of class represented by this descriptor, if
-     *   suitable default constructor was found; null otherwise.
-     */
-    public Object instantiateBean(boolean fixAccess)
-    {
-        AnnotatedConstructor ac = _classInfo.getDefaultConstructor();
-        if (ac == null) {
-            return null;
-        }
-        if (fixAccess) {
-            ac.fixAccess();
-        }
-        try {
-            return ac.getAnnotated().newInstance();
-        } catch (Exception e) {
-            Throwable t = e;
-            while (t.getCause() != null) {
-                t = t.getCause();
-            }
-            if (t instanceof Error) throw (Error) t;
-            if (t instanceof RuntimeException) throw (RuntimeException) t;
-            throw new IllegalArgumentException("Failed to instantiate bean of type "+_classInfo.getAnnotated().getName()+": ("+t.getClass().getName()+") "+t.getMessage(), t);
-        }
-    }
-
-    /*
-    /**********************************************************
-    /* Introspection for serialization, factories
-    /**********************************************************
-     */
-
-    public List<AnnotatedMethod> getFactoryMethods()
-    {
-        // must filter out anything that clearly is not a factory method
-        List<AnnotatedMethod> candidates = _classInfo.getStaticMethods();
-        if (candidates.isEmpty()) {
-            return candidates;
-        }
-        ArrayList<AnnotatedMethod> result = new ArrayList<AnnotatedMethod>();
-        for (AnnotatedMethod am : candidates) {
-            if (isFactoryMethod(am)) {
-                result.add(am);
-            }
-        }
-        return result;
-    }
-
-    /**
-     * Method that can be called to locate a single-arg constructor that
-     * takes specified exact type (will not accept supertype constructors)
-     *
-     * @param argTypes Type(s) of the argument that we are looking for
-     */
-    public Constructor<?> findSingleArgConstructor(Class<?>... argTypes)
-    {
-        for (AnnotatedConstructor ac : _classInfo.getConstructors()) {
-            // This list is already filtered to only include accessible
-            /* (note: for now this is a redundant check; but in future
-             * that may change; thus leaving here for now)
-             */
-            if (ac.getParameterCount() == 1) {
-                Class<?> actArg = ac.getParameterClass(0);
-                for (Class<?> expArg : argTypes) {
-                    if (expArg == actArg) {
-                        return ac.getAnnotated();
-                    }
-                }
-            }
-        }
-        return null;
-    }
-
-    /**
-     * Method that can be called to find if introspected class declares
-     * a static "valueOf" factory method that returns an instance of
-     * introspected type, given one of acceptable types.
-     *
-     * @param expArgTypes Types that the matching single argument factory
-     *   method can take: will also accept super types of these types
-     *   (ie. arg just has to be assignable from expArgType)
-     */
-    public Method findFactoryMethod(Class<?>... expArgTypes)
-    {
-        // So, of all single-arg static methods:
-        for (AnnotatedMethod am : _classInfo.getStaticMethods()) {
-            if (isFactoryMethod(am)) {
-                // And must take one of expected arg types (or supertype)
-                Class<?> actualArgType = am.getParameterClass(0);
-                for (Class<?> expArgType : expArgTypes) {
-                    // And one that matches what we would pass in
-                    if (actualArgType.isAssignableFrom(expArgType)) {
-                        return am.getAnnotated();
-                    }
-                }
-            }
-        }
-        return null;
-    }
-
-    protected boolean isFactoryMethod(AnnotatedMethod am)
-    {
-        /* First: return type must be compatible with the introspected class
-         * (i.e. allowed to be sub-class, although usually is the same
-         * class)
-         */
-        Class<?> rt = am.getRawType();
-        if (!getBeanClass().isAssignableFrom(rt)) {
-            return false;
-        }
-
-        /* Also: must be a recognized factory method, meaning:
-         * (a) marked with @JsonCreator annotation, or
-         * (a) "valueOf" (at this point, need not be public)
-         */
-        if (_annotationIntrospector.hasCreatorAnnotation(am)) {
-            return true;
-        }
-        if ("valueOf".equals(am.getName())) {
-            return true;
-        }
-        return false;
-    }
-
-    /**
-     * Method for getting ordered list of named Creator properties.
-     * Returns an empty list is none found. If multiple Creator
-     * methods are defined, order between properties from different
-     * methods is undefined; however, properties for each such
-     * Creator are ordered properly relative to each other. For the
-     * usual case of just a single Creator, named properties are
-     * thus properly ordered.
-     */
-    public List<String> findCreatorPropertyNames()
-    {
-        List<String> names = null;
-
-        for (int i = 0; i < 2; ++i) {
-            List<? extends AnnotatedWithParams> l = (i == 0)
-                ? getConstructors() : getFactoryMethods();
-            for (AnnotatedWithParams creator : l) {
-                int argCount = creator.getParameterCount();
-                if (argCount < 1) continue;
-                String name = _annotationIntrospector.findPropertyNameForParam(creator.getParameter(0));
-                if (name == null) continue;
-                if (names == null) {
-                    names = new ArrayList<String>();
-                }
-                names.add(name);
-                for (int p = 1; p < argCount; ++p) {
-                    names.add(_annotationIntrospector.findPropertyNameForParam(creator.getParameter(p)));
-                }
-            }
-        }
-        if (names == null) {
-            return Collections.emptyList();
-        }
-        return names;
-    }
-    
-    /*
-    /**********************************************************
-    /* Introspection for serialization, other
-    /**********************************************************
-     */
-
-    /**
-     * Method for determining whether null properties should be written
-     * out for a Bean of introspected type. This is based on global
-     * feature (lowest priority, passed as argument)
-     * and per-class annotation (highest priority).
-     */
-    public JsonSerialize.Inclusion findSerializationInclusion(JsonSerialize.Inclusion defValue)
-    {
-        if (_annotationIntrospector == null) {
-            return defValue;
-        }
-        return _annotationIntrospector.findSerializationInclusion(_classInfo, defValue);
-    }
-
-    /**
-     * Method used to locate the method of introspected class that
-     * implements {@link sh.calaba.org.codehaus.jackson.annotate.JsonAnyGetter}.
-     * If no such method exists null is returned.
-     * If more than one are found, an exception is thrown.
-     * 
-     * @since 1.6
-     */
-    @Override
-    public AnnotatedMethod findAnyGetter() throws IllegalArgumentException
-    {
-        if (_anyGetterMethod != null) {
-            /* For now let's require a Map; in future can add support for other
-             * types like perhaps Iterable<Map.Entry>?
-             */
-            Class<?> type = _anyGetterMethod.getRawType();
-            if (!Map.class.isAssignableFrom(type)) {
-                throw new IllegalArgumentException("Invalid 'any-getter' annotation on method "+_anyGetterMethod.getName()+"(): return type is not instance of java.util.Map");
-            }
-        }
-        return _anyGetterMethod;
-    }
-    
-    /**
-     * Method for locating all back-reference properties (setters, fields) bean has
-     * 
-     * @since 1.6
-     */
-    public Map<String,AnnotatedMember> findBackReferenceProperties()
-    {
-        HashMap<String,AnnotatedMember> result = null;
-        for (BeanPropertyDefinition property : _properties) {
-            AnnotatedMember am = property.getMutator();
-            if (am == null) {
-                continue;
-            }
-            AnnotationIntrospector.ReferenceProperty refDef = _annotationIntrospector.findReferenceType(am);
-            if (refDef != null && refDef.isBackReference()) {
-                if (result == null) {
-                    result = new HashMap<String,AnnotatedMember>();
-                }
-                String refName = refDef.getName();
-                if (result.put(refName, am) != null) {
-                    throw new IllegalArgumentException("Multiple back-reference properties with name '"+refName+"'");
-                }
-            }
-        }
-        return result;
-    }
-
-    /*
-    /**********************************************************
-    /* Helper methods for field introspection
-    /**********************************************************
-     */
-
-    /**
-     * @param ignoredProperties (optional) names of properties to ignore;
-     *   any fields that would be recognized as one of these properties
-     *   is ignored.
-     * @param forSerialization If true, will collect serializable property
-     *    fields; if false, deserializable
-     *
-     * @return Ordered Map with logical property name as key, and
-     *    matching field as value.
-     */
-    public LinkedHashMap<String,AnnotatedField> _findPropertyFields(
-            Collection<String> ignoredProperties, boolean forSerialization)
-    {
-        LinkedHashMap<String,AnnotatedField> results = new LinkedHashMap<String,AnnotatedField>();
-        for (BeanPropertyDefinition property : _properties) {
-            AnnotatedField f = property.getField();
-            if (f != null) {
-                String name = property.getName();
-                if (ignoredProperties != null) {
-                    if (ignoredProperties.contains(name)) {
-                        continue;
-                    }
-                }
-                results.put(name, f);
-            }
-        }
-        return results;
-    }
-
-    /*
-    /**********************************************************
-    /* Deprecated methods from BeanDescription
-    /**********************************************************
-     */
-    
-    @SuppressWarnings("deprecation")
-    @Override
-    public LinkedHashMap<String,AnnotatedMethod> findGetters(VisibilityChecker<?> visibilityChecker,
-            Collection<String> ignoredProperties)
-    {
-        LinkedHashMap<String,AnnotatedMethod> results = new LinkedHashMap<String,AnnotatedMethod>();
-        for (BeanPropertyDefinition property : _properties) {
-            AnnotatedMethod m = property.getGetter();
-            if (m != null) {
-                String name = property.getName();
-                if (ignoredProperties != null) {
-                    if (ignoredProperties.contains(name)) {
-                        continue;
-                    }
-                }
-                results.put(name, m);
-            }
-        }
-        return results;
-    }
-
-    @SuppressWarnings("deprecation")
-    @Override
-    public LinkedHashMap<String,AnnotatedMethod> findSetters(VisibilityChecker<?> visibilityChecker)
-    {
-        LinkedHashMap<String,AnnotatedMethod> results = new LinkedHashMap<String,AnnotatedMethod>();
-        for (BeanPropertyDefinition property : _properties) {
-            AnnotatedMethod m = property.getSetter();
-            if (m != null) {
-                results.put(property.getName(), m);
-            }
-        }
-        return results;
-    }
-    
-    @SuppressWarnings("deprecation")
-    @Override
-    public LinkedHashMap<String,AnnotatedField> findSerializableFields(VisibilityChecker<?> visibilityChecker,
-            Collection<String> ignoredProperties)
-    {
-        return _findPropertyFields(ignoredProperties, true);
-    }
-
-    @SuppressWarnings("deprecation")
-    @Override
-    public LinkedHashMap<String,AnnotatedField> findDeserializableFields(VisibilityChecker<?> visibilityChecker,
-            Collection<String> ignoredProperties)
-    {
-        return _findPropertyFields(ignoredProperties, false);
-    }
-}