calabash-android 0.0.1

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

@@ -0,0 +1,80 @@
+package sh.calaba.org.codehaus.jackson;
+
+/**
+ * Intermediate base class for all problems encountered when
+ * processing (parsing, generating) JSON content
+ * that are not pure I/O problems.
+ * Regular {@link java.io.IOException}s will be passed through as is.
+ * Sub-class of {@link java.io.IOException} for convenience.
+ */
+public class JsonProcessingException
+    extends java.io.IOException
+{
+    final static long serialVersionUID = 123; // Stupid eclipse...
+	
+    protected JsonLocation mLocation;
+
+    protected JsonProcessingException(String msg, JsonLocation loc, Throwable rootCause)
+    {
+        /* Argh. IOException(Throwable,String) is only available starting
+         * with JDK 1.6...
+         */
+        super(msg);
+        if (rootCause != null) {
+            initCause(rootCause);
+        }
+        mLocation = loc;
+    }
+
+    protected JsonProcessingException(String msg)
+    {
+        super(msg);
+    }
+
+    protected JsonProcessingException(String msg, JsonLocation loc)
+    {
+        this(msg, loc, null);
+    }
+
+    protected JsonProcessingException(String msg, Throwable rootCause)
+    {
+        this(msg, null, rootCause);
+    }
+
+    protected JsonProcessingException(Throwable rootCause)
+    {
+        this(null, null, rootCause);
+    }
+
+    public JsonLocation getLocation()
+    {
+        return mLocation;
+    }
+
+    /**
+     * Default method overridden so that we can add location information
+     */
+    @Override
+    public String getMessage()
+    {
+        String msg = super.getMessage();
+        if (msg == null) {
+            msg = "N/A";
+        }
+        JsonLocation loc = getLocation();
+        if (loc != null) {
+            StringBuilder sb = new StringBuilder();
+            sb.append(msg);
+            sb.append('\n');
+            sb.append(" at ");
+            sb.append(loc.toString());
+            return sb.toString();
+        }
+        return msg;
+    }
+
+    @Override
+    public String toString() {
+        return getClass().getName()+": "+getMessage();
+    }
+}

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

@@ -0,0 +1,122 @@
+/* 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;
+
+/**
+ * Shared base class for streaming processing contexts used during
+ * reading and writing of Json content using Streaming API.
+ * This context is also exposed to applications:
+ * context object can be used by applications to get an idea of
+ * relative position of the parser/generator within json content
+ * being processed. This allows for some contextual processing: for
+ * example, output within Array context can differ from that of
+ * Object context.
+ */
+public abstract class JsonStreamContext
+{
+    // // // Type constants used internally
+
+    protected final static int TYPE_ROOT = 0;
+    protected final static int TYPE_ARRAY = 1;
+    protected final static int TYPE_OBJECT = 2;
+
+    protected int _type;
+
+    /**
+     * Index of the currently processed entry. Starts with -1 to signal
+     * that no entries have been started, and gets advanced each
+     * time a new entry is started, either by encountering an expected
+     * separator, or with new values if no separators are expected
+     * (the case for root context).
+     */
+    protected int _index;
+
+    /*
+    /**********************************************************
+    /* Life-cycle
+    /**********************************************************
+     */
+
+    protected JsonStreamContext() { }
+
+    /*
+    /**********************************************************
+    /* Public API, accessors
+    /**********************************************************
+     */
+
+    /**
+     * Accessor for finding parent context of this context; will
+     * return null for root context.
+     */
+    public abstract JsonStreamContext getParent();
+
+    /**
+     * Method that returns true if this context is an Array context;
+     * that is, content is being read from or written to a Json Array.
+     */
+    public final boolean inArray() { return _type == TYPE_ARRAY; }
+
+    /**
+     * Method that returns true if this context is a Root context;
+     * that is, content is being read from or written to without
+     * enclosing array or object structure.
+     */
+    public final boolean inRoot() { return _type == TYPE_ROOT; }
+
+    /**
+     * Method that returns true if this context is an Object context;
+     * that is, content is being read from or written to a Json Object.
+     */
+    public final boolean inObject() { return _type == TYPE_OBJECT; }
+
+    /**
+     * Method for accessing simple type description of current context;
+     * either ROOT (for root-level values), OBJECT (for field names and
+     * values of JSON Objects) or ARRAY (for values of JSON Arrays)
+     */
+    public final String getTypeDesc() {
+        switch (_type) {
+        case TYPE_ROOT: return "ROOT";
+        case TYPE_ARRAY: return "ARRAY";
+        case TYPE_OBJECT: return "OBJECT";
+        }
+        return "?";
+    }
+
+    /**
+     * @return Number of entries that are complete and started.
+     */
+    public final int getEntryCount()
+    {
+        return _index + 1;
+    }
+
+    /**
+     * @return Index of the currently processed entry, if any
+     */
+    public final int getCurrentIndex()
+    {
+        return (_index < 0) ? 0 : _index;
+    }
+
+    /**
+     * Method for accessing name associated with the current location.
+     * Non-null for <code>FIELD_NAME</code> and value events that directly
+     * follow field names; null for root level and array values.
+     */
+    public abstract String getCurrentName();
+}

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

