calabash-android 0.0.1

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

@@ -0,0 +1,115 @@
+package sh.calaba.org.codehaus.jackson.map;
+
+import sh.calaba.org.codehaus.jackson.map.deser.ValueInstantiator;
+import sh.calaba.org.codehaus.jackson.map.introspect.Annotated;
+import sh.calaba.org.codehaus.jackson.map.jsontype.TypeIdResolver;
+import sh.calaba.org.codehaus.jackson.map.jsontype.TypeResolverBuilder;
+
+/**
+ * Helper class used for handling details of creating handler instances (things
+ * like {@link JsonSerializer}s, {@link JsonDeserializer}s, various type
+ * handlers) of specific types. Actual handler type has been resolved at this
+ * point, so instantiator is strictly responsible for providing a configured
+ * instance by constructing and configuring a new instance, or possibly by
+ * recycling a shared instance. One use case is that of allowing
+ * dependency injection, which would otherwise be difficult to do.
+ *<p>
+ * Custom instances are allowed to return null to indicate that caller should
+ * use the default instantiation handling (which just means calling no-argument
+ * constructor via reflection).
+ *<p>
+ * Care has to be taken to ensure that if instance returned is shared, it will
+ * be thread-safe; caller will not synchronize access to returned instances.
+ * 
+ * @since 1.8
+ */
+public abstract class HandlerInstantiator
+{
+    /*
+    /**********************************************************
+    /* Public API
+    /**********************************************************
+     */
+
+    /**
+     * Method called to get an instance of deserializer of specified type.
+     * 
+     * @param config Deserialization configuration in effect
+     * @param annotated Element (Class, Method, Field, constructor parameter) that
+     *    had annotation defining class of deserializer to construct (to allow
+     *    implementation use information from other annotations)
+     * @param deserClass Class of deserializer instance to return
+     * 
+     * @return Deserializer instance to use
+     */
+    public abstract JsonDeserializer<?> deserializerInstance(DeserializationConfig config,
+            Annotated annotated, Class<? extends JsonDeserializer<?>> deserClass);
+
+    /**
+     * Method called to get an instance of key deserializer of specified type.
+     * 
+     * @param config Deserialization configuration in effect
+     * @param annotated Element (Class, Method, Field, constructor parameter) that
+     *    had annotation defining class of key deserializer to construct (to allow
+     *    implementation use information from other annotations)
+     * @param keyDeserClass Class of key deserializer instance to return
+     * 
+     * @return Key deserializer instance to use
+     */
+    public abstract KeyDeserializer keyDeserializerInstance(DeserializationConfig config,
+            Annotated annotated, Class<? extends KeyDeserializer> keyDeserClass);
+    
+    /**
+     * Method called to get an instance of serializer of specified type.
+     * 
+     * @param config Serialization configuration in effect
+     * @param annotated Element (Class, Method, Field) that
+     *    had annotation defining class of serializer to construct (to allow
+     *    implementation use information from other annotations)
+     * @param serClass Class of serializer instance to return
+     * 
+     * @return Serializer instance to use
+     */
+    public abstract JsonSerializer<?> serializerInstance(SerializationConfig config,
+            Annotated annotated, Class<? extends JsonSerializer<?>> serClass);
+
+    /**
+     * Method called to get an instance of TypeResolverBuilder of specified type.
+     * 
+     * @param config Mapper configuration in effect (either SerializationConfig or
+     *   DeserializationConfig, depending on when instance is being constructed)
+     * @param annotated annotated Element (Class, Method, Field) that
+     *    had annotation defining class of builder to construct (to allow
+     *    implementation use information from other annotations)
+     * @param builderClass Class of builder instance to return
+     * 
+     * @return TypeResolverBuilder instance to use
+     */
+    public abstract TypeResolverBuilder<?> typeResolverBuilderInstance(MapperConfig<?> config,
+            Annotated annotated, Class<? extends TypeResolverBuilder<?>> builderClass);
+
+    /**
+     * Method called to get an instance of TypeIdResolver of specified type.
+     * 
+     * @param config Mapper configuration in effect (either SerializationConfig or
+     *   DeserializationConfig, depending on when instance is being constructed)
+     * @param annotated annotated Element (Class, Method, Field) that
+     *    had annotation defining class of resolver to construct (to allow
+     *    implementation use information from other annotations)
+     * @param resolverClass Class of resolver instance to return
+     * 
+     * @return TypeResolverBuilder instance to use
+     */
+    public abstract TypeIdResolver typeIdResolverInstance(MapperConfig<?> config,
+            Annotated annotated, Class<? extends TypeIdResolver> resolverClass);
+
+    /**
+     * Method called to construct an instance of ValueInstantiator of specified type.
+     * 
+     * @since 1.9
+     */
+    public ValueInstantiator valueInstantiatorInstance(MapperConfig<?> config,
+            Annotated annotated, Class<? extends ValueInstantiator> resolverClass) {
+        return null;
+    }
+}

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

