calabash-android 0.5.2 → 0.5.3

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

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

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

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

@@ -1,294 +0,0 @@
-/* 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;
-    }
-
-}
-