calabash-android 0.4.7.pre6 → 0.4.7.pre7

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

@@ -0,0 +1,85 @@
+package sh.calaba.org.codehaus.jackson.map.introspect;
+
+import java.lang.reflect.Method;
+import java.util.*;
+
+/**
+ * Simple helper class used to keep track of collection of
+ * {@link AnnotatedMethod}s, accessible by lookup. Lookup
+ * is usually needed for augmenting and overriding annotations.
+ */
+public final class AnnotatedMethodMap
+    implements Iterable<AnnotatedMethod>
+{
+    protected LinkedHashMap<MemberKey,AnnotatedMethod> _methods;
+
+    public AnnotatedMethodMap() { }
+
+    /**
+     * Method called to add specified annotated method in the Map.
+     */
+    public void add(AnnotatedMethod am)
+    {
+        if (_methods == null) {
+            _methods = new LinkedHashMap<MemberKey,AnnotatedMethod>();
+        }
+        _methods.put(new MemberKey(am.getAnnotated()), am);
+    }
+
+    /**
+     * Method called to remove specified method, assuming
+     * it exists in the Map
+     */
+    public AnnotatedMethod remove(AnnotatedMethod am)
+    {
+        return remove(am.getAnnotated());
+    }
+
+    public AnnotatedMethod remove(Method m)
+    {
+        if (_methods != null) {
+            return _methods.remove(new MemberKey(m));
+        }
+        return null;
+    }
+
+    public boolean isEmpty() {
+        return (_methods == null || _methods.size() == 0);
+    }
+
+    public int size() {
+        return (_methods == null) ? 0 : _methods.size();
+    }
+
+    public AnnotatedMethod find(String name, Class<?>[] paramTypes)
+    {
+        if (_methods == null) {
+            return null;
+        }
+        return _methods.get(new MemberKey(name, paramTypes));
+    }
+
+    public AnnotatedMethod find(Method m)
+    {
+        if (_methods == null) {
+            return null;
+        }
+        return _methods.get(new MemberKey(m));
+    }
+
+    /*
+    /**********************************************************
+    /* Iterable implementation (for iterating over values)
+    /**********************************************************
+     */
+
+    @Override
+    public Iterator<AnnotatedMethod> iterator()
+    {
+        if (_methods != null) {
+            return _methods.values().iterator();
+        }
+        List<AnnotatedMethod> empty = Collections.emptyList();
+        return empty.iterator();
+    }
+}

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