@@ -0,0 +1,85 @@
+package sh.calaba.org.codehaus.jackson.map;
+
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * Abstract class that defines API for objects that provide value to
+ * "inject" during deserialization. An instance of this object
+ * 
+ * @since 1.9
+ */
+public abstract class InjectableValues
+{
+    /**
+     * Method called to find value identified by id <code>valueId</code> to
+     * inject as value of specified property during deserialization, passing
+     * POJO instance in which value will be injected if it is available
+     * (will be available when injected via field or setter; not available
+     * when injected via constructor or factory method argument).
+     * 
+     * @param valueId Object that identifies value to inject; may be a simple
+     *   name or more complex identifier object, whatever provider needs
+     * @param ctxt Deserialization context
+     * @param forProperty Bean property in which value is to be injected
+     * @param beanInstance Bean instance that contains property to inject,
+     *    if available; null if bean has not yet been constructed.
+     */
+    public abstract Object findInjectableValue(Object valueId,
+            DeserializationContext ctxt, BeanProperty forProperty,
+            Object beanInstance);
+
+    /*
+    /**********************************************************
+    /* Standard implementation
+    /**********************************************************
+     */
+
+    /**
+     * Simple standard implementation which uses a simple Map to
+     * store values to inject, identified by simple String keys.
+     */
+    public static class Std
+        extends InjectableValues
+    {
+        protected final Map<String,Object> _values;
+        
+        public Std() {
+            this(new HashMap<String,Object>());
+        }
+
+        public Std(Map<String,Object> values) {
+            _values = values;
+        }
+
+        public Std addValue(String key, Object value)
+        {
+            _values.put(key, value);
+            return this;
+        }
+
+        public Std addValue(Class<?> classKey, Object value)
+        {
+            _values.put(classKey.getName(), value);
+            return this;
+        }
+        
+        @Override
+        public Object findInjectableValue(Object valueId,
+                DeserializationContext ctxt, BeanProperty forProperty,
+                Object beanInstance)
+        {
+            if (!(valueId instanceof String)) {
+                String type = (valueId == null) ? "[null]" : valueId.getClass().getName();
+                throw new IllegalArgumentException("Unrecognized inject value id type ("+type+"), expecting String");
+            }
+            String key = (String) valueId;
+            Object ob = _values.get(key);
+            if (ob == null && !_values.containsKey(key)) {
+                throw new IllegalArgumentException("No injectable id with value '"+key+"' found (for property '"
+                        +forProperty.getName()+"')");
+            }
+            return ob;
+        }
+    }
+}

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

