calabash-android 0.0.1

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

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

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

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

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