calabash-android 0.5.2 → 0.5.3

data/test-server/instrumentation-backend/src/sh/calaba/org/codehaus/jackson/io/OutputDecorator.java

@@ -1,40 +0,0 @@
-package sh.calaba.org.codehaus.jackson.io;
-
-import java.io.*;
-
-/**
- * Handler class that can be used to decorate output destinations.
- * Typical use is to use a filter abstraction (filtered output stream,
- * writer) around original output destination, and apply additional
- * processing during write operations.
- * 
- * @since 1.8
- */
-public abstract class OutputDecorator
-{
-    /**
-     * Method called by {@link sh.calaba.org.codehaus.jackson.JsonFactory} instance when
-     * creating generator for given {@link OutputStream}, when this decorator
-     * has been registered.
-     * 
-     * @param ctxt IO context in use (provides access to declared encoding)
-     * @param out Original output destination
-     * 
-     * @return OutputStream to use; either passed in argument, or something that
-     *   calls it
-     */
-    public abstract OutputStream decorate(IOContext ctxt, OutputStream out)
-        throws IOException;
-
-    /**
-     * Method called by {@link sh.calaba.org.codehaus.jackson.JsonFactory} instance when
-     * creating generator for given {@link Writer}, when this decorator
-     * has been registered.
-     * 
-     * @param ctxt IO context in use (provides access to declared encoding)
-     * @param w Original output writer
-     * 
-     * @return Writer to use; either passed in argument, or something that calls it
-     */
-    public abstract Writer decorate(IOContext ctxt, Writer w) throws IOException;
-}

data/test-server/instrumentation-backend/src/sh/calaba/org/codehaus/jackson/io/SegmentedStringWriter.java

@@ -1,104 +0,0 @@
-package sh.calaba.org.codehaus.jackson.io;
-
-import java.io.*;
-
-import sh.calaba.org.codehaus.jackson.util.BufferRecycler;
-import sh.calaba.org.codehaus.jackson.util.TextBuffer;
-
-/**
- * Efficient alternative to {@link StringWriter}, based on using segmented
- * internal buffer. Initial input buffer is also recyclable.
- *<p>
- * This class is most useful when serializing JSON content as a String:
- * if so, instance of this class can be given as the writer to
- * <code>JsonGenerator</code>.
- *
- * @since 1.3
- */
-public final class SegmentedStringWriter
-    extends Writer
-{
-    final protected TextBuffer _buffer;
-
-    public SegmentedStringWriter(BufferRecycler br)
-    {
-        super();
-        _buffer = new TextBuffer(br);
-    }
-
-    /*
-    /**********************************************************
-    /* java.io.Writer implementation
-    /**********************************************************
-     */
-
-    @Override
-    public Writer append(char c)
-    {
-        write(c);
-        return this;
-    }
-
-    @Override
-    public Writer append(CharSequence csq)
-    {
-	String str = csq.toString();
-	_buffer.append(str, 0, str.length());
-        return this;
-    }
-
-    @Override
-    public Writer append(CharSequence csq, int start, int end)
-    {
-	String str = csq.subSequence(start, end).toString();
-	_buffer.append(str, 0, str.length());
-        return this;
-    }
-
-    @Override public void close() { } // NOP
-
-    @Override public void flush() { } // NOP
-
-    @Override
-    public void write(char[] cbuf) {
-        _buffer.append(cbuf, 0, cbuf.length);
-    }
-
-    @Override
-    public void write(char[] cbuf, int off, int len) {
-        _buffer.append(cbuf, off, len);
-    }
-
-    @Override
-    public void write(int c) {
-        _buffer.append((char) c);
-    }
-
-    @Override
-    public void write(String str) { _buffer.append(str, 0, str.length()); }
-
-    @Override
-    public void write(String str, int off, int len) {
-        _buffer.append(str, 0, str.length());
-    }
-
-    /*
-    /**********************************************************
-    /* Extended API
-    /**********************************************************
-     */
-
-    /**
-     * Main access method that will construct a String that contains
-     * all the contents, release all internal buffers we may have,
-     * and return result String.
-     * Note that the method is not idempotent -- if called second time,
-     * will just return an empty String.
-     */
-    public String getAndClear()
-    {
-        String result = _buffer.contentsAsString();
-        _buffer.releaseBuffers();
-        return result;
-    }
-}

data/test-server/instrumentation-backend/src/sh/calaba/org/codehaus/jackson/io/SerializedString.java

