calabash-android 0.0.1

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

@@ -0,0 +1,6 @@
+/**
+ * Parser and generator implementation classes that Jackson
+ * defines and uses.
+ * Application code should not (need to) use contents of this package.
+ */
+package sh.calaba.org.codehaus.jackson.impl;

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

@@ -0,0 +1,117 @@
+
+package sh.calaba.org.codehaus.jackson.io;
+
+import java.io.*;
+
+
+/**
+ * Simple basic class for optimized readers in this package; implements
+ * "cookie-cutter" methods that are used by all actual implementations.
+ */
+abstract class BaseReader
+    extends Reader
+{
+    /**
+     * JSON actually limits available Unicode range in the high end
+     * to the same as xml (to basically limit UTF-8 max byte sequence
+     * length to 4)
+     */
+    final protected static int LAST_VALID_UNICODE_CHAR = 0x10FFFF;
+
+    final protected static char NULL_CHAR = (char) 0;
+    final protected static char NULL_BYTE = (byte) 0;
+
+    final protected IOContext _context;
+
+    protected InputStream _in;
+
+    protected byte[] _buffer;
+
+    protected int _ptr;
+    protected int _length;
+
+    /*
+    /**********************************************************
+    /* Life-cycle
+    /**********************************************************
+     */
+
+    protected BaseReader(IOContext context,
+                         InputStream in, byte[] buf, int ptr, int len)
+    {
+        _context = context;
+        _in = in;
+        _buffer = buf;
+        _ptr = ptr;
+        _length = len;
+    }
+
+    /*
+    /**********************************************************
+    /* Reader API
+    /**********************************************************
+     */
+
+    @Override
+    public void close() throws IOException
+    {
+        InputStream in = _in;
+
+        if (in != null) {
+            _in = null;
+            freeBuffers();
+            in.close();
+        }
+    }
+
+    protected char[] _tmpBuf = null;
+
+    /**
+     * Although this method is implemented by the base class, AND it should
+     * never be called by main code, let's still implement it bit more
+     * efficiently just in case
+     */
+    @Override
+    public int read() throws IOException
+    {
+        if (_tmpBuf == null) {
+            _tmpBuf = new char[1];
+        }
+        if (read(_tmpBuf, 0, 1) < 1) {
+            return -1;
+        }
+        return _tmpBuf[0];
+    }
+
+    /*
+    /**********************************************************
+    /* Internal/package methods:
+    /**********************************************************
+     */
+
+    /**
+     * This method should be called along with (or instead of) normal
+     * close. After calling this method, no further reads should be tried.
+     * Method will try to recycle read buffers (if any).
+     */
+    public final void freeBuffers()
+    {
+        byte[] buf = _buffer;
+        if (buf != null) {
+            _buffer = null;
+            _context.releaseReadIOBuffer(buf);
+        }
+    }
+
+    protected void reportBounds(char[] cbuf, int start, int len)
+        throws IOException
+    {
+        throw new ArrayIndexOutOfBoundsException("read(buf,"+start+","+len+"), cbuf["+cbuf.length+"]");
+    }
+
+    protected void reportStrangeStream()
+        throws IOException
+    {
+        throw new IOException("Strange I/O stream, returned 0 bytes on read");
+    }
+}

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

