calabash-android 0.4.7.pre4 → 0.4.7.pre6

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

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

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

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

@@ -1,335 +0,0 @@
-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("->");
-            }
-        }
-    }
-}