@@ -0,0 +1,166 @@
+package sh.calaba.org.codehaus.jackson.map;
+
+import java.io.IOException;
+
+import sh.calaba.org.codehaus.jackson.JsonParser;
+import sh.calaba.org.codehaus.jackson.JsonProcessingException;
+import sh.calaba.org.codehaus.jackson.JsonToken;
+
+/**
+ * Abstract class that defines API used by {@link ObjectMapper} (and
+ * other chained {@link JsonDeserializer}s too) to deserialize Objects of
+ * arbitrary types from JSON, using provided {@link JsonParser}.
+ */
+public abstract class JsonDeserializer<T>
+{
+    /*
+    /**********************************************************
+    /* Main deserialization methods
+    /**********************************************************
+     */
+    
+    /**
+     * Method that can be called to ask implementation to deserialize
+     * JSON content into the value type this serializer handles.
+     * Returned instance is to be constructed by method itself.
+     *<p>
+     * Pre-condition for this method is that the parser points to the
+     * first event that is part of value to deserializer (and which 
+     * is never JSON 'null' literal, more on this below): for simple
+     * types it may be the only value; and for structured types the
+     * Object start marker.
+     * Post-condition is that the parser will point to the last
+     * event that is part of deserialized value (or in case deserialization
+     * fails, event that was not recognized or usable, which may be
+     * the same event as the one it pointed to upon call).
+     *<p>
+     * Note that this method is never called for JSON null literal,
+     * and thus deserializers need (and should) not check for it.
+     *
+     * @param jp Parsed used for reading JSON content
+     * @param ctxt Context that can be used to access information about
+     *   this deserialization activity.
+     *
+     * @return Deserializer value
+     */
+    public abstract T deserialize(JsonParser jp, DeserializationContext ctxt)
+        throws IOException, JsonProcessingException;
+
+    /**
+     * Alternate deserialization method (compared to the most commonly
+     * used, {@link #deserialize(JsonParser, DeserializationContext)}),
+     * which takes in initialized value instance, to be
+     * configured and/or populated by deserializer.
+     * Method is not necessarily used for all supported types; most commonly
+     * it is used
+     * for Collections and Maps.
+     *<p>
+     * Default implementation just throws
+     * {@link UnsupportedOperationException}, to indicate that types
+     * that do not explicitly add support do not expect to get the call.
+     */
+    public T deserialize(JsonParser jp, DeserializationContext ctxt,
+                         T intoValue)
+        throws IOException, JsonProcessingException
+    {
+        throw new UnsupportedOperationException();
+    }
+
+    /**
+     * Deserialization called when type being deserialized is defined to
+     * contain additional type identifier, to allow for correctly
+     * instantiating correct subtype. This can be due to annotation on
+     * type (or its supertype), or due to global settings without
+     * annotations.
+     *<p>
+     * Default implementation may work for some types, but ideally subclasses
+     * should not rely on current default implementation.
+     * Implementation is mostly provided to avoid compilation errors with older
+     * code.
+     * 
+     * @param typeDeserializer Deserializer to use for handling type information
+     * 
+     * @since 1.5
+     */
+    @SuppressWarnings("unchecked")
+    public Object deserializeWithType(JsonParser jp, DeserializationContext ctxt,
+            TypeDeserializer typeDeserializer)
+        throws IOException, JsonProcessingException
+    {
+        // We could try calling 
+        return (T) typeDeserializer.deserializeTypedFromAny(jp, ctxt);
+    }
+
+    /*
+    /**********************************************************
+    /* Fluent factory methods for constructing decorated versions
+    /**********************************************************
+     */
+
+    /**
+     * Method that will return deserializer instance that is able
+     * to handle "unwrapped" value instances
+     * If no unwrapped instance can be constructed, will simply
+     * return this object as-is.
+     *<p>
+     * Default implementation just returns 'this'
+     * indicating that no unwrapped variant exists
+     * 
+     * @since 1.9
+     */
+    public JsonDeserializer<T> unwrappingDeserializer() {
+        return this;
+    }
+    
+    /*
+    /**********************************************************
+    /* Other accessors
+    /**********************************************************
+     */
+    
+    /**
+     * Method that can be called to determine value to be used for
+     * representing null values (values deserialized when JSON token
+     * is {@link JsonToken#VALUE_NULL}). Usually this is simply
+     * Java null, but for some types (especially primitives) it may be
+     * necessary to use non-null values.
+     *<p>
+     * Note that deserializers are allowed to call this just once and
+     * then reuse returned value; that is, method is not guaranteed to
+     * be called once for each conversion.
+     *<p>
+     * Default implementation simply returns null.
+     */
+    public T getNullValue() { return null; }
+
+    /**
+     * Method called to determine value to be used for "empty" values
+     * (most commonly when deserializing from empty JSON Strings).
+     * Usually this is same as {@link #getNullValue} (which in turn
+     * is usually simply Java null), but it can be overridden
+     * for types. Or, if type should never be converted from empty
+     * String, method can also throw an exception.
+     *<p>
+     * Default implementation simple calls {@link #getNullValue} and
+     * returns value.
+     * 
+     * @since 1.9
+     */
+    public T getEmptyValue() { return getNullValue(); }
+    
+    /*
+    /**********************************************************
+    /* Helper classes
+    /**********************************************************
+     */
+
+    /**
+     * This marker class is only to be used with annotations, to
+     * indicate that <b>no deserializer is configured</b>.
+     *<p>
+     * Specifically, this class is to be used as the marker for
+     * annotation {@link sh.calaba.org.codehaus.jackson.map.annotate.JsonDeserialize}
+     */
+    public abstract static class None
+        extends JsonDeserializer<Object> { }
+}

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