@@ -0,0 +1,191 @@
+package sh.calaba.org.codehaus.jackson.map.introspect;
+
+import java.lang.annotation.Annotation;
+import java.lang.reflect.AnnotatedElement;
+import java.lang.reflect.Member;
+import java.lang.reflect.Type;
+
+import sh.calaba.org.codehaus.jackson.map.type.TypeFactory;
+import sh.calaba.org.codehaus.jackson.type.JavaType;
+
+/**
+ * Object that represents method parameters, mostly so that associated
+ * annotations can be processed conveniently. Note that many of accessors
+ * can not return meaningful values since parameters do not have stand-alone
+ * JDK objects associated; so access should mostly be limited to checking
+ * annotation values which are properly aggregated and included.
+ *<p>
+ * Note: as of version 1.7, this type extends {@link AnnotatedMember}, since
+ * it behaves like a member for the most part, but earlier it just extended
+ * {@link Annotated}
+ */
+public final class AnnotatedParameter
+    extends AnnotatedMember
+{
+    /**
+     * Member (method, constructor) that this parameter belongs to
+     * 
+     * @since 1.7
+     */
+    protected final AnnotatedWithParams _owner;
+    
+    /**
+     * JDK type of the parameter, possibly contains generic type information
+     */
+    protected final Type _type;
+    
+    /**
+     * Index of the parameter within argument list
+     * 
+     * @since 1.9
+     */
+    protected final int _index;
+    
+    /*
+    /**********************************************************
+    /* Life-cycle
+    /**********************************************************
+     */
+
+    public AnnotatedParameter(AnnotatedWithParams owner, Type type,  AnnotationMap annotations,
+            int index)
+    {
+        super(annotations);
+        _owner = owner;
+        _type = type;
+        _index = index;
+    }
+
+    @Override
+    public AnnotatedParameter withAnnotations(AnnotationMap ann) {
+        if (ann == _annotations) {
+            return this;
+        }
+        return _owner.replaceParameterAnnotations(_index, ann);
+    }
+    
+    public void addOrOverride(Annotation a)
+    {
+        _annotations.add(a);
+    }
+
+    /*
+    /**********************************************************
+    /* Annotated impl
+    /**********************************************************
+     */
+
+    /**
+     * Since there is no matching JDK element, this method will
+     * always return null
+     */
+    @Override
+    public AnnotatedElement getAnnotated() { return null; }
+
+    /**
+     * Returns modifiers of the constructor, as parameters do not
+     * have independent modifiers.
+     */
+    @Override
+    public int getModifiers() { return _owner.getModifiers(); }
+
+    /**
+     * Parameters have no names in bytecode (unlike in source code),
+     * will always return empty String ("").
+     */
+    @Override
+    public String getName() { return ""; }
+
+    /**
+     * Accessor for annotations; all annotations associated with parameters
+     * are properly passed and accessible.
+     */
+    @Override
+    public <A extends Annotation> A getAnnotation(Class<A> acls)
+    {
+        return _annotations.get(acls);
+    }
+
+    @Override
+    public Type getGenericType() {
+        return _type;
+    }
+
+    @Override
+    public Class<?> getRawType()
+    {
+        if (_type instanceof Class<?>) {
+            return (Class<?>) _type;
+        }
+        // 14-Mar-2011, tatu: Not optimal, but has to do for now...
+        JavaType t = TypeFactory.defaultInstance().constructType(_type);
+        return t.getRawClass();
+    }
+
+    /*
+    /**********************************************************
+    /* AnnotatedMember extras
+    /**********************************************************
+     */
+
+    @Override
+    public Class<?> getDeclaringClass() {
+        return _owner.getDeclaringClass();
+    }
+
+    @Override
+    public Member getMember() {
+        /* This is bit tricky: since there is no JDK equivalent; can either
+         * return null or owner... let's do latter, for now.
+         */
+        return _owner.getMember();
+    }
+
+    @Override
+    public void setValue(Object pojo, Object value)
+        throws UnsupportedOperationException
+    {
+        throw new UnsupportedOperationException("Cannot call setValue() on constructor parameter of "
+                +getDeclaringClass().getName());
+    }
+    
+    /*
+    /**********************************************************
+    /* Extended API
+    /**********************************************************
+     */
+
+    public Type getParameterType() { return _type; }
+
+    /**
+     * Accessor for 'owner' of this parameter; method or constructor that
+     * has this parameter as member of its argument list.
+     * 
+     * @return Owner (member or creator) object of this parameter
+     * 
+     * @since 1.9
+     */
+    public AnnotatedWithParams getOwner() { return _owner; }
+    
+    /**
+     * Accessor for index of this parameter within argument list
+     * 
+     * @return Index of this parameter within argument list
+     * 
+     * @since 1.9
+     */
+    public int getIndex() { return _index; }
+
+    /*
+    /********************************************************
+    /* Other
+    /********************************************************
+     */
+    
+    @Override
+    public String toString()
+    {
+        return "[parameter #"+getIndex()+", annotations: "+_annotations+"]";
+    }
+}
+

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

