calabash-android 0.4.7.pre4 → 0.4.7.pre6

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

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

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

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

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