calabash-android 0.4.7.pre6 → 0.4.7.pre7

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

@@ -0,0 +1,180 @@
+package sh.calaba.org.codehaus.jackson.map.util;
+
+/**
+ * Base class for specialized primitive array builders.
+ */
+public abstract class PrimitiveArrayBuilder<T>
+{
+    /**
+     * 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
+
+    T _freeBuffer;
+
+    Node<T> _bufferHead;
+
+    Node<T> _bufferTail;
+
+    /**
+     * Number of total buffered entries in this buffer, counting all instances
+     * within linked list formed by following {@link #_bufferHead}.
+     */
+    int _bufferedEntryCount;
+
+    // // // Recycled instances of sub-classes
+
+    // // // Life-cycle
+
+    protected PrimitiveArrayBuilder() { }
+
+    /*
+    ////////////////////////////////////////////////////////////////////////
+    // Public API
+    ////////////////////////////////////////////////////////////////////////
+     */
+
+    public T resetAndStart()
+    {
+        _reset();
+        return (_freeBuffer == null) ?
+            _constructArray(INITIAL_CHUNK_SIZE) : _freeBuffer;
+    }
+
+    /**
+     * @return Length of the next chunk to allocate
+     */
+    public final T appendCompletedChunk(T fullChunk, int fullChunkLength)
+    {
+        Node<T> next = new Node<T>(fullChunk, fullChunkLength);
+        if (_bufferHead == null) { // first chunk
+            _bufferHead = _bufferTail = next;
+        } else { // have something already
+            _bufferTail.linkNext(next);
+            _bufferTail = next;
+        }
+        _bufferedEntryCount += fullChunkLength;
+        int nextLen = fullChunkLength; // start with last chunk size
+        // double the size for small chunks
+        if (nextLen < SMALL_CHUNK_SIZE) {
+            nextLen += nextLen;
+        } else { // but by +25% for larger (to limit overhead)
+            nextLen += (nextLen >> 2);
+        }
+        return _constructArray(nextLen);
+    }
+
+    public T completeAndClearBuffer(T lastChunk, int lastChunkEntries)
+    {
+        int totalSize = lastChunkEntries + _bufferedEntryCount;
+        T resultArray = _constructArray(totalSize);
+
+        int ptr = 0;
+
+        for (Node<T> n = _bufferHead; n != null; n = n.next()) {
+            ptr = n.copyData(resultArray, ptr);
+        }
+        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);
+        }
+        return resultArray;
+    }
+
+    /*
+    ////////////////////////////////////////////////////////////////////////
+    // Abstract methods for sub-classes to implement
+    ////////////////////////////////////////////////////////////////////////
+     */
+
+    protected abstract T _constructArray(int len);
+
+    /*
+    ////////////////////////////////////////////////////////////////////////
+    // 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;
+    }
+
+    /*
+    ////////////////////////////////////////////////////////////////////////
+    // Helper classes
+    ////////////////////////////////////////////////////////////////////////
+     */
+
+    /**
+     * For actual buffering beyond the current buffer, we can actually
+     * use shared class which only deals with opaque "untyped" chunks.
+     * This works because {@link java.lang.System#arraycopy} does not
+     * take type; hence we can implement some aspects of primitive data
+     * handling in generic fashion.
+     */
+    final static class Node<T>
+    {
+        /**
+         * Data stored in this node.
+         */
+        final T _data;
+
+        /**
+         * Number entries in the (untyped) array. Offset is assumed to be 0.
+         */
+        final int _dataLength;
+
+        Node<T> _next;
+
+        public Node(T data, int dataLen)
+        {
+            _data = data;
+            _dataLength = dataLen;
+        }
+
+        public T getData() { return _data; }
+
+        public int copyData(T dst, int ptr)
+        {
+            System.arraycopy(_data, 0, dst, ptr, _dataLength);
+            ptr += _dataLength;
+            return ptr;
+        }
+
+        public Node<T> next() { return _next; }
+
+        public void linkNext(Node<T> next)
+        {
+            if (_next != null) { // sanity check
+                throw new IllegalStateException();
+            }
+            _next = next;
+        }
+    }
+}

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

