calabash-android 0.0.1

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

@@ -0,0 +1,105 @@
+package sh.calaba.org.codehaus.jackson.map.util;
+
+import java.io.IOException;
+
+import sh.calaba.org.codehaus.jackson.*;
+import sh.calaba.org.codehaus.jackson.map.*;
+import sh.calaba.org.codehaus.jackson.map.type.TypeFactory;
+import sh.calaba.org.codehaus.jackson.type.JavaType;
+
+/**
+ * Container class that can be used to wrap any Object instances (including
+ * nulls), and will serialize embedded in
+ * <a href="http://en.wikipedia.org/wiki/JSONP">JSONP</a> wrapping.
+ * 
+ * @see sh.calaba.org.codehaus.jackson.map.util.JSONWrappedObject
+ * 
+ * @author tatu
+ * @since 1.5
+ */
+public class JSONPObject
+    implements JsonSerializableWithType
+{
+    /**
+     * JSONP function name to use for serialization
+     */
+    protected final String _function;
+    
+    /**
+     * Value to be serialized as JSONP padded; can be null.
+     */
+    protected final Object _value;
+
+    /**
+     * Optional static type to use for serialization; if null, runtime
+     * type is used. Can be used to specify declared type which defines
+     * serializer to use, as well as aspects of extra type information
+     * to include (if any).
+     */
+    protected final JavaType _serializationType;
+
+    public JSONPObject(String function, Object value) {
+        this(function, value, (JavaType) null);
+    }
+
+    public JSONPObject(String function, Object value, JavaType asType)
+    {
+        _function = function;
+        _value = value;
+        _serializationType = asType;
+    }
+
+    /**
+     * @deprecated Since 1.8; instead use variant that takes JavaType: this ensures
+     *    that type information is properly resolved
+     */
+    @Deprecated
+    public JSONPObject(String function, Object value, Class<?> rawType) {
+        _function = function;
+        _value = value;
+        _serializationType = (rawType == null) ? null : TypeFactory.defaultInstance().constructType(rawType);
+    }
+    
+    /*
+    /**********************************************************
+    /* JsonSerializable(WithType) implementation
+    /**********************************************************
+     */
+    
+    @Override
+    public void serializeWithType(JsonGenerator jgen, SerializerProvider provider, TypeSerializer typeSer)
+            throws IOException, JsonProcessingException
+    {
+        // No type for JSONP wrapping: value serializer will handle typing for value:
+        serialize(jgen, provider);
+    }
+
+    @Override
+    @SuppressWarnings("deprecation")
+    public void serialize(JsonGenerator jgen, SerializerProvider provider)
+            throws IOException, JsonProcessingException
+    {
+        // First, wrapping:
+        jgen.writeRaw(_function);
+        jgen.writeRaw('(');
+        if (_value == null) {
+            provider.defaultSerializeNull(jgen);
+        } else if (_serializationType != null) {
+            provider.findTypedValueSerializer(_serializationType, true, null).serialize(_value, jgen, provider);
+        } else {
+            Class<?> cls = _value.getClass();
+            provider.findTypedValueSerializer(cls, true, null).serialize(_value, jgen, provider);
+        }
+        jgen.writeRaw(')');
+    }
+
+    /*
+    /**************************************************************
+    /* Accessors
+    /**************************************************************
+     */
+    
+    public String getFunction() { return _function; }
+    public Object getValue() { return _value; }
+    public JavaType getSerializationType() { return _serializationType; }
+}

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