@@ -0,0 +1,161 @@
+package sh.calaba.org.codehaus.jackson;
+
+/**
+ * Enumeration for basic token types used for returning results
+ * of parsing JSON content.
+ */
+public enum JsonToken
+{
+    /* Some notes on implementation:
+     *
+     * - Entries are to be ordered such that start/end array/object
+     *   markers come first, then field name marker (if any), and
+     *   finally scalar value tokens. This is assumed by some
+     *   typing checks.
+     */
+
+    /**
+     * NOT_AVAILABLE can be returned if {@link JsonParser}
+     * implementation can not currently return the requested
+     * token (usually next one), or even if any will be
+     * available, but that may be able to determine this in
+     * future. This is the case with non-blocking parsers --
+     * they can not block to wait for more data to parse and
+     * must return something.
+     *
+     * @since 0.9.7
+     */
+    NOT_AVAILABLE(null),
+
+    /**
+     * START_OBJECT is returned when encountering '{'
+     * which signals starting of an Object value.
+     */
+    START_OBJECT("{"),
+        
+    /**
+     * START_OBJECT is returned when encountering '}'
+     * which signals ending of an Object value
+     */
+    END_OBJECT("}"),
+        
+    /**
+     * START_OBJECT is returned when encountering '['
+     * which signals starting of an Array value
+     */
+    START_ARRAY("["),
+
+    /**
+     * START_OBJECT is returned when encountering ']'
+     * which signals ending of an Array value
+     */
+    END_ARRAY("]"),
+        
+    /**
+     * FIELD_NAME is returned when a String token is encountered
+     * as a field name (same lexical value, different function)
+     */
+    FIELD_NAME(null),
+        
+    /**
+     * Placeholder token returned when the input source has a concept
+     * of embedded Object that are not accessible as usual structure
+     * (of starting with {@link #START_OBJECT}, having values, ending with
+     * {@link #END_OBJECT}), but as "raw" objects.
+     *<p>
+     * Note: this token is never returned by regular JSON readers, but
+     * only by readers that expose other kinds of source (like
+     * {@link JsonNode}-based JSON trees, Maps, Lists and such).
+     *
+     * @since 1.1
+     */
+    VALUE_EMBEDDED_OBJECT(null),
+
+    /**
+     * VALUE_STRING is returned when a String token is encountered
+     * in value context (array element, field value, or root-level
+     * stand-alone value)
+     */
+    VALUE_STRING(null),
+
+    /**
+     * VALUE_NUMBER_INT is returned when an integer numeric token is
+     * encountered in value context: that is, a number that does
+     * not have floating point or exponent marker in it (consists
+     * only of an optional sign, followed by one or more digits)
+     */
+    VALUE_NUMBER_INT(null),
+
+    /**
+     * VALUE_NUMBER_INT is returned when a numeric token other
+     * that is not an integer is encountered: that is, a number that does
+     * have floating point or exponent marker in it, in addition
+     * to one or more digits.
+     */
+    VALUE_NUMBER_FLOAT(null),
+
+    /**
+     * VALUE_TRUE is returned when encountering literal "true" in
+     * value context
+     */
+    VALUE_TRUE("true"),
+
+    /**
+     * VALUE_FALSE is returned when encountering literal "false" in
+     * value context
+     */
+    VALUE_FALSE("false"),
+
+    /**
+     * VALUE_NULL is returned when encountering literal "null" in
+     * value context
+     */
+    VALUE_NULL("null")
+        ;
+
+    final String _serialized;
+
+    final char[] _serializedChars;
+
+    final byte[] _serializedBytes;
+
+    /**
+     * @param Textual representation for this token, if there is a
+     *   single static representation; null otherwise
+     */
+    JsonToken(String token)
+    {
+        if (token == null) {
+            _serialized = null;
+            _serializedChars = null;
+            _serializedBytes = null;
+        } else {
+            _serialized = token;
+            _serializedChars = token.toCharArray();
+            // It's all in ascii, can just case...
+            int len = _serializedChars.length;
+            _serializedBytes = new byte[len];
+            for (int i = 0; i < len; ++i) {
+                _serializedBytes[i] = (byte) _serializedChars[i];
+            }
+        }
+    }
+
+    public String asString() { return _serialized; }
+    public char[] asCharArray() { return _serializedChars; }
+    public byte[] asByteArray() { return _serializedBytes; }
+
+    public boolean isNumeric() {
+        return (this == VALUE_NUMBER_INT) || (this == VALUE_NUMBER_FLOAT);
+    }
+
+    /**
+     * Method that can be used to check whether this token represents
+     * a valid non-structured value. This means all tokens other than
+     * Object/Array start/end markers all field names.
+     */
+    public boolean isScalarValue() {
+        // note: up to 1.5, VALUE_EMBEDDED_OBJECT was incorrectly considered non-scalar!
+        return ordinal() >= VALUE_EMBEDDED_OBJECT.ordinal();
+    }
+}

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