@@ -0,0 +1,73 @@
+package sh.calaba.org.codehaus.jackson.io;
+
+import sh.calaba.org.codehaus.jackson.SerializableString;
+import sh.calaba.org.codehaus.jackson.util.CharTypes;
+
+/**
+ * Abstract base class that defines interface for customizing character
+ * escaping aspects for String values, for formats that use escaping.
+ * For JSON this applies to both property names and String values.
+ *
+ * @since 1.8
+ */
+public abstract class CharacterEscapes
+{
+    /**
+     * Value used for lookup tables to indicate that matching characters
+     * do not need to be escaped.
+     */
+    public final static int ESCAPE_NONE = 0;
+
+    /**
+     * Value used for lookup tables to indicate that matching characters
+     * are to be escaped using standard escaping; for JSON this means
+     * (for example) using "backslash - u" escape method.
+     */
+    public final static int ESCAPE_STANDARD = -1;
+
+    /**
+     * Value used for lookup tables to indicate that matching characters
+     * will need custom escapes; and that another call
+     * to {@link #getEscapeSequence} is needed to figure out exact escape
+     * sequence to output.
+     */
+    public final static int ESCAPE_CUSTOM = -2;
+    
+    /**
+     * Method generators can call to get lookup table for determining
+     * escape handling for first 128 characters of Unicode (ASCII
+     * characters. Caller is not to modify contents of this array, since
+     * this is expected to be a shared copy.
+     * 
+     * @return Array with size of at least 128, where first 128 entries
+     *    have either one of <code>ESCAPE_xxx</code> constants, or non-zero positive
+     *    integer (meaning of which is data format specific; for JSON it means
+     *    that combination of backslash and character with that value is to be used)
+     *    to indicate that specific escape sequence is to be used.
+     */
+    public abstract int[] getEscapeCodesForAscii();
+
+    /**
+     * Method generators can call to get lookup table for determining
+     * exact escape sequence to use for given character.
+     * It can be called for any character, but typically is called for
+     * either for ASCII characters for which custom escape
+     * sequence is needed; or for any non-ASCII character.
+     */
+    public abstract SerializableString getEscapeSequence(int ch);
+
+    /**
+     * Helper method that can be used to get a copy of standard JSON
+     * escape definitions; this is useful when just wanting to slightly
+     * customize definitions. Caller can modify this array as it sees
+     * fit and usually returns modified instance via {@link #getEscapeCodesForAscii}
+     */
+    public static int[] standardAsciiEscapesForJSON()
+    {
+        int[] esc = CharTypes.get7BitOutputEscapes();
+        int len = esc.length;
+        int[] result = new int[len];
+        System.arraycopy(esc, 0, result, 0, esc.length);
+        return result;
+    }
+}

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