@@ -0,0 +1,117 @@
+package sh.calaba.org.codehaus.jackson.map.util;
+
+import java.io.IOException;
+
+import sh.calaba.org.codehaus.jackson.*;
+import sh.calaba.org.codehaus.jackson.map.*;
+import sh.calaba.org.codehaus.jackson.map.type.TypeFactory;
+import sh.calaba.org.codehaus.jackson.type.JavaType;
+
+
+/**
+ * General-purpose wrapper class that can be used to decorate serialized
+ * value with arbitrary literal prefix and suffix. This can be used for
+ * example to construct arbitrary Javascript values (similar to how basic
+ * function name and parenthesis are used with JSONP).
+ * 
+ * @see sh.calaba.org.codehaus.jackson.map.util.JSONPObject
+ * 
+ * @author tatu
+ * @since 1.5
+ */
+public class JSONWrappedObject
+    implements JsonSerializableWithType
+{
+    /**
+     * Literal String to output before serialized value.
+     * Will not be quoted when serializing value.
+     */
+    protected final String _prefix;
+
+    /**
+     * Literal String to output after serialized value.
+     * Will not be quoted when serializing value.
+     */
+    protected final String _suffix;
+    
+    /**
+     * Value to be serialized as JSONP padded; can be null.
+     */
+    protected final Object _value;
+
+    /**
+     * Optional static type to use for serialization; if null, runtime
+     * type is used. Can be used to specify declared type which defines
+     * serializer to use, as well as aspects of extra type information
+     * to include (if any).
+     */
+    protected final JavaType _serializationType;
+    
+    public JSONWrappedObject(String prefix, String suffix, Object value) {
+        this(prefix, suffix, value, (JavaType) null);
+    }
+
+    public JSONWrappedObject(String prefix, String suffix, Object value, JavaType asType)
+    {
+        _prefix = prefix;
+        _suffix = suffix;
+        _value = value;
+        _serializationType = asType;
+    }
+
+    /**
+     * @deprecated Since 1.8; should construct with resolved <code>JavaType</code>,
+     *   to ensure type has been properly resolved
+     */
+    @Deprecated
+    public JSONWrappedObject(String prefix, String suffix, Object value, Class<?> rawType) {
+        _prefix = prefix;
+        _suffix = suffix;
+        _value = value;
+        _serializationType = (rawType == null) ? null : TypeFactory.defaultInstance().constructType(rawType);
+    }
+    
+    /*
+    /**************************************************************
+    /* JsonSerializable(WithType) implementation
+    /**************************************************************
+     */
+    
+    @Override
+    public void serializeWithType(JsonGenerator jgen, SerializerProvider provider, TypeSerializer typeSer)
+            throws IOException, JsonProcessingException
+    {
+        // No type for JSONP wrapping: value serializer will handle typing for value:
+        serialize(jgen, provider);
+    }
+
+    @Override
+    @SuppressWarnings("deprecation")
+    public void serialize(JsonGenerator jgen, SerializerProvider provider)
+            throws IOException, JsonProcessingException
+    {
+        // First, wrapping:
+    	if (_prefix != null) jgen.writeRaw(_prefix);
+        if (_value == null) {
+            provider.defaultSerializeNull(jgen);
+        } else if (_serializationType != null) {
+            provider.findTypedValueSerializer(_serializationType, true, null).serialize(_value, jgen, provider);
+        } else {
+            Class<?> cls = _value.getClass();
+            provider.findTypedValueSerializer(cls, true, null).serialize(_value, jgen, provider);
+        }
+        if (_suffix != null) jgen.writeRaw(_suffix);
+    }
+
+    /*
+    /**************************************************************
+    /* Accessors
+    /**************************************************************
+     */
+    
+    public String getPrefix() { return _prefix; }
+    public String getSuffix() { return _suffix; }
+    public Object getValue() { return _value; }
+    public JavaType getSerializationType() { return _serializationType; }
+
+}

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

@@ -0,0 +1,28 @@
+package sh.calaba.org.codehaus.jackson.map.util;
+
+import java.util.LinkedHashMap;
+import java.util.Map;
+
+/**
+ * Helper for simple bounded LRU maps used for reusing lookup values.
+ * 
+ * @since 1.7
+ */
+@SuppressWarnings("serial")
+public class LRUMap<K,V> extends LinkedHashMap<K,V>
+{
+    protected final int _maxEntries;
+    
+    public LRUMap(int initialEntries, int maxEntries)
+    {
+        super(initialEntries, 0.8f, true);
+        _maxEntries = maxEntries;
+    }
+
+    @Override
+    protected boolean removeEldestEntry(Map.Entry<K,V> eldest)
+    {
+        return size() > _maxEntries;
+    }
+
+}

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