@@ -1,114 +0,0 @@
-package sh.calaba.org.codehaus.jackson.io;
-
-import sh.calaba.org.codehaus.jackson.SerializableString;
-
-/**
- * String token that can lazily serialize String contained and then reuse that
- * serialization later on. This is similar to JDBC prepared statements, for example,
- * in that instances should only be created when they are used more than use;
- * prime candidates are various serializers.
- *<p>
- * Class is final for performance reasons and since this is not designed to
- * be extensible or customizable (customizations would occur in calling code)
- *
- * @since 1.6
- */
-public class SerializedString implements SerializableString
-{
-    protected final String _value;
-
-    /* 13-Dec-2010, tatu: Whether use volatile or not is actually an important
-     *   decision for multi-core use cases. Cost of volatility can be non-trivial
-     *   for heavy use cases, and serialized-string instances are accessed often.
-     *   Given that all code paths with common Jackson usage patterns go through
-     *   a few memory barriers (mostly with cache/reuse pool access) it seems safe
-     *   enough to omit volatiles here, given how simple lazy initialization is.
-     *   This can be compared to how {@link String#intern} works; lazily and
-     *   without synchronization or use of volatile keyword.
-     */
-    
-    protected /*volatile*/ byte[] _quotedUTF8Ref;
-
-    protected /*volatile*/ byte[] _unquotedUTF8Ref;
-
-    protected /*volatile*/ char[] _quotedChars;
-
-    public SerializedString(String v) { _value = v; }
-
-    /*
-    /**********************************************************
-    /* API
-    /**********************************************************
-     */
-
-    @Override
-    public final String getValue() { return _value; }
-    
-    /**
-     * Returns length of the String as characters
-     */
-    @Override
-    public final int charLength() { return _value.length(); }
-    
-    @Override
-    public final char[] asQuotedChars()
-    {
-        char[] result = _quotedChars;
-        if (result == null) {
-            result = JsonStringEncoder.getInstance().quoteAsString(_value);
-            _quotedChars = result;
-        }
-        return result;
-    }
-
-    /**
-     * Accessor for accessing value that has been quoted using JSON
-     * quoting rules, and encoded using UTF-8 encoding.
-     */
-    @Override
-    public final byte[] asUnquotedUTF8()
-    {
-        byte[] result = _unquotedUTF8Ref;
-        if (result == null) {
-            result = JsonStringEncoder.getInstance().encodeAsUTF8(_value);
-            _unquotedUTF8Ref  = result;
-        }
-        return result;
-    }
-
-    /**
-     * Accessor for accessing value as is (without JSON quoting)
-     * encoded using UTF-8 encoding.
-     */
-    @Override
-    public final byte[] asQuotedUTF8()
-    {
-        byte[] result = _quotedUTF8Ref;
-        if (result == null) {
-            result = JsonStringEncoder.getInstance().quoteAsUTF8(_value);
-            _quotedUTF8Ref = result;
-        }
-        return result;
-    }
-    
-    /*
-    /**********************************************************
-    /* Standard method overrides
-    /**********************************************************
-     */
-
-    @Override
-    public final String toString() { return _value; }
-    
-    @Override
-    public final int hashCode() { return _value.hashCode(); }
-
-    @Override
-    public final boolean equals(Object o)
-    {
-        if (o == this) return true;
-        if (o == null || o.getClass() != getClass()) return false;
-        SerializedString other = (SerializedString) o;
-        return _value.equals(other._value);
-    }
-}

data/test-server/instrumentation-backend/src/sh/calaba/org/codehaus/jackson/io/UTF32Reader.java