@@ -0,0 +1,239 @@
+package sh.calaba.org.codehaus.jackson.io;
+
+import sh.calaba.org.codehaus.jackson.JsonEncoding;
+import sh.calaba.org.codehaus.jackson.util.BufferRecycler;
+import sh.calaba.org.codehaus.jackson.util.TextBuffer;
+
+/**
+ * To limit number of configuration and state objects to pass, all
+ * contextual objects that need to be passed by the factory to
+ * readers and writers are combined under this object. One instance
+ * is created for each reader and writer.
+ */
+public final class IOContext
+{
+    /*
+    /**********************************************************
+    /* Configuration
+    /**********************************************************
+     */
+
+    /**
+     * Reference to the source object, which can be used for displaying
+     * location information
+     */
+    protected final Object _sourceRef;
+
+    /**
+     * Encoding used by the underlying stream, if known.
+     */
+    protected JsonEncoding _encoding;
+
+    /**
+     * Flag that indicates whether underlying input/output source/target
+     * object is fully managed by the owner of this context (parser or
+     * generator). If true, it is, and is to be closed by parser/generator;
+     * if false, calling application has to do closing (unless auto-closing
+     * feature is enabled for the parser/generator in question; in which
+     * case it acts like the owner).
+     */
+    protected final boolean _managedResource;
+
+    /*
+    /**********************************************************
+    /* Buffer handling, recycling
+    /**********************************************************
+     */
+
+    /**
+     * Recycler used for actual allocation/deallocation/reuse
+     */
+    protected final BufferRecycler _bufferRecycler;
+
+    /**
+     * Reference to the allocated I/O buffer for low-level input reading,
+     * if any allocated.
+     */
+    protected byte[] _readIOBuffer = null;
+
+    /**
+     * Reference to the allocated I/O buffer used for low-level
+     * encoding-related buffering.
+     */
+    protected byte[] _writeEncodingBuffer = null;
+    
+    /**
+     * Reference to the buffer allocated for tokenization purposes,
+     * in which character input is read, and from which it can be
+     * further returned.
+     */
+    protected char[] _tokenCBuffer = null;
+
+    /**
+     * Reference to the buffer allocated for buffering it for
+     * output, before being encoded: generally this means concatenating
+     * output, then encoding when buffer fills up.
+     */
+    protected char[] _concatCBuffer = null;
+
+    /**
+     * Reference temporary buffer Parser instances need if calling
+     * app decides it wants to access name via 'getTextCharacters' method.
+     * Regular text buffer can not be used as it may contain textual
+     * representation of the value token.
+     */
+    protected char[] _nameCopyBuffer = null;
+
+    /*
+    /**********************************************************
+    /* Life-cycle
+    /**********************************************************
+     */
+
+    public IOContext(BufferRecycler br, Object sourceRef, boolean managedResource)
+    {
+        _bufferRecycler = br;
+        _sourceRef = sourceRef;
+        _managedResource = managedResource;
+    }
+
+    public void setEncoding(JsonEncoding enc)
+    {
+        _encoding = enc;
+    }
+
+    /*
+    /**********************************************************
+    /* Public API, accessors
+    /**********************************************************
+     */
+
+    public final Object getSourceReference() { return _sourceRef; }
+    public final JsonEncoding getEncoding() { return _encoding; }
+    public final boolean isResourceManaged() { return _managedResource; }
+    
+    /*
+    /**********************************************************
+    /* Public API, buffer management
+    /**********************************************************
+     */
+
+    public final TextBuffer constructTextBuffer() {
+        return new TextBuffer(_bufferRecycler);
+    }
+
+    /**
+     *<p>
+     * Note: the method can only be called once during its life cycle.
+     * This is to protect against accidental sharing.
+     */
+    public final byte[] allocReadIOBuffer()
+    {
+        if (_readIOBuffer != null) {
+            throw new IllegalStateException("Trying to call allocReadIOBuffer() second time");
+        }
+        _readIOBuffer = _bufferRecycler.allocByteBuffer(BufferRecycler.ByteBufferType.READ_IO_BUFFER);
+        return _readIOBuffer;
+    }
+
+    public final byte[] allocWriteEncodingBuffer()
+    {
+        if (_writeEncodingBuffer != null) {
+            throw new IllegalStateException("Trying to call allocWriteEncodingBuffer() second time");
+        }
+        _writeEncodingBuffer = _bufferRecycler.allocByteBuffer(BufferRecycler.ByteBufferType.WRITE_ENCODING_BUFFER);
+        return _writeEncodingBuffer;
+    }
+    
+    public final char[] allocTokenBuffer()
+    {
+        if (_tokenCBuffer != null) {
+            throw new IllegalStateException("Trying to call allocTokenBuffer() second time");
+        }
+        _tokenCBuffer = _bufferRecycler.allocCharBuffer(BufferRecycler.CharBufferType.TOKEN_BUFFER);
+        return _tokenCBuffer;
+    }
+
+    public final char[] allocConcatBuffer()
+    {
+        if (_concatCBuffer != null) {
+            throw new IllegalStateException("Trying to call allocConcatBuffer() second time");
+        }
+        _concatCBuffer = _bufferRecycler.allocCharBuffer(BufferRecycler.CharBufferType.CONCAT_BUFFER);
+        return _concatCBuffer;
+    }
+
+    public final char[] allocNameCopyBuffer(int minSize)
+    {
+        if (_nameCopyBuffer != null) {
+            throw new IllegalStateException("Trying to call allocNameCopyBuffer() second time");
+        }
+        _nameCopyBuffer = _bufferRecycler.allocCharBuffer(BufferRecycler.CharBufferType.NAME_COPY_BUFFER, minSize);
+        return _nameCopyBuffer;
+    }
+
+    /**
+     * Method to call when all the processing buffers can be safely
+     * recycled.
+     */
+    public final void releaseReadIOBuffer(byte[] buf)
+    {
+        if (buf != null) {
+            /* Let's do sanity checks to ensure once-and-only-once release,
+             * as well as avoiding trying to release buffers not owned
+             */
+            if (buf != _readIOBuffer) {
+                throw new IllegalArgumentException("Trying to release buffer not owned by the context");
+            }
+            _readIOBuffer = null;
+            _bufferRecycler.releaseByteBuffer(BufferRecycler.ByteBufferType.READ_IO_BUFFER, buf);
+        }
+    }
+
+    public final void releaseWriteEncodingBuffer(byte[] buf)
+    {
+        if (buf != null) {
+            /* Let's do sanity checks to ensure once-and-only-once release,
+             * as well as avoiding trying to release buffers not owned
+             */
+            if (buf != _writeEncodingBuffer) {
+                throw new IllegalArgumentException("Trying to release buffer not owned by the context");
+            }
+            _writeEncodingBuffer = null;
+            _bufferRecycler.releaseByteBuffer(BufferRecycler.ByteBufferType.WRITE_ENCODING_BUFFER, buf);
+        }
+    }
+    
+    public final void releaseTokenBuffer(char[] buf)
+    {
+        if (buf != null) {
+            if (buf != _tokenCBuffer) {
+                throw new IllegalArgumentException("Trying to release buffer not owned by the context");
+            }
+            _tokenCBuffer = null;
+            _bufferRecycler.releaseCharBuffer(BufferRecycler.CharBufferType.TOKEN_BUFFER, buf);
+        }
+    }
+
+    public final void releaseConcatBuffer(char[] buf)
+    {
+        if (buf != null) {
+            if (buf != _concatCBuffer) {
+                throw new IllegalArgumentException("Trying to release buffer not owned by the context");
+            }
+            _concatCBuffer = null;
+            _bufferRecycler.releaseCharBuffer(BufferRecycler.CharBufferType.CONCAT_BUFFER, buf);
+        }
+    }
+
+    public final void releaseNameCopyBuffer(char[] buf)
+    {
+        if (buf != null) {
+            if (buf != _nameCopyBuffer) {
+                throw new IllegalArgumentException("Trying to release buffer not owned by the context");
+            }
+            _nameCopyBuffer = null;
+            _bufferRecycler.releaseCharBuffer(BufferRecycler.CharBufferType.NAME_COPY_BUFFER, buf);
+        }
+    }
+}

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

