calabash-android 0.5.2 → 0.5.3

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

@@ -1,38 +0,0 @@
-package sh.calaba.org.codehaus.jackson.map.type;
-
-import java.lang.reflect.Type;
-
-import sh.calaba.org.codehaus.jackson.type.JavaType;
-
-/**
- * Class that defines API that can be used to modify details of
- * {@link JavaType} instances constructed using {@link TypeFactory}.
- * Registered modifiers are called in order, to let them modify (or
- * replace) basic type instance factory constructs.
- * This is typically needed to support creation of
- * {@link MapLikeType} and {@link CollectionLikeType} instances,
- * as those can not be constructed in generic fashion.
- * 
- * @since 1.8
- */
-public abstract class TypeModifier
-{
-    /**
-     * Method called to let modifier change constructed type definition.
-     * Note that as of version 1.8 this is only guaranteed to be called for
-     * non-container types ("simple" types not recognized as arrays,
-     * <code>java.util.Collection</code> or <code>java.util.Map</code>).
-     * 
-     * @param type Instance to modify
-     * @param jdkType JDK type that was used to construct instance to modify
-     * @param context Type resolution context used for the type
-     * @param typeFactory Type factory that can be used to construct parameter type; note,
-     *   however, that care must be taken to avoid infinite loops -- specifically, do not
-     *   construct instance of primary type itself
-     * 
-     * @return Actual type instance to use; usually either <code>type</code> (as is or with
-     *    modifications), or a newly constructed type instance based on it. Can not be null.
-     */
-    public abstract JavaType modifyType(JavaType type, Type jdkType, TypeBindings context,
-            TypeFactory typeFactory);
-}

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

@@ -1,134 +0,0 @@
-package sh.calaba.org.codehaus.jackson.map.type;
-
-import java.util.*;
-
-import sh.calaba.org.codehaus.jackson.type.JavaType;
-
-/**
- * Simple recursive-descent parser for parsing canonical {@link JavaType}
- * representations and constructing type instances.
- * 
- * @author tatu
- * @since 1.5
- */
-public class TypeParser
-{
-    final TypeFactory _factory;
-        
-    public TypeParser(TypeFactory f) {
-        _factory = f;
-    }
-
-    public JavaType parse(String canonical)
-        throws IllegalArgumentException
-    {
-        canonical = canonical.trim();
-        MyTokenizer tokens = new MyTokenizer(canonical);
-        JavaType type = parseType(tokens);
-        // must be end, now
-        if (tokens.hasMoreTokens()) {
-            throw _problem(tokens, "Unexpected tokens after complete type");
-        }
-        return type;
-    }
-
-    protected JavaType parseType(MyTokenizer tokens)
-        throws IllegalArgumentException
-    {
-        if (!tokens.hasMoreTokens()) {
-            throw _problem(tokens, "Unexpected end-of-string");
-        }
-        Class<?> base = findClass(tokens.nextToken(), tokens);
-        // either end (ok, non generic type), or generics
-        if (tokens.hasMoreTokens()) {
-            String token = tokens.nextToken();
-            if ("<".equals(token)) {
-                return _factory._fromParameterizedClass(base, parseTypes(tokens));
-            }
-            // can be comma that separates types, or closing '>'
-            tokens.pushBack(token);
-        }
-        return _factory._fromClass(base, null);
-    }
-
-    protected List<JavaType> parseTypes(MyTokenizer tokens)
-        throws IllegalArgumentException
-    {
-        ArrayList<JavaType> types = new ArrayList<JavaType>();
-        while (tokens.hasMoreTokens()) {
-            types.add(parseType(tokens));
-            if (!tokens.hasMoreTokens()) break;
-            String token = tokens.nextToken();
-            if (">".equals(token)) return types;
-            if (!",".equals(token)) {
-                throw _problem(tokens, "Unexpected token '"+token+"', expected ',' or '>')");
-            }
-        }
-        throw _problem(tokens, "Unexpected end-of-string");
-    }
-
-    protected Class<?> findClass(String className, MyTokenizer tokens)
-    {
-        try {
-            /* [JACKSON-350]: Default Class.forName() won't work too well; context class loader
-             *    seems like slightly better choice
-             */
-//          return Class.forName(className);
-            ClassLoader loader = Thread.currentThread().getContextClassLoader();
-            return Class.forName(className, true, loader);
-        } catch (Exception e) {
-            if (e instanceof RuntimeException) {
-                throw (RuntimeException) e;
-            }
-            throw _problem(tokens, "Can not locate class '"+className+"', problem: "+e.getMessage());
-        }
-    }
-
-    protected IllegalArgumentException _problem(MyTokenizer tokens, String msg)
-    {
-        return new IllegalArgumentException("Failed to parse type '"+tokens.getAllInput()
-                +"' (remaining: '"+tokens.getRemainingInput()+"'): "+msg);
-    }
-
-    final static class MyTokenizer
-        extends StringTokenizer
-    {
-        protected final String _input;
-
-        protected int _index;
-
-        protected String _pushbackToken;
-        
-        public MyTokenizer(String str) {            
-            super(str, "<,>", true);
-            _input = str;
-        }
-
-        @Override
-        public boolean hasMoreTokens() {
-            return (_pushbackToken != null) || super.hasMoreTokens();
-        }
-        
-        @Override
-        public String nextToken() {
-            String token;
-            if (_pushbackToken != null) {
-                token = _pushbackToken;
-                _pushbackToken = null;
-            } else {
-                token = super.nextToken();
-            }
-            _index += token.length();
-            return token;
-        }
-
-        public void pushBack(String token) {
-            _pushbackToken = token;
-            _index -= token.length();
-        }
-        
-        public String getAllInput() { return _input; }
-        public String getUsedInput() { return _input.substring(0, _index); }
-        public String getRemainingInput() { return _input.substring(_index); }
-    }
-}

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

