calabash-android 0.0.1

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

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

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

@@ -0,0 +1,10 @@
+/**
+ * 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

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

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