calabash-android 0.0.1

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

@@ -0,0 +1,60 @@
+package sh.calaba.org.codehaus.jackson.type;
+
+import java.lang.reflect.ParameterizedType;
+import java.lang.reflect.Type;
+
+/**
+ * This class is used to pass full generics type information, and
+ * avoid problems with type erasure (that basically removes most
+ * usable type references from runtime Class objects).
+ * It is based on ideas from
+ * <a href="http://gafter.blogspot.com/2006/12/super-type-tokens.html"
+ * >http://gafter.blogspot.com/2006/12/super-type-tokens.html</a>,
+ * Additional idea (from a suggestion made in comments of the article)
+ * is to require bogus implementation of <code>Comparable</code>
+ * (any such generic interface would do, as long as it forces a method
+ * with generic type to be implemented).
+ * to ensure that a Type argument is indeed given.
+ *<p>
+ * Usage is by sub-classing: here is one way to instantiate reference
+ * to generic type <code>List&lt;Integer></code>:
+ *<pre>
+ *  TypeReference ref = new TypeReference&lt;List&lt;Integer>>() { };
+ *</pre>
+ * which can be passed to methods that accept TypeReference.
+ */
+public abstract class TypeReference<T>
+    implements Comparable<TypeReference<T>>
+{
+    final Type _type;
+
+    protected TypeReference()
+    {
+        Type superClass = getClass().getGenericSuperclass();
+        if (superClass instanceof Class<?>) { // sanity check, should never happen
+            throw new IllegalArgumentException("Internal error: TypeReference constructed without actual type information");
+        }
+        /* 22-Dec-2008, tatu: Not sure if this case is safe -- I suspect
+         *   it is possible to make it fail?
+         *   But let's deal with specifc
+         *   case when we know an actual use case, and thereby suitable
+         *   work arounds for valid case(s) and/or error to throw
+         *   on invalid one(s).
+         */
+        _type = ((ParameterizedType) superClass).getActualTypeArguments()[0];
+    }
+
+    public Type getType() { return _type; }
+
+    /**
+     * The only reason we define this method (and require implementation
+     * of <code>Comparable</code>) is to prevent constructing a
+     * reference without type information.
+     */
+    @Override
+    public int compareTo(TypeReference<T> o) {
+        // just need an implementation, not a good one... hence:
+        return 0;
+    }
+}
+

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

@@ -0,0 +1,8 @@
+/**
+ * Contains classes needed for type introspection, mostly used by data binding
+ * functionality. Most of this functionality is needed to properly handled
+ * generic types, and to simplify and unify processing of things Jackson needs
+ * to determine how contained types (of {@link java.util.Collection} and
+ * {@link java.util.Map} classes) are to be handled.
+ */
+package sh.calaba.org.codehaus.jackson.type;

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

@@ -0,0 +1,109 @@
+package sh.calaba.org.codehaus.jackson.util;
+
+/**
+ * This is a small utility class, whose main functionality is to allow
+ * simple reuse of raw byte/char buffers. It is usually used through
+ * <code>ThreadLocal</code> member of the owning class pointing to
+ * instance of this class through a <code>SoftReference</code>. The
+ * end result is a low-overhead GC-cleanable recycling: hopefully
+ * ideal for use by stream readers.
+ */
+public class BufferRecycler
+{
+    public final static int DEFAULT_WRITE_CONCAT_BUFFER_LEN = 2000;
+    
+    public enum ByteBufferType {
+        READ_IO_BUFFER(4000)
+        /**
+         * Buffer used for temporarily storing encoded content; used
+         * for example by UTF-8 encoding writer
+         */
+        ,WRITE_ENCODING_BUFFER(4000)
+
+        /**
+         * Buffer used for temporarily concatenating output; used for
+         * example when requesting output as byte array.
+         */
+        ,WRITE_CONCAT_BUFFER(2000)
+        ;
+            
+        private final int size;
+
+        ByteBufferType(int size) { this.size = size; }
+    }
+
+    public enum CharBufferType {
+        TOKEN_BUFFER(2000) // Tokenizable input
+            ,CONCAT_BUFFER(2000) // concatenated output
+            ,TEXT_BUFFER(200) // Text content from input
+            ,NAME_COPY_BUFFER(200) // Temporary buffer for getting name characters
+            ;
+        
+        private final int size;
+
+        CharBufferType(int size) { this.size = size; }
+    }
+
+    final protected byte[][] _byteBuffers = new byte[ByteBufferType.values().length][];
+    final protected char[][] _charBuffers = new char[CharBufferType.values().length][];
+
+    public BufferRecycler() { }
+
+    public final byte[] allocByteBuffer(ByteBufferType type)
+    {
+        int ix = type.ordinal();
+        byte[] buffer = _byteBuffers[ix];
+        if (buffer == null) {
+            buffer = balloc(type.size);
+        } else {
+            _byteBuffers[ix] = null;
+        }
+        return buffer;
+    }
+
+    public final void releaseByteBuffer(ByteBufferType type, byte[] buffer)
+    {
+        _byteBuffers[type.ordinal()] = buffer;
+    }
+
+    public final char[] allocCharBuffer(CharBufferType type)
+    {
+        return allocCharBuffer(type, 0);
+    }
+
+    public final char[] allocCharBuffer(CharBufferType type, int minSize)
+    {
+        if (type.size > minSize) {
+            minSize = type.size;
+        }
+        int ix = type.ordinal();
+        char[] buffer = _charBuffers[ix];
+        if (buffer == null || buffer.length < minSize) {
+            buffer = calloc(minSize);
+        } else {
+            _charBuffers[ix] = null;
+        }
+        return buffer;
+    }
+
+    public final void releaseCharBuffer(CharBufferType type, char[] buffer)
+    {
+        _charBuffers[type.ordinal()] = buffer;
+    }
+
+    /*
+    /**********************************************************
+    /* Actual allocations separated for easier debugging/profiling
+    /**********************************************************
+     */
+
+    private final byte[] balloc(int size)
+    {
+        return new byte[size];
+    }
+
+    private final char[] calloc(int size)
+    {
+        return new char[size];
+    }
+}

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