@@ -1,214 +0,0 @@
-package sh.calaba.org.codehaus.jackson.io;
-
-import java.io.*;
-
-
-/**
- * Since JDK does not come with UTF-32/UCS-4, let's implement a simple
- * decoder to use.
- */
-public final class UTF32Reader
-    extends BaseReader
-{
-    final boolean mBigEndian;
-
-    /**
-     * Although input is fine with full Unicode set, Java still uses
-     * 16-bit chars, so we may have to split high-order chars into
-     * surrogate pairs.
-     */
-    char mSurrogate = NULL_CHAR;
-
-    /**
-     * Total read character count; used for error reporting purposes
-     */
-    int mCharCount = 0;
-
-    /**
-     * Total read byte count; used for error reporting purposes
-     */
-    int mByteCount = 0;
-
-    /*
-    ////////////////////////////////////////
-    // Life-cycle
-    ////////////////////////////////////////
-    */
-
-    public UTF32Reader(IOContext ctxt,
-                       InputStream in, byte[] buf, int ptr, int len,
-                       boolean isBigEndian)
-    {
-        super(ctxt, in, buf, ptr, len);
-        mBigEndian = isBigEndian;
-    }
-
-    /*
-    ////////////////////////////////////////
-    // Public API
-    ////////////////////////////////////////
-    */
-
-    @Override
-	public int read(char[] cbuf, int start, int len)
-        throws IOException
-    {
-        // Already EOF?
-        if (_buffer == null) {
-            return -1;
-        }
-        if (len < 1) {
-            return len;
-        }
-        // Let's then ensure there's enough room...
-        if (start < 0 || (start+len) > cbuf.length) {
-            reportBounds(cbuf, start, len);
-        }
-
-        len += start;
-        int outPtr = start;
-
-        // Ok, first; do we have a surrogate from last round?
-        if (mSurrogate != NULL_CHAR) {
-            cbuf[outPtr++] = mSurrogate;
-            mSurrogate = NULL_CHAR;
-            // No need to load more, already got one char
-        } else {
-            /* Note: we'll try to avoid blocking as much as possible. As a
-             * result, we only need to get 4 bytes for a full char.
-             */
-            int left = (_length - _ptr);
-            if (left < 4) {
-                if (!loadMore(left)) { // (legal) EOF?
-                    return -1;
-                }
-            }
-        }
-
-        main_loop:
-        while (outPtr < len) {
-            int ptr = _ptr;
-            int ch;
-
-            if (mBigEndian) {
-                ch = (_buffer[ptr] << 24) | ((_buffer[ptr+1] & 0xFF) << 16)
-                    | ((_buffer[ptr+2] & 0xFF) << 8) | (_buffer[ptr+3] & 0xFF);
-            } else {
-                ch = (_buffer[ptr] & 0xFF) | ((_buffer[ptr+1] & 0xFF) << 8)
-                    | ((_buffer[ptr+2] & 0xFF) << 16) | (_buffer[ptr+3] << 24);
-            }
-            _ptr += 4;
-
-            // Does it need to be split to surrogates?
-            // (also, we can and need to verify illegal chars)
-            if (ch > 0xFFFF) { // need to split into surrogates?
-                if (ch > LAST_VALID_UNICODE_CHAR) {
-                    reportInvalid(ch, outPtr-start,
-                                  "(above "+Integer.toHexString(LAST_VALID_UNICODE_CHAR)+") ");
-                }
-                ch -= 0x10000; // to normalize it starting with 0x0
-                cbuf[outPtr++] = (char) (0xD800 + (ch >> 10));
-                // hmmh. can this ever be 0? (not legal, at least?)
-                ch = (0xDC00 | (ch & 0x03FF));
-                // Room for second part?
-                if (outPtr >= len) { // nope
-                    mSurrogate = (char) ch;
-                    break main_loop;
-                }
-            }
-            cbuf[outPtr++] = (char) ch;
-            if (_ptr >= _length) {
-                break main_loop;
-            }
-        }
-
-        len = outPtr - start;
-        mCharCount += len;
-        return len;
-    }
-
-    /*
-    ////////////////////////////////////////
-    // Internal methods
-    ////////////////////////////////////////
-    */
-
-    private void reportUnexpectedEOF(int gotBytes, int needed)
-        throws IOException
-    {
-        int bytePos = mByteCount + gotBytes;
-        int charPos = mCharCount;
-
-        throw new CharConversionException("Unexpected EOF in the middle of a 4-byte UTF-32 char: got "
-                                          +gotBytes+", needed "+needed
-                                          +", at char #"+charPos+", byte #"+bytePos+")");
-    }
-
-    private void reportInvalid(int value, int offset, String msg)
-        throws IOException
-    {
-        int bytePos = mByteCount + _ptr - 1;
-        int charPos = mCharCount + offset;
-
-        throw new CharConversionException("Invalid UTF-32 character 0x"
-                                          +Integer.toHexString(value)
-                                          +msg+" at char #"+charPos+", byte #"+bytePos+")");
-    }
-
-    /**
-     * @param available Number of "unused" bytes in the input buffer
-     *
-     * @return True, if enough bytes were read to allow decoding of at least
-     *   one full character; false if EOF was encountered instead.
-     */
-    private boolean loadMore(int available)
-        throws IOException
-    {
-        mByteCount += (_length - available);
-
-        // Bytes that need to be moved to the beginning of buffer?
-        if (available > 0) {
-            if (_ptr > 0) {
-                for (int i = 0; i < available; ++i) {
-                    _buffer[i] = _buffer[_ptr+i];
-                }
-                _ptr = 0;
-            }
-            _length = available;
-        } else {
-            /* Ok; here we can actually reasonably expect an EOF,
-             * so let's do a separate read right away:
-             */
-            _ptr = 0;
-            int count = _in.read(_buffer);
-            if (count < 1) {
-                _length = 0;
-                if (count < 0) { // -1
-                    freeBuffers(); // to help GC?
-                    return false;
-                }
-                // 0 count is no good; let's err out
-                reportStrangeStream();
-            }
-            _length = count;
-        }
-
-        /* Need at least 4 bytes; if we don't get that many, it's an
-         * error.
-         */
-        while (_length < 4) {
-            int count = _in.read(_buffer, _length, _buffer.length - _length);
-            if (count < 1) {
-                if (count < 0) { // -1, EOF... no good!
-                    freeBuffers(); // to help GC?
-                    reportUnexpectedEOF(_length, 4);
-                }
-                // 0 count is no good; let's err out
-                reportStrangeStream();
-            }
-            _length += count;
-        }
-        return true;
-    }
-}
-