calabash-android 0.4.7.pre4 → 0.4.7.pre6

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

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

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

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