@@ -0,0 +1,21 @@
+package sh.calaba.org.codehaus.jackson.map.util;
+
+import java.util.*;
+
+/**
+* Simple helper class used for decoupling instantiation of
+* optionally loaded handlers, like deserializers and deserializers
+* for libraries that are only present on some platforms.
+ * 
+ * @author tatu
+ *
+ * @param <T> Type of objects provided
+ */
+public interface Provider<T>
+{
+    /**
+     * Method used to request provider to provide entries it has
+     */
+    public Collection<T> provide();
+}
+

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

@@ -0,0 +1,54 @@
+package sh.calaba.org.codehaus.jackson.map.util;
+
+import sh.calaba.org.codehaus.jackson.io.SerializedString;
+import sh.calaba.org.codehaus.jackson.map.AnnotationIntrospector;
+import sh.calaba.org.codehaus.jackson.map.MapperConfig;
+import sh.calaba.org.codehaus.jackson.map.introspect.AnnotatedClass;
+import sh.calaba.org.codehaus.jackson.map.introspect.BasicBeanDescription;
+import sh.calaba.org.codehaus.jackson.map.type.ClassKey;
+import sh.calaba.org.codehaus.jackson.type.JavaType;
+
+/**
+ * Helper class for caching resolved root names.
+ */
+public class RootNameLookup
+{
+    /**
+     * For efficient operation, let's try to minimize number of times we
+     * need to introspect root element name to use.
+     */
+    protected LRUMap<ClassKey,SerializedString> _rootNames;
+
+    public RootNameLookup() { }
+
+    public SerializedString findRootName(JavaType rootType, MapperConfig<?> config)
+    {
+        return findRootName(rootType.getRawClass(), config);
+    }
+
+    public synchronized SerializedString findRootName(Class<?> rootType, MapperConfig<?> config)
+    {
+        ClassKey key = new ClassKey(rootType);
+
+        if (_rootNames == null) {
+            _rootNames = new LRUMap<ClassKey,SerializedString>(20, 200);
+        } else {
+            SerializedString name = _rootNames.get(key);
+            if (name != null) {
+                return name;
+            }
+        }
+        BasicBeanDescription beanDesc = (BasicBeanDescription) config.introspectClassAnnotations(rootType);
+        AnnotationIntrospector intr = config.getAnnotationIntrospector();
+        AnnotatedClass ac = beanDesc.getClassInfo();
+        String nameStr = intr.findRootName(ac);
+        // No answer so far? Let's just default to using simple class name
+        if (nameStr == null) {
+            // Should we strip out enclosing class tho? For now, nope:
+            nameStr = rootType.getSimpleName();
+        }
+        SerializedString name = new SerializedString(nameStr);
+        _rootNames.put(key, name);
+        return name;
+    }
+}

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