@@ -0,0 +1,195 @@
+package sh.calaba.org.codehaus.jackson.map.introspect;
+
+import java.lang.annotation.Annotation;
+import java.lang.reflect.Type;
+import java.lang.reflect.TypeVariable;
+
+import sh.calaba.org.codehaus.jackson.map.type.TypeBindings;
+import sh.calaba.org.codehaus.jackson.map.type.TypeFactory;
+import sh.calaba.org.codehaus.jackson.type.JavaType;
+
+/**
+ * Intermediate base class that encapsulates features that
+ * constructors and methods share.
+ */
+public abstract class AnnotatedWithParams
+    extends AnnotatedMember
+{
+    /**
+     * Annotations associated with parameters of the annotated
+     * entity (method or constructor parameters)
+     */
+    protected final AnnotationMap[] _paramAnnotations;
+
+    /*
+    /**********************************************************
+    /* Life-cycle
+    /**********************************************************
+     */
+
+    protected AnnotatedWithParams(AnnotationMap annotations, AnnotationMap[] paramAnnotations)
+    {
+        super(annotations);
+        _paramAnnotations = paramAnnotations;
+    }
+
+    /**
+     * Method called to override a class annotation, usually due to a mix-in
+     * annotation masking or overriding an annotation 'real' class
+     */
+    public final void addOrOverride(Annotation a)
+    {
+        _annotations.add(a);
+    }
+
+    /**
+     * Method called to override a method parameter annotation,
+     * usually due to a mix-in
+     * annotation masking or overriding an annotation 'real' method
+     * has.
+     */
+    public final void addOrOverrideParam(int paramIndex, Annotation a)
+    {
+        AnnotationMap old = _paramAnnotations[paramIndex];
+        if (old == null) {
+            old = new AnnotationMap();
+            _paramAnnotations[paramIndex] = old;
+        }
+        old.add(a);
+    }
+
+    /**
+     * Method called to augment annotations, by adding specified
+     * annotation if and only if it is not yet present in the
+     * annotation map we have.
+     */
+    public final void addIfNotPresent(Annotation a)
+    {
+        _annotations.addIfNotPresent(a);
+    }
+
+    
+    /**
+     * Method called by parameter object when an augmented instance is created;
+     * needs to replace parameter with new instance
+     * 
+     * @since 1.9
+     */
+    protected AnnotatedParameter replaceParameterAnnotations(int index, AnnotationMap ann)
+    {
+        _paramAnnotations[index] = ann;
+        return getParameter(index);
+    }    
+
+    /*
+    /**********************************************************
+    /* Helper methods for subclasses
+    /**********************************************************
+     */
+
+    protected JavaType getType(TypeBindings bindings, TypeVariable<?>[] typeParams)
+    {
+        // [JACKSON-468] Need to consider local type binding declarations too...
+        if (typeParams != null && typeParams.length > 0) {
+            bindings = bindings.childInstance();
+            for (TypeVariable<?> var : typeParams) {
+                String name = var.getName();
+                // to prevent infinite loops, need to first add placeholder ("<T extends Enum<T>>" etc)
+                bindings._addPlaceholder(name);
+                // About only useful piece of information is the lower bound (which is at least Object.class)
+                Type lowerBound = var.getBounds()[0];
+                JavaType type = (lowerBound == null) ? TypeFactory.unknownType()
+                        : bindings.resolveType(lowerBound);
+                bindings.addBinding(var.getName(), type);
+            }
+        }
+        return bindings.resolveType(getGenericType());
+    }
+
+    /*
+    /**********************************************************
+    /* Partial Annotated impl
+    /**********************************************************
+     */
+
+    @Override
+    public final <A extends Annotation> A getAnnotation(Class<A> acls)
+    {
+        return _annotations.get(acls);
+    }
+
+    /*
+    /**********************************************************
+    /* Extended API
+    /**********************************************************
+     */
+
+    public final AnnotationMap getParameterAnnotations(int index)
+    {
+        if (_paramAnnotations != null) {
+            if (index >= 0 && index <= _paramAnnotations.length) {
+                return _paramAnnotations[index];
+            }
+        }
+        return null;
+    }
+
+    public final AnnotatedParameter getParameter(int index) {
+        return new AnnotatedParameter(this, getParameterType(index),
+                _paramAnnotations[index], index);
+    }
+
+    public abstract int getParameterCount();
+
+    public abstract Class<?> getParameterClass(int index);
+
+    public abstract Type getParameterType(int index);
+
+    /**
+     * Method called to fully resolve type of one of parameters, given
+     * specified type variable bindings.
+     * 
+     * @since 1.8
+     */
+    public final JavaType resolveParameterType(int index, TypeBindings bindings) {
+        return bindings.resolveType(getParameterType(index));
+    }
+    
+    public final int getAnnotationCount() { return _annotations.size(); }
+
+    /**
+     * Method that can be used to (try to) call this object without arguments.
+     * This may succeed or fail, depending on expected number
+     * of arguments: caller needs to take care to pass correct number.
+     * Exceptions are thrown directly from actual low-level call.
+     *<p>
+     * Note: only works for constructors and static methods.
+     * 
+     * @since 1.9
+     */
+    public abstract Object call() throws Exception;
+
+    /**
+     * Method that can be used to (try to) call this object with specified arguments.
+     * This may succeed or fail, depending on expected number
+     * of arguments: caller needs to take care to pass correct number.
+     * Exceptions are thrown directly from actual low-level call.
+     *<p>
+     * Note: only works for constructors and static methods.
+     * 
+     * @since 1.9
+     */
+    public abstract Object call(Object[] args) throws Exception;
+
+    /**
+     * Method that can be used to (try to) call this object with single arguments.
+     * This may succeed or fail, depending on expected number
+     * of arguments: caller needs to take care to pass correct number.
+     * Exceptions are thrown directly from actual low-level call.
+     *<p>
+     * Note: only works for constructors and static methods.
+     * 
+     * @since 1.9
+     */
+    public abstract Object call1(Object arg) throws Exception;
+}