@@ -0,0 +1,45 @@
+package sh.calaba.org.codehaus.jackson.map.util;
+
+/**
+ * Node of a forward-only linked list.
+ * 
+ * @author tatu
+ *
+ * @param <T> Type of contained object
+ */
+public final class LinkedNode<T>
+{
+    final T _value;
+    final LinkedNode<T> _next;
+    
+    public LinkedNode(T value, LinkedNode<T> next)
+    {
+        _value = value;
+        _next = next;
+    }
+    
+    public LinkedNode<T> next() { return _next; }
+    
+    public T value() { return _value; }
+    
+    /**
+     * Convenience method that can be used to check if a linked list
+     * with given head node (which may be null to indicate empty list)
+     * contains given value
+     * 
+     * @param <ST> Type argument that defines contents of the linked list parameter
+     * @param node Head node of the linked list
+     * @param value Value to look for
+     * @return True if linked list contains the value, false otherwise
+     */
+    public static <ST> boolean contains(LinkedNode<ST> node, ST value)
+    {
+        while (node != null) {
+            if (node.value() == value) {
+                return true;
+            }
+            node = node.next();
+        }
+        return false;
+    }
+}

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

@@ -0,0 +1,10 @@
+package sh.calaba.org.codehaus.jackson.map.util;
+
+/**
+ * Simple tag interface mostly to allow sorting by name
+ *
+ * @since 1.9
+ */
+public interface Named {
+    public String getName();
+}

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