@@ -0,0 +1,67 @@
+package sh.calaba.org.codehaus.jackson.io;
+
+import java.io.*;
+
+/**
+ * Handler class that can be used to decorate input sources.
+ * Typical use is to use a filter abstraction (filtered stream,
+ * reader) around original input source, and apply additional
+ * processing during read operations.
+ * 
+ * @since 1.8
+ */
+public abstract class InputDecorator
+{
+    /**
+     * Method called by {@link sh.calaba.org.codehaus.jackson.JsonFactory} instance when
+     * creating parser given an {@link InputStream}, when this decorator
+     * has been registered.
+     * 
+     * @param ctxt IO context in use (provides access to declared encoding).
+     *   NOTE: at this point context may not have all information initialized;
+     *   specifically auto-detected encoding is only available once parsing starts,
+     *   which may occur only after this method is called.
+     * @param in Original input source
+     * 
+     * @return InputStream to use; either passed in argument, or something that
+     *   calls it
+     */
+    public abstract InputStream decorate(IOContext ctxt, InputStream in)
+        throws IOException;
+
+    /**
+     * Method called by {@link sh.calaba.org.codehaus.jackson.JsonFactory} instance when
+     * creating parser on given "raw" byte source.
+     * Method can either construct a {@link InputStream} for reading; or return
+     * null to indicate that no wrapping should occur.
+     * 
+     * @param ctxt IO context in use (provides access to declared encoding)
+     *   NOTE: at this point context may not have all information initialized;
+     *   specifically auto-detected encoding is only available once parsing starts,
+     *   which may occur only after this method is called.
+     * @param src Input buffer that contains contents to parse
+     * @param offset Offset of the first available byte in the input buffer
+     * @param length Number of bytes available in the input buffer
+     * 
+     * @return Either {@link InputStream} to use as input source; or null to indicate
+     *   that contents are to be processed as-is by caller
+     */
+    public abstract InputStream decorate(IOContext ctxt, byte[] src, int offset, int length)
+        throws IOException;
+    
+    /**
+     * Method called by {@link sh.calaba.org.codehaus.jackson.JsonFactory} instance when
+     * creating parser given an {@link Reader}, when this decorator
+     * has been registered.
+     * 
+     * @param ctxt IO context in use (provides access to declared encoding)
+     *   NOTE: at this point context may not have all information initialized;
+     *   specifically auto-detected encoding is only available once parsing starts,
+     *   which may occur only after this method is called.
+     * @param src Original input source
+     * 
+     * @return Reader to use; either passed in argument, or something that
+     *   calls it (for example, a {@link FilterReader})
+     */
+    public abstract Reader decorate(IOContext ctxt, Reader src) throws IOException;
+}