@@ -0,0 +1,294 @@
+/* Jackson JSON-processor.
+ *
+ * Copyright (c) 2007- Tatu Saloranta, tatu.saloranta@iki.fi
+ *
+ * Licensed under the License specified in file LICENSE, included with
+ * the source code and binary code bundles.
+ * You may not use this file except in compliance with the License.
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package sh.calaba.org.codehaus.jackson.util;
+
+import java.io.OutputStream;
+import java.util.*;
+
+/**
+ * Helper class that is similar to {@link java.io.ByteArrayOutputStream}
+ * in usage, but more geared to Jackson use cases internally.
+ * Specific changes include segment storage (no need to have linear
+ * backing buffer, can avoid reallocs, copying), as well API
+ * not based on {@link java.io.OutputStream}. In short, a very much
+ * specialized builder object.
+ *<p>
+ * Since version 1.5, also implements {@link OutputStream} to allow
+ * efficient aggregation of output content as a byte array, similar
+ * to how {@link java.io.ByteArrayOutputStream} works, but somewhat more
+ * efficiently for many use cases.
+ */
+public final class ByteArrayBuilder
+    extends OutputStream
+{
+    private final static byte[] NO_BYTES = new byte[0];
+    
+    /**
+     * Size of the first block we will allocate.
+     */
+    private final static int INITIAL_BLOCK_SIZE = 500;
+    
+    /**
+     * Maximum block size we will use for individual non-aggregated
+     * blocks. Let's limit to using 256k chunks.
+     */
+    private final static int MAX_BLOCK_SIZE = (1 << 18);
+    
+    final static int DEFAULT_BLOCK_ARRAY_SIZE = 40;
+
+    /**
+     * Optional buffer recycler instance that we can use for allocating
+     * the first block.
+     * 
+     * @since 1.5
+     */
+    private final BufferRecycler _bufferRecycler;
+    
+    private final LinkedList<byte[]> _pastBlocks = new LinkedList<byte[]>();
+    
+    /**
+     * Number of bytes within byte arrays in {@link _pastBlocks}.
+     */
+    private int _pastLen;
+
+    private byte[] _currBlock;
+
+    private int _currBlockPtr;
+    
+    public ByteArrayBuilder() { this(null); }
+
+    public ByteArrayBuilder(BufferRecycler br) { this(br, INITIAL_BLOCK_SIZE); }
+
+    public ByteArrayBuilder(int firstBlockSize) { this(null, firstBlockSize); }
+
+    public ByteArrayBuilder(BufferRecycler br, int firstBlockSize)
+    {
+        _bufferRecycler = br;
+        if (br == null) {
+            _currBlock = new byte[firstBlockSize];
+        } else {
+            _currBlock = br.allocByteBuffer(BufferRecycler.ByteBufferType.WRITE_CONCAT_BUFFER);
+        }
+    }
+
+    public void reset()
+    {
+        _pastLen = 0;
+        _currBlockPtr = 0;
+
+        if (!_pastBlocks.isEmpty()) {
+            _pastBlocks.clear();
+        }
+    }
+
+    /**
+     * Clean up method to call to release all buffers this object may be
+     * using. After calling the method, no other accessors can be used (and
+     * attempt to do so may result in an exception)
+     */
+    public void release() {
+        reset();
+        if (_bufferRecycler != null && _currBlock != null) {
+            _bufferRecycler.releaseByteBuffer(BufferRecycler.ByteBufferType.WRITE_CONCAT_BUFFER, _currBlock);
+            _currBlock = null;
+        }
+    }
+
+    public void append(int i)
+    {
+        if (_currBlockPtr >= _currBlock.length) {
+            _allocMore();
+        }
+        _currBlock[_currBlockPtr++] = (byte) i;
+    }
+
+    public void appendTwoBytes(int b16)
+    {
+        if ((_currBlockPtr + 1) < _currBlock.length) {
+            _currBlock[_currBlockPtr++] = (byte) (b16 >> 8);
+            _currBlock[_currBlockPtr++] = (byte) b16;
+        } else {
+            append(b16 >> 8);
+            append(b16);
+        }
+    }
+
+    public void appendThreeBytes(int b24)
+    {
+        if ((_currBlockPtr + 2) < _currBlock.length) {
+            _currBlock[_currBlockPtr++] = (byte) (b24 >> 16);
+            _currBlock[_currBlockPtr++] = (byte) (b24 >> 8);
+            _currBlock[_currBlockPtr++] = (byte) b24;
+        } else {
+            append(b24 >> 16);
+            append(b24 >> 8);
+            append(b24);
+        }
+    }
+
+    /**
+     * Method called when results are finalized and we can get the
+     * full aggregated result buffer to return to the caller
+     */
+    public byte[] toByteArray()
+    {
+        int totalLen = _pastLen + _currBlockPtr;
+        
+        if (totalLen == 0) { // quick check: nothing aggregated?
+            return NO_BYTES;
+        }
+        
+        byte[] result = new byte[totalLen];
+        int offset = 0;
+
+        for (byte[] block : _pastBlocks) {
+            int len = block.length;
+            System.arraycopy(block, 0, result, offset, len);
+            offset += len;
+        }
+        System.arraycopy(_currBlock, 0, result, offset, _currBlockPtr);
+        offset += _currBlockPtr;
+        if (offset != totalLen) { // just a sanity check
+            throw new RuntimeException("Internal error: total len assumed to be "+totalLen+", copied "+offset+" bytes");
+        }
+        // Let's only reset if there's sizable use, otherwise will get reset later on
+        if (!_pastBlocks.isEmpty()) {
+            reset();
+        }
+        return result;
+    }
+
+    /*
+    /**********************************************************
+    /* Non-stream API (similar to TextBuffer), since 1.6
+    /**********************************************************
+     */
+
+    /**
+     * Method called when starting "manual" output: will clear out
+     * current state and return the first segment buffer to fill
+     * 
+     * @since 1.6
+     */
+    public byte[] resetAndGetFirstSegment() {
+        reset();
+        return _currBlock;
+    }
+
+    /**
+     * Method called when the current segment buffer is full; will
+     * append to current contents, allocate a new segment buffer
+     * and return it
+     * 
+     * @since 1.6
+     */
+    public byte[] finishCurrentSegment() {
+        _allocMore();
+        return _currBlock;
+    }
+
+    /**
+     * Method that will complete "manual" output process, coalesce
+     * content (if necessary) and return results as a contiguous buffer.
+     * 
+     * @param lastBlockLength Amount of content in the current segment
+     * buffer.
+     * 
+     * @return Coalesced contents
+     */
+    public byte[] completeAndCoalesce(int lastBlockLength)
+    {
+        _currBlockPtr = lastBlockLength;
+        return toByteArray();
+    }
+
+    public byte[] getCurrentSegment() {
+        return _currBlock;
+    }
+
+    public void setCurrentSegmentLength(int len) {
+        _currBlockPtr = len;
+    }
+
+    public int getCurrentSegmentLength() {
+        return _currBlockPtr;
+    }
+    
+    /*
+    /**********************************************************
+    /* OutputStream implementation
+    /**********************************************************
+     */
+    
+    @Override
+    public void write(byte[] b) {
+        write(b, 0, b.length);
+    }
+
+    @Override
+    public void write(byte[] b, int off, int len)
+    {
+        while (true) {
+            int max = _currBlock.length - _currBlockPtr;
+            int toCopy = Math.min(max, len);
+            if (toCopy > 0) {
+                System.arraycopy(b, off, _currBlock, _currBlockPtr, toCopy);
+                off += toCopy;
+                _currBlockPtr += toCopy;
+                len -= toCopy;
+            }
+            if (len <= 0) break;
+            _allocMore();
+        }
+    }
+
+    @Override
+    public void write(int b) {
+        append(b);
+    }
+
+    @Override public void close() { /* NOP */ }
+
+    @Override public void flush() { /* NOP */ }
+
+    /*
+    /**********************************************************
+    /* Internal methods
+    /**********************************************************
+     */
+    
+    private void _allocMore()
+    {
+        _pastLen += _currBlock.length;
+
+        /* Let's allocate block that's half the total size, except
+         * never smaller than twice the initial block size.
+         * The idea is just to grow with reasonable rate, to optimize
+         * between minimal number of chunks and minimal amount of
+         * wasted space.
+         */
+        int newSize = Math.max((_pastLen >> 1), (INITIAL_BLOCK_SIZE + INITIAL_BLOCK_SIZE));
+        // plus not to exceed max we define...
+        if (newSize > MAX_BLOCK_SIZE) {
+            newSize = MAX_BLOCK_SIZE;
+        }
+        _pastBlocks.add(_currBlock);
+        _currBlock = new byte[newSize];
+        _currBlockPtr = 0;
+    }
+
+}
+