@@ -0,0 +1,257 @@
+package sh.calaba.org.codehaus.jackson.map.util;
+
+import java.lang.reflect.Array;
+import java.util.List;
+
+/**
+ * Helper class to use for constructing Object arrays by appending entries
+ * to create arrays of various lengths (length that is not known a priori). 
+ */
+public final class ObjectBuffer
+{
+    // // // Config constants
+
+    /**
+     * Let's start with small chunks; typical usage is for small arrays anyway.
+     */
+    final static int INITIAL_CHUNK_SIZE = 12;
+
+    /**
+     * Also: let's expand by doubling up until 64k chunks (which is 16k entries for
+     * 32-bit machines)
+     */
+    final static int SMALL_CHUNK_SIZE = (1 << 14);
+
+    /**
+     * Let's limit maximum size of chunks we use; helps avoid excessive allocation
+     * overhead for huge data sets.
+     * For now, let's limit to quarter million entries, 1 meg chunks for 32-bit
+     * machines.
+     */
+    final static int MAX_CHUNK_SIZE = (1 << 18);
+
+    // // // Data storage
+
+    private Node _bufferHead;
+
+    private Node _bufferTail;
+
+    /**
+     * Number of total buffered entries in this buffer, counting all instances
+     * within linked list formed by following {@link #_bufferHead}.
+     */
+    private int _bufferedEntryCount;
+
+    // // // Simple reuse
+
+    /**
+     * Reusable Object array, stored here after buffer has been released having
+     * been used previously.
+     */
+    private Object[] _freeBuffer;
+
+    /*
+    /**********************************************************
+    /* Construction
+    /**********************************************************
+     */
+
+    public ObjectBuffer() { }
+
+    /*
+    /**********************************************************
+    /* Public API
+    /**********************************************************
+     */
+
+    /**
+     * Method called to start buffering process. Will ensure that the buffer
+     * is empty, and then return an object array to start chunking content on
+     */
+    public Object[] resetAndStart()
+    {
+        _reset();
+        if (_freeBuffer == null) {
+            return new Object[INITIAL_CHUNK_SIZE];
+        }
+        return _freeBuffer;
+    }
+
+    /**
+     * Method called to add a full Object array as a chunk buffered within
+     * this buffer, and to obtain a new array to fill. Caller is not to use
+     * the array it gives; but to use the returned array for continued
+     * buffering.
+     *
+     * @param fullChunk Completed chunk that the caller is requesting
+     *   to append to this buffer. It is generally chunk that was
+     *   returned by an earlier call to {@link #resetAndStart} or
+     *   {@link #appendCompletedChunk} (although this is not required or
+     *   enforced)
+     *
+     * @return New chunk buffer for caller to fill
+     */
+    public Object[] appendCompletedChunk(Object[] fullChunk)
+    {
+        Node next = new Node(fullChunk);
+        if (_bufferHead == null) { // first chunk
+            _bufferHead = _bufferTail = next;
+        } else { // have something already
+            _bufferTail.linkNext(next);
+            _bufferTail = next;
+        }
+        int len = fullChunk.length;
+        _bufferedEntryCount += len;
+        // double the size for small chunks
+        if (len < SMALL_CHUNK_SIZE) {
+            len += len;
+        } else { // but by +25% for larger (to limit overhead)
+            len += (len >> 2);
+        }
+        return new Object[len];
+    }
+
+    /**
+     * Method called to indicate that the buffering process is now
+     * complete; and to construct a combined exactly-sized result
+     * array. Additionally the buffer itself will be reset to
+     * reduce memory retention.
+     *<p>
+     * Resulting array will be of generic <code>Object[]</code> type:
+     * if a typed array is needed, use the method with additional
+     * type argument.
+     */
+    public Object[] completeAndClearBuffer(Object[] lastChunk, int lastChunkEntries)
+    {
+        int totalSize = lastChunkEntries + _bufferedEntryCount;
+        Object[] result = new Object[totalSize];
+        _copyTo(result, totalSize, lastChunk, lastChunkEntries);
+        return result;
+    }
+
+    /**
+     * Type-safe alternative to
+     * {@link #completeAndClearBuffer(Object[], int)}, to allow
+     * for constructing explicitly typed result array.
+     *
+     * @param componentType Type of elements included in the buffer. Will be
+     *   used for constructing the result array.
+     */
+    public <T> T[] completeAndClearBuffer(Object[] lastChunk, int lastChunkEntries, Class<T> componentType)
+    {
+       int totalSize = lastChunkEntries + _bufferedEntryCount;
+ 	   @SuppressWarnings("unchecked")
+        T[] result = (T[]) Array.newInstance(componentType, totalSize);
+        _copyTo(result, totalSize, lastChunk, lastChunkEntries);
+        _reset();
+        return result;
+    }
+
+    /**
+     * Another
+     * 
+     * @since 1.6
+     */
+    public void completeAndClearBuffer(Object[] lastChunk, int lastChunkEntries, List<Object> resultList)
+    {
+        for (Node n = _bufferHead; n != null; n = n.next()) {
+            Object[] curr = n.getData();
+            for (int i = 0, len = curr.length; i < len; ++i) {
+                resultList.add(curr[i]);
+            }
+        }
+        // and then the last one
+        for (int i = 0; i < lastChunkEntries; ++i) {
+            resultList.add(lastChunk[i]);
+        }
+    }
+    
+    /**
+     * Helper method that can be used to check how much free capacity
+     * will this instance start with. Can be used to choose the best
+     * instance to reuse, based on size of reusable object chunk
+     * buffer holds reference to.
+     */
+    public int initialCapacity()
+    {
+        return (_freeBuffer == null) ? 0 : _freeBuffer.length;
+    }
+
+    /**
+     * Method that can be used to check how many Objects have been buffered
+     * within this buffer.
+     */
+    public int bufferedSize() { return _bufferedEntryCount; }
+
+    /*
+    /**********************************************************
+    /* Internal methods
+    /**********************************************************
+     */
+
+    protected void _reset()
+    {
+        // can we reuse the last (and thereby biggest) array for next time?
+        if (_bufferTail != null) {
+            _freeBuffer = _bufferTail.getData();
+        }
+        // either way, must discard current contents
+        _bufferHead = _bufferTail = null;
+        _bufferedEntryCount = 0;
+    }
+
+    protected final void _copyTo(Object resultArray, int totalSize,
+                                 Object[] lastChunk, int lastChunkEntries)
+    {
+        int ptr = 0;
+
+        for (Node n = _bufferHead; n != null; n = n.next()) {
+            Object[] curr = n.getData();
+            int len = curr.length;
+            System.arraycopy(curr, 0, resultArray, ptr, len);
+            ptr += len;
+        }
+        System.arraycopy(lastChunk, 0, resultArray, ptr, lastChunkEntries);
+        ptr += lastChunkEntries;
+
+        // sanity check (could have failed earlier due to out-of-bounds, too)
+        if (ptr != totalSize) {
+            throw new IllegalStateException("Should have gotten "+totalSize+" entries, got "+ptr);
+        }
+    }
+
+    /*
+    /**********************************************************
+    /* Helper classes
+    /**********************************************************
+     */
+
+    /**
+     * Helper class used to store actual data, in a linked list.
+     */
+    final static class Node
+    {
+        /**
+         * Data stored in this node. Array is considered to be full.
+         */
+        final Object[] _data;
+
+        Node _next;
+
+        public Node(Object[] data) {
+            _data = data;
+        }
+
+        public Object[] getData() { return _data; }
+
+        public Node next() { return _next; }
+
+        public void linkNext(Node next)
+        {
+            if (_next != null) { // sanity check
+                throw new IllegalStateException();
+            }
+            _next = next;
+        }
+    }
+}