@@ -0,0 +1,157 @@
+package sh.calaba.org.codehaus.jackson;
+
+import java.io.IOException;
+import java.util.Iterator;
+
+import sh.calaba.org.codehaus.jackson.type.JavaType;
+import sh.calaba.org.codehaus.jackson.type.TypeReference;
+
+/**
+ * Abstract class that defines the interface that {@link JsonParser} and
+ * {@link JsonGenerator} use to serialize and deserialize regular
+ * Java objects (POJOs aka Beans).
+ *<p>
+ * The standard implementation of this class is
+ * {@link sh.calaba.org.codehaus.jackson.map.ObjectMapper}.
+ */
+public abstract class ObjectCodec
+{
+    protected ObjectCodec() { }
+
+    /*
+    /**********************************************************
+    /* API for de-serialization (JSON-to-Object)
+    /**********************************************************
+     */
+
+    /**
+     * Method to deserialize JSON content into a non-container
+     * type (it can be an array type, however): typically a bean, array
+     * or a wrapper type (like {@link java.lang.Boolean}).
+     *<p>
+     * Note: this method should NOT be used if the result type is a
+     * container ({@link java.util.Collection} or {@link java.util.Map}.
+     * The reason is that due to type erasure, key and value types
+     * can not be introspected when using this method.
+     */
+    public abstract <T> T readValue(JsonParser jp, Class<T> valueType)
+        throws IOException, JsonProcessingException;
+
+    /**
+     * Method to deserialize JSON content into a Java type, reference
+     * to which is passed as argument. Type is passed using so-called
+     * "super type token" 
+     * and specifically needs to be used if the root type is a 
+     * parameterized (generic) container type.
+     */
+    public abstract <T> T readValue(JsonParser jp, TypeReference<?> valueTypeRef)
+        throws IOException, JsonProcessingException;
+
+    /**
+     * Method to deserialize JSON content as tree expressed
+     * using set of {@link JsonNode} instances. Returns
+     * root of the resulting tree (where root can consist
+     * of just a single node if the current event is a
+     * value event, not container).
+     */
+    public abstract <T> T readValue(JsonParser jp, JavaType valueType)
+        throws IOException, JsonProcessingException;
+
+    /**
+     * Method to deserialize JSON content as tree expressed
+     * using set of {@link JsonNode} instances. Returns
+     * root of the resulting tree (where root can consist
+     * of just a single node if the current event is a
+     * value event, not container).
+     */
+    public abstract JsonNode readTree(JsonParser jp)
+        throws IOException, JsonProcessingException;
+
+    /**
+     * Method for reading sequence of Objects from parser stream,
+     * all with same specified value type.
+     * 
+     * @since 1.9
+     */
+    public abstract <T> Iterator<T> readValues(JsonParser jp, Class<T> valueType)
+        throws IOException, JsonProcessingException;
+
+    /**
+     * Method for reading sequence of Objects from parser stream,
+     * all with same specified value type.
+     * 
+     * @since 1.9
+     */
+    public abstract <T> Iterator<T> readValues(JsonParser jp, TypeReference<?> valueTypeRef)
+        throws IOException, JsonProcessingException;
+    
+    /**
+     * Method for reading sequence of Objects from parser stream,
+     * all with same specified value type.
+     * 
+     * @since 1.9
+     */
+    public abstract <T> Iterator<T> readValues(JsonParser jp, JavaType valueType)
+        throws IOException, JsonProcessingException;
+    
+    /*
+    /**********************************************************
+    /* API for serialization (Object-to-JSON)
+    /**********************************************************
+     */
+
+    /**
+     * Method to serialize given Java Object, using generator
+     * provided.
+     */
+    public abstract void writeValue(JsonGenerator jgen, Object value)
+        throws IOException, JsonProcessingException;
+
+    /**
+     * Method to serialize given Json Tree, using generator
+     * provided.
+     */
+    public abstract void writeTree(JsonGenerator jgen, JsonNode rootNode)
+        throws IOException, JsonProcessingException;
+
+    /*
+    /**********************************************************
+    /* API for Tree Model handling
+    /**********************************************************
+     */
+
+    /**
+     * Method for construct root level Object nodes
+     * for Tree Model instances.
+     *
+     * @since 1.2
+     */
+    public abstract JsonNode createObjectNode();
+
+    /**
+     * Method for construct root level Array nodes
+     * for Tree Model instances.
+     *
+     * @since 1.2
+     */
+    public abstract JsonNode createArrayNode();
+
+    /**
+     * Method for constructing a {@link JsonParser} for reading
+     * contents of a JSON tree, as if it was external serialized
+     * JSON content.
+     *
+     * @since 1.3
+     */
+    public abstract JsonParser treeAsTokens(JsonNode n);
+
+    /**
+     * Convenience method for converting given JSON tree into instance of specified
+     * value type. This is equivalent to first constructing a {@link JsonParser} to
+     * iterate over contents of the tree, and using that parser for data binding.
+     * 
+     * @since 1.3
+     */
+    public abstract <T> T treeToValue(JsonNode n, Class<T> valueType)
+        throws IOException, JsonProcessingException;
+}