@@ -1,10 +0,0 @@
-/**
- * Package that contains concrete implementations of
- * {@link sh.calaba.org.codehaus.jackson.type.JavaType}, as
- * well as the factory ({@link sh.calaba.org.codehaus.jackson.map.type.TypeFactory}) for
- * constructing instances from various input data types
- * (like {@link java.lang.Class}, {@link java.lang.reflect.Type})
- * and programmatically (for structured types, arrays,
- * {@link java.util.List}s and {@link java.util.Map}s).
- */
-package sh.calaba.org.codehaus.jackson.map.type;

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

@@ -1,23 +0,0 @@
-package sh.calaba.org.codehaus.jackson.map.util;
-
-import java.lang.annotation.Annotation;
-
-/**
- * Interface that defines interface for collection of annotations.
- *<p>
- * Standard mutable implementation is {@link sh.calaba.org.codehaus.jackson.map.introspect.AnnotationMap}
- * 
- * @since 1.7
- */
-public interface Annotations
-{
-    /**
-     * Main access method used to find value for given annotation.
-     */
-    public <A extends Annotation> A get(Class<A> cls);
-
-    /**
-     * Returns number of annotation entries in this collection.
-     */
-    public int size();
-}

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

@@ -1,293 +0,0 @@
-package sh.calaba.org.codehaus.jackson.map.util;
-
-import java.lang.reflect.Array;
-import java.util.*;
-
-/**
- * Helper class that contains set of distinct builders for different
- * arrays of primitive values. It also provides trivially simple
- * reuse scheme, which assumes that caller knows not to use instances
- * concurrently (which works ok with primitive arrays since they can
- * not contain other non-primitive types).
- */
-public final class ArrayBuilders
-{
-    BooleanBuilder _booleanBuilder = null;
-
-    // note: no need for char[] builder, assume they are Strings
-
-    ByteBuilder _byteBuilder = null;
-    ShortBuilder _shortBuilder = null;
-    IntBuilder _intBuilder = null;
-    LongBuilder _longBuilder = null;
-    
-    FloatBuilder _floatBuilder = null;
-    DoubleBuilder _doubleBuilder = null;
-
-    public ArrayBuilders() { }
-
-    public BooleanBuilder getBooleanBuilder()
-    {
-        if (_booleanBuilder == null) {
-            _booleanBuilder = new BooleanBuilder();
-        }
-        return _booleanBuilder;
-    }
-
-    public ByteBuilder getByteBuilder()
-    {
-        if (_byteBuilder == null) {
-            _byteBuilder = new ByteBuilder();
-        }
-        return _byteBuilder;
-    }
-    public ShortBuilder getShortBuilder()
-    {
-        if (_shortBuilder == null) {
-            _shortBuilder = new ShortBuilder();
-        }
-        return _shortBuilder;
-    }
-    public IntBuilder getIntBuilder()
-    {
-        if (_intBuilder == null) {
-            _intBuilder = new IntBuilder();
-        }
-        return _intBuilder;
-    }
-    public LongBuilder getLongBuilder()
-    {
-        if (_longBuilder == null) {
-            _longBuilder = new LongBuilder();
-        }
-        return _longBuilder;
-    }
-
-    public FloatBuilder getFloatBuilder()
-    {
-        if (_floatBuilder == null) {
-            _floatBuilder = new FloatBuilder();
-        }
-        return _floatBuilder;
-    }
-    public DoubleBuilder getDoubleBuilder()
-    {
-        if (_doubleBuilder == null) {
-            _doubleBuilder = new DoubleBuilder();
-        }
-        return _doubleBuilder;
-    }
-
-    /*
-    /**********************************************************
-    /* Impl classes
-    /**********************************************************
-     */
-
-    public final static class BooleanBuilder
-        extends PrimitiveArrayBuilder<boolean[]>
-    {
-        public BooleanBuilder() { }
-        @Override
-        public final boolean[] _constructArray(int len) { return new boolean[len]; }
-    }
-
-    public final static class ByteBuilder
-        extends PrimitiveArrayBuilder<byte[]>
-    {
-        public ByteBuilder() { }
-        @Override
-        public final byte[] _constructArray(int len) { return new byte[len]; }
-    }
-    public final static class ShortBuilder
-        extends PrimitiveArrayBuilder<short[]>
-    {
-        public ShortBuilder() { }
-        @Override
-        public final short[] _constructArray(int len) { return new short[len]; }
-    }
-    public final static class IntBuilder
-        extends PrimitiveArrayBuilder<int[]>
-    {
-        public IntBuilder() { }
-        @Override
-        public final int[] _constructArray(int len) { return new int[len]; }
-    }
-    public final static class LongBuilder
-        extends PrimitiveArrayBuilder<long[]>
-    {
-        public LongBuilder() { }
-        @Override
-        public final long[] _constructArray(int len) { return new long[len]; }
-    }
-
-    public final static class FloatBuilder
-        extends PrimitiveArrayBuilder<float[]>
-    {
-        public FloatBuilder() { }
-        @Override
-        public final float[] _constructArray(int len) { return new float[len]; }
-    }
-    public final static class DoubleBuilder
-        extends PrimitiveArrayBuilder<double[]>
-    {
-        public DoubleBuilder() { }
-        @Override
-        public final double[] _constructArray(int len) { return new double[len]; }
-    }
-    
-    /*
-    /**********************************************************
-    /* Static helper methods
-    /**********************************************************
-     */
-
-    public static <T> HashSet<T> arrayToSet(T[] elements)
-    {
-        HashSet<T> result = new HashSet<T>();
-        if (elements != null) {
-            for (T elem : elements) {
-                result.add(elem);
-            }
-        }
-        return result;
-    }
-
-    /**
-     * Helper method for adding specified element to a List, but also
-     * considering case where the List may not have been yet constructed
-     * (that is, null is passed instead).
-     * 
-     * @param list List to add to; may be null to indicate that a new
-     *    List is to be constructed
-     * @param element Element to add to list
-     * 
-     * @return List in which element was added; either <code>list</code>
-     *   (if it was not null), or a newly constructed List.
-     */
-    public static <T> List<T> addToList(List<T> list, T element)
-    {
-        if (list == null) {
-            list = new ArrayList<T>();
-        }
-        list.add(element);
-        return list;
-    }
-
-    /**
-     * Helper method for constructing a new array that contains specified
-     * element followed by contents of the given array. No checking is done
-     * to see if element being inserted is duplicate.
-     */
-    public static <T> T[] insertInList(T[] array, T element)
-    {
-        int len = array.length;
-        @SuppressWarnings("unchecked")
-        T[] result = (T[]) Array.newInstance(array.getClass().getComponentType(), len+1);
-        if (len > 0) {
-            System.arraycopy(array, 0, result, 1, len);
-        }
-        result[0] = element;
-        return result;
-    }
-
-    /**
-     * Helper method for constructing a new array that contains specified
-     * element followed by contents of the given array but never contains
-     * duplicates.
-     * If element already existed, one of two things happens: if the element
-     * was already the first one in array, array is returned as is; but
-     * if not, a new copy is created in which element has moved as the head.
-     */
-    @SuppressWarnings("unchecked")
-    public static <T> T[] insertInListNoDup(T[] array, T element)
-    {
-        final int len = array.length;
-        
-        // First: see if the element already exists
-        for (int ix = 0; ix < len; ++ix) {
-            if (array[ix] == element) {
-                // if at head already, return as is
-                if (ix == 0) {
-                    return array;
-                }
-                // otherwise move things around
-                T[] result = (T[]) Array.newInstance(array.getClass().getComponentType(), len);
-                System.arraycopy(array, 0, result, 1, ix);
-                array[0] = element;
-                return result;
-            }
-        }
-
-        // but if not, allocate new array, move
-        T[] result = (T[]) Array.newInstance(array.getClass().getComponentType(), len+1);
-        if (len > 0) {
-            System.arraycopy(array, 0, result, 1, len);
-        }
-        result[0] = element;
-        return result;
-    }
-    
-    /**
-     * Helper method for exposing contents of arrays using a read-only
-     * iterator
-     * 
-     * @since 1.7
-     */
-    public static <T> Iterator<T> arrayAsIterator(T[] array)
-    {
-        return new ArrayIterator<T>(array);
-    }
-
-    public static <T> Iterable<T> arrayAsIterable(T[] array)
-    {
-        return new ArrayIterator<T>(array);
-    }
-
-    /*
-    /**********************************************************
-    /* Helper classes
-    /**********************************************************
-     */
-
-    /**
-     * Iterator implementation used to efficiently expose contents of an
-     * Array as read-only iterator.
-     * 
-     * @since 1.7
-     */
-    private final static class ArrayIterator<T>
-        implements Iterator<T>, Iterable<T>
-    {
-        private final T[] _array;
-        
-        private int _index;
-
-        public ArrayIterator(T[] array) {
-            _array = array;
-            _index = 0;
-        }
-        
-        @Override public boolean hasNext() {
-            return _index < _array.length;
-        }
-
-        @Override
-        public T next()
-        {
-            if (_index >= _array.length) {
-                throw new NoSuchElementException();
-            }
-            return _array[_index++];
-        }
-
-        @Override public void remove() {
-            throw new UnsupportedOperationException();
-        }
-
-        @Override
-        public Iterator<T> iterator() {
-            return this;
-        }
-    }
-}