@@ -0,0 +1,335 @@
+package sh.calaba.org.codehaus.jackson.map;
+
+import java.io.Serializable;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Iterator;
+import java.util.LinkedList;
+import java.util.List;
+
+import sh.calaba.org.codehaus.jackson.JsonLocation;
+import sh.calaba.org.codehaus.jackson.JsonParser;
+import sh.calaba.org.codehaus.jackson.JsonProcessingException;
+
+/**
+ * Checked exception used to signal fatal problems with mapping of
+ * content.
+ *<p>
+ * One additional feature is the ability to denote relevant path
+ * of references (during serialization/deserialization) to help in
+ * troubleshooting.
+ */
+public class JsonMappingException
+    extends JsonProcessingException
+{
+    private static final long serialVersionUID = 1L;
+
+    /**
+     * Let's limit length of reference chain, to limit damage in cases
+     * of infinite recursion.
+     */
+    final static int MAX_REFS_TO_LIST = 1000;
+
+    /*
+    /**********************************************************
+    /* Helper classes
+    /**********************************************************
+     */
+
+    /**
+     * Simple bean class used to contain references. References
+     * can be added to indicate execution/reference path that
+     * lead to the problem that caused this exception to be
+     * thrown.
+     */
+    public static class Reference implements Serializable
+    {
+        private static final long serialVersionUID = 1L;
+
+        /**
+         * Object through which reference was resolved. Can be either
+         * actual instance (usually the case for serialization), or
+         * Class (usually the case for deserialization).
+         */
+        protected Object _from;
+
+        /**
+         * Name of field (for beans) or key (for Maps) that is part
+         * of the reference. May be null for Collection types (which
+         * generally have {@link #_index} defined), or when resolving
+         * Map classes without (yet) having an instance to operate on.
+         */
+        protected String _fieldName;
+
+        /**
+         * Index within a {@link Collection} instance that contained
+         * the reference; used if index is relevant and available.
+         * If either not applicable, or not available, -1 is used to
+         * denote "not known".
+         */
+        protected int _index = -1;
+
+        /**
+         * Default constructor for deserialization/sub-classing purposes
+         */
+        protected Reference() { }
+
+        public Reference(Object from) { _from = from; }
+
+        public Reference(Object from, String fieldName) {
+            _from = from;
+            if (fieldName == null) {
+                throw new NullPointerException("Can not pass null fieldName");
+            }
+            _fieldName = fieldName;
+        }
+
+        public Reference(Object from, int index) {
+            _from = from;
+            _index = index;
+        }
+
+        public void setFrom(Object o) { _from = o; }
+        public void setFieldName(String n) { _fieldName = n; }
+        public void setIndex(int ix) { _index = ix; }
+
+        public Object getFrom() { return _from; }
+        public String getFieldName() { return _fieldName; }
+        public int getIndex() { return _index; }
+
+        @Override public String toString() {
+            StringBuilder sb = new StringBuilder();
+            Class<?> cls = (_from instanceof Class<?>) ?
+                ((Class<?>)_from) : _from.getClass();
+            /* Hmmh. Although Class.getName() is mostly ok, it does look
+             * butt-ugly for arrays. So let's use getSimpleName() instead;
+             * but have to prepend package name too.
+             */
+            Package pkg = cls.getPackage();
+            if (pkg != null) {
+                sb.append(pkg.getName());
+                sb.append('.');
+            }
+            sb.append(cls.getSimpleName());
+            sb.append('[');
+            if (_fieldName != null) {
+                sb.append('"');
+                sb.append(_fieldName);
+                sb.append('"');
+            } else if (_index >= 0) {
+                sb.append(_index);
+            } else {
+                sb.append('?');
+            }
+            sb.append(']');
+            return sb.toString();
+        }
+    }
+
+    /*
+    /**********************************************************
+    /* State/configuration
+    /**********************************************************
+     */
+
+    /**
+     * Path through which problem that triggering throwing of
+     * this exception was reached.
+     */
+    protected LinkedList<Reference> _path;
+
+    /*
+    /**********************************************************
+    /* Life-cycle
+    /**********************************************************
+     */
+
+    public JsonMappingException(String msg)
+    {
+        super(msg);
+    }
+
+    public JsonMappingException(String msg, Throwable rootCause)
+    {
+        super(msg, rootCause);
+    }
+
+    public JsonMappingException(String msg, JsonLocation loc)
+    {
+        super(msg, loc);
+    }
+
+    public JsonMappingException(String msg, JsonLocation loc, Throwable rootCause)
+    {
+        super(msg, loc, rootCause);
+    }
+
+    public static JsonMappingException from(JsonParser jp, String msg)
+    {
+        return new JsonMappingException(msg, jp.getTokenLocation());
+    }
+
+    public static JsonMappingException from(JsonParser jp, String msg,
+                                            Throwable problem)
+    {
+        return new JsonMappingException(msg, jp.getTokenLocation(), problem);
+    }
+
+    /**
+     * Method that can be called to either create a new JsonMappingException
+     * (if underlying exception is not a JsonMappingException), or augment
+     * given exception with given path/reference information.
+     *
+     * This version of method is called when the reference is through a
+     * non-indexed object, such as a Map or POJO/bean.
+     */
+    public static JsonMappingException wrapWithPath(Throwable src, Object refFrom,
+                                                    String refFieldName)
+    {
+        return wrapWithPath(src, new Reference(refFrom, refFieldName));
+    }
+
+    /**
+     * Method that can be called to either create a new JsonMappingException
+     * (if underlying exception is not a JsonMappingException), or augment
+     * given exception with given path/reference information.
+     *
+     * This version of method is called when the reference is through an
+     * index, which happens with arrays and Collections.
+     */
+    public static JsonMappingException wrapWithPath(Throwable src, Object refFrom,
+                                                    int index)
+    {
+        return wrapWithPath(src, new Reference(refFrom, index));
+    }
+
+    /**
+     * Method that can be called to either create a new JsonMappingException
+     * (if underlying exception is not a JsonMappingException), or augment
+     * given exception with given path/reference information.
+     */
+    public static JsonMappingException wrapWithPath(Throwable src, Reference ref)
+    {
+        JsonMappingException jme;
+        if (src instanceof JsonMappingException) {
+            jme = (JsonMappingException) src;
+        } else {
+            String msg = src.getMessage();
+            /* Related to [JACKSON-62], let's use a more meaningful placeholder
+             * if all we have is null
+             */
+            if (msg == null || msg.length() == 0) {
+                msg = "(was "+src.getClass().getName()+")";
+            }
+            jme = new JsonMappingException(msg, null, src);
+        }
+        jme.prependPath(ref);
+        return jme;
+    }
+
+    /*
+    /**********************************************************
+    /* Accessors/mutators
+    /**********************************************************
+     */
+
+    public List<Reference> getPath()
+    {
+        if (_path == null) {
+            return Collections.emptyList();
+        }
+        return Collections.unmodifiableList(_path);
+    }
+
+    /**
+     * Method called to prepend a reference information in front of
+     * current path
+     */
+    public void prependPath(Object referrer, String fieldName)
+    {
+        Reference ref = new Reference(referrer, fieldName);
+        prependPath(ref);
+    }
+    /**
+     * Method called to prepend a reference information in front of
+     * current path
+     */
+    public void prependPath(Object referrer, int index)
+    {
+        Reference ref = new Reference(referrer, index);
+        prependPath(ref);
+    }
+
+    public void prependPath(Reference r)
+    {
+        if (_path == null) {
+            _path = new LinkedList<Reference>();
+        }
+        /* Also: let's not increase without bounds. Could choose either
+         * head or tail; tail is easier (no need to ever remove), as
+         * well as potentially more useful so let's use it:
+         */
+        if (_path.size() < MAX_REFS_TO_LIST) {
+            _path.addFirst(r);
+        }
+    }
+
+    /*
+    /**********************************************************
+    /* Overridden methods
+    /**********************************************************
+     */
+
+    /**
+     * Method is overridden so that we can properly inject description
+     * of problem path, if such is defined.
+     */
+    @Override
+    public String getMessage()
+    {
+        /* First: if we have no path info, let's just use parent's
+         * definition as is
+         */
+        String msg = super.getMessage();
+        if (_path == null) {
+            return msg;
+        }
+        /* 19-Feb-2009, tatu: Null and empty messages are not very
+         *   useful (plus nulls would lead to NPEs), so let's
+         *   use something else
+         */
+        StringBuilder sb = (msg == null) ? new StringBuilder() : new StringBuilder(msg);
+        /* 18-Feb-2009, tatu: initially there was a linefeed between
+         *    message and path reference; but unfortunately many systems
+         *   (loggers, junit) seem to assume linefeeds are only added to
+         *   separate stack trace.
+         */
+        sb.append(" (through reference chain: ");
+        _appendPathDesc(sb);
+        sb.append(')');
+        return sb.toString();
+    }
+
+    @Override
+    public String toString()
+    {
+        return getClass().getName()+": "+getMessage();
+    }
+
+    /*
+    /**********************************************************
+    /* Internal methods
+    /**********************************************************
+     */
+
+    protected void _appendPathDesc(StringBuilder sb)
+    {
+        Iterator<Reference> it = _path.iterator();
+        while (it.hasNext()) {
+            sb.append(it.next().toString());
+            if (it.hasNext()) {
+                sb.append("->");
+            }
+        }
+    }
+}