@@ -0,0 +1,348 @@
+package sh.calaba.org.codehaus.jackson.map.util;
+
+import java.text.DateFormat;
+import java.text.FieldPosition;
+import java.text.ParseException;
+import java.text.ParsePosition;
+import java.text.SimpleDateFormat;
+import java.util.*;
+
+import sh.calaba.org.codehaus.jackson.io.NumberInput;
+
+/**
+ * Default {@link DateFormat} implementation used by standard Date
+ * serializers and deserializers. For serialization defaults to using
+ * an ISO-8601 compliant format (format String "yyyy-MM-dd'T'HH:mm:ss.SSSZ")
+ * and for deserialization, both ISO-8601 and RFC-1123.
+ */
+@SuppressWarnings("serial")
+public class StdDateFormat
+    extends DateFormat
+{
+    /* TODO !!! 24-Nov-2009, tatu: Need to rewrite this class soon:
+     * JDK date parsing is awfully brittle, and ISO-8601 is quite
+     * permissive. The two don't mix, need to write a better one.
+     */
+
+    /**
+     * Defines a commonly used date format that conforms
+     * to ISO-8601 date formatting standard, when it includes basic undecorated
+     * timezone definition
+     */
+    protected final static String DATE_FORMAT_STR_ISO8601 = "yyyy-MM-dd'T'HH:mm:ss.SSSZ";
+
+    /**
+     * Same as 'regular' 8601, but handles 'Z' as an alias for "+0000"
+     * (or "GMT")
+     */
+    protected final static String DATE_FORMAT_STR_ISO8601_Z = "yyyy-MM-dd'T'HH:mm:ss.SSS'Z'";
+
+    /**
+     * ISO-8601 with just the Date part, no time
+     *
+     * @since 1.3.1
+     */
+    protected final static String DATE_FORMAT_STR_PLAIN = "yyyy-MM-dd";
+
+    /**
+     * This constant defines the date format specified by
+     * RFC 1123.
+     */
+    protected final static String DATE_FORMAT_STR_RFC1123 = "EEE, dd MMM yyyy HH:mm:ss zzz";
+
+    /**
+     * For error messages we'll also need a list of all formats.
+     */
+    protected final static String[] ALL_FORMATS = new String[] {
+        DATE_FORMAT_STR_ISO8601,
+        DATE_FORMAT_STR_ISO8601_Z,
+        DATE_FORMAT_STR_RFC1123,
+        DATE_FORMAT_STR_PLAIN
+    };
+
+    protected final static DateFormat DATE_FORMAT_RFC1123;
+
+    protected final static DateFormat DATE_FORMAT_ISO8601;
+    protected final static DateFormat DATE_FORMAT_ISO8601_Z;
+
+    protected final static DateFormat DATE_FORMAT_PLAIN;
+
+    /* Let's construct "blueprint" date format instances: can not be used
+     * as is, due to thread-safety issues, but can be used for constructing
+     * actual instances more cheaply (avoids re-parsing).
+     */
+    static {
+        /* Another important thing: let's force use of GMT for
+         * baseline DataFormat objects
+         */
+        TimeZone gmt = TimeZone.getTimeZone("GMT");
+        DATE_FORMAT_RFC1123 = new SimpleDateFormat(DATE_FORMAT_STR_RFC1123);
+        DATE_FORMAT_RFC1123.setTimeZone(gmt);
+        DATE_FORMAT_ISO8601 = new SimpleDateFormat(DATE_FORMAT_STR_ISO8601);
+        DATE_FORMAT_ISO8601.setTimeZone(gmt);
+        DATE_FORMAT_ISO8601_Z = new SimpleDateFormat(DATE_FORMAT_STR_ISO8601_Z);
+        DATE_FORMAT_ISO8601_Z.setTimeZone(gmt);
+        DATE_FORMAT_PLAIN = new SimpleDateFormat(DATE_FORMAT_STR_PLAIN);
+        DATE_FORMAT_PLAIN.setTimeZone(gmt);
+    }
+
+    /**
+     * A singleton instance can be used for cloning purposes.
+     */
+    public final static StdDateFormat instance = new StdDateFormat();
+
+    protected transient DateFormat _formatRFC1123;
+    protected transient DateFormat _formatISO8601;
+    protected transient DateFormat _formatISO8601_z;
+    protected transient DateFormat _formatPlain;
+
+    /*
+    /**********************************************************
+    /* Life cycle, accessing singleton "standard" formats
+    /**********************************************************
+     */
+
+    public StdDateFormat() { }
+
+    @Override
+    public StdDateFormat clone() {
+        /* Since we always delegate all work to child DateFormat instances,
+         * let's NOT call super.clone(); this is bit unusual, but makes
+         * sense here to avoid unnecessary work.
+         */
+        return new StdDateFormat();
+    }
+
+    /**
+     * Method for getting the globally shared DateFormat instance
+     * that uses GMT timezone and can handle simple ISO-8601
+     * compliant date format.
+     */
+    public static DateFormat getBlueprintISO8601Format() {
+        return DATE_FORMAT_ISO8601;
+    }
+
+    /**
+     * Method for getting a non-shared DateFormat instance
+     * that uses specified timezone and can handle simple ISO-8601
+     * compliant date format.
+     */
+    public static DateFormat getISO8601Format(TimeZone tz) {
+        DateFormat df = (DateFormat) DATE_FORMAT_ISO8601.clone();
+        df.setTimeZone(tz);
+        return df;
+    }
+
+    /**
+     * Method for getting the globally shared DateFormat instance
+     * that uses GMT timezone and can handle RFC-1123
+     * compliant date format.
+     */
+    public static DateFormat getBlueprintRFC1123Format() {
+        return DATE_FORMAT_RFC1123;
+    }
+
+
+    /**
+     * Method for getting a non-shared DateFormat instance
+     * that uses specific timezone and can handle RFC-1123
+     * compliant date format.
+     */
+    public static DateFormat getRFC1123Format(TimeZone tz)
+    {
+        DateFormat df = (DateFormat) DATE_FORMAT_RFC1123.clone();
+        df.setTimeZone(tz);
+        return df;
+    }
+
+    /*
+    /**********************************************************
+    /* Public API
+    /**********************************************************
+     */
+
+    @Override
+    public Date parse(String dateStr) throws ParseException
+    {
+        dateStr = dateStr.trim();
+        ParsePosition pos = new ParsePosition(0);
+        Date result = parse(dateStr, pos);
+        if (result != null) {
+            return result;
+        }
+
+        StringBuilder sb = new StringBuilder();
+        for (String f : ALL_FORMATS) {
+            if (sb.length() > 0) {
+                sb.append("\", \"");
+            } else {
+                sb.append('"');
+            }
+            sb.append(f);
+        }
+        sb.append('"');
+        throw new ParseException
+            (String.format("Can not parse date \"%s\": not compatible with any of standard forms (%s)",
+                           dateStr, sb.toString()), pos.getErrorIndex());
+    }
+
+    @Override
+    public Date parse(String dateStr, ParsePosition pos)
+    {
+        if (looksLikeISO8601(dateStr)) { // also includes "plain"
+            return parseAsISO8601(dateStr, pos);
+        }
+        /* 14-Feb-2010, tatu: As per [JACKSON-236], better also
+         *   consider "stringified" simple time stamp
+         */
+        int i = dateStr.length();
+        while (--i >= 0) {
+            char ch = dateStr.charAt(i);
+            if (ch < '0' || ch > '9') break;
+        }
+        if (i < 0) { // all digits
+            if (NumberInput.inLongRange(dateStr, false)) {
+                return new Date(Long.parseLong(dateStr));
+            }
+        }
+        // Otherwise, fall back to using RFC 1123
+        return parseAsRFC1123(dateStr, pos);
+    }
+
+    @Override
+    public StringBuffer format(Date date, StringBuffer toAppendTo,
+                               FieldPosition fieldPosition)
+    {
+        if (_formatISO8601 == null) {
+            _formatISO8601 = (DateFormat) DATE_FORMAT_ISO8601.clone();
+        }
+        return _formatISO8601.format(date, toAppendTo, fieldPosition);
+    }
+
+    /*
+    /**********************************************************
+    /* Helper methods
+    /**********************************************************
+     */
+
+    /**
+     * Overridable helper method used to figure out which of supported
+     * formats is the likeliest match.
+     */
+    protected boolean looksLikeISO8601(String dateStr)
+    {
+        if (dateStr.length() >= 5
+            && Character.isDigit(dateStr.charAt(0))
+            && Character.isDigit(dateStr.charAt(3))
+            && dateStr.charAt(4) == '-'
+            ) {
+            return true;
+        }
+        return false;
+    }
+
+    protected Date parseAsISO8601(String dateStr, ParsePosition pos)
+    {
+        /* 21-May-2009, tatu: DateFormat has very strict handling of
+         * timezone  modifiers for ISO-8601. So we need to do some scrubbing.
+         */
+
+        /* First: do we have "zulu" format ('Z' == "GMT")? If yes, that's
+         * quite simple because we already set date format timezone to be
+         * GMT, and hence can just strip out 'Z' altogether
+         */
+        int len = dateStr.length();
+        char c = dateStr.charAt(len-1);
+        DateFormat df;
+
+        // [JACKSON-200]: need to support "plain" date...
+        if (len <= 10 && Character.isDigit(c)) {
+           df = _formatPlain;
+            if (df == null) {
+                df = _formatPlain = (DateFormat) DATE_FORMAT_PLAIN.clone();
+            }
+        } else if (c == 'Z') {
+            df = _formatISO8601_z;
+            if (df == null) {
+                df = _formatISO8601_z = (DateFormat) DATE_FORMAT_ISO8601_Z.clone();
+            }
+            // [JACKSON-334]: may be missing milliseconds... if so, add
+            if (dateStr.charAt(len-4) == ':') {
+                StringBuilder sb = new StringBuilder(dateStr);
+                sb.insert(len-1, ".000");
+                dateStr = sb.toString();
+            }
+        } else {
+            // Let's see if we have timezone indicator or not...
+            if (hasTimeZone(dateStr)) {
+                c = dateStr.charAt(len-3);
+                if (c == ':') { // remove optional colon
+                    // remove colon
+                    StringBuilder sb = new StringBuilder(dateStr);
+                    sb.delete(len-3, len-2);
+                    dateStr = sb.toString();
+                } else if (c == '+' || c == '-') { // missing minutes
+                    // let's just append '00'
+                    dateStr += "00";
+                }
+                // [JACKSON-334]: may be missing milliseconds... if so, add
+                len = dateStr.length();
+                // '+0000' (5 chars); should come after '.000' (4 chars) of milliseconds, so:
+                c = dateStr.charAt(len-9);
+                if (Character.isDigit(c)) {
+                    StringBuilder sb = new StringBuilder(dateStr);
+                    sb.insert(len-5, ".000");
+                    dateStr = sb.toString();
+                }
+                
+                df = _formatISO8601;
+                if (_formatISO8601 == null) {
+                    df = _formatISO8601 = (DateFormat) DATE_FORMAT_ISO8601.clone();
+                }
+            } else {
+                /* 24-Nov-2009, tatu: Ugh. This is getting pretty
+                 *   ugly. Need to rewrite soon!
+                 */
+
+                // If not, plain date. Easiest to just patch 'Z' in the end?
+                StringBuilder sb = new StringBuilder(dateStr);
+                // And possible also millisecond part if missing
+                int timeLen = len - dateStr.lastIndexOf('T') - 1;
+                if (timeLen <= 8) {
+                    sb.append(".000");
+                }
+                sb.append('Z');
+                dateStr = sb.toString();
+                df = _formatISO8601_z;
+                if (df == null) {
+                    df = _formatISO8601_z = (DateFormat) DATE_FORMAT_ISO8601_Z.clone();
+                }
+            }
+        }
+        return df.parse(dateStr, pos);
+    }
+
+    protected Date parseAsRFC1123(String dateStr, ParsePosition pos)
+    {
+        if (_formatRFC1123 == null) {
+            _formatRFC1123 = (DateFormat) DATE_FORMAT_RFC1123.clone();
+        }
+        return _formatRFC1123.parse(dateStr, pos);
+    }
+
+    private final static boolean hasTimeZone(String str)
+    {
+        // Only accept "+hh", "+hhmm" and "+hh:mm" (and with minus), so
+        int len = str.length();
+        if (len >= 6) {
+            char c = str.charAt(len-6);
+            if (c == '+' || c == '-') return true;
+            c = str.charAt(len-5);
+            if (c == '+' || c == '-') return true;
+            c = str.charAt(len-3);
+            if (c == '+' || c == '-') return true;
+        }
+        return false;
+    }
+}
+