calabash-android 0.5.2 → 0.5.3

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

@@ -1,340 +0,0 @@
-package sh.calaba.org.codehaus.jackson.map.deser.std;
-
-import java.io.IOException;
-import java.lang.reflect.Constructor;
-import java.lang.reflect.Method;
-import java.util.UUID;
-
-import sh.calaba.org.codehaus.jackson.JsonProcessingException;
-import sh.calaba.org.codehaus.jackson.io.NumberInput;
-import sh.calaba.org.codehaus.jackson.map.*;
-import sh.calaba.org.codehaus.jackson.map.introspect.AnnotatedMethod;
-import sh.calaba.org.codehaus.jackson.map.util.ClassUtil;
-import sh.calaba.org.codehaus.jackson.map.util.EnumResolver;
-
-/**
- * Base class for simple key deserializers.
- * 
- * @since 1.9 (moved from 'sh.calaba.org.codehaus.jackson.map.deser.StdKeyDeserializer')
- */
-public abstract class StdKeyDeserializer
-    extends KeyDeserializer
-{
-    final protected Class<?> _keyClass;
-
-    protected StdKeyDeserializer(Class<?> cls) { _keyClass = cls; }
-
-    @Override
-    public final Object deserializeKey(String key, DeserializationContext ctxt)
-        throws IOException, JsonProcessingException
-    {
-        if (key == null) { // is this even legal call?
-            return null;
-        }
-        try {
-            Object result = _parse(key, ctxt);
-            if (result != null) {
-                return result;
-            }
-        } catch (Exception re) {
-            throw ctxt.weirdKeyException(_keyClass, key, "not a valid representation: "+re.getMessage());
-        }
-        throw ctxt.weirdKeyException(_keyClass, key, "not a valid representation");
-    }
-
-    public Class<?> getKeyClass() { return _keyClass; }
-
-    protected abstract Object _parse(String key, DeserializationContext ctxt) throws Exception;
-
-    /*
-    /**********************************************************
-    /* Helper methods for sub-classes
-    /**********************************************************
-     */
-
-    protected int _parseInt(String key) throws IllegalArgumentException
-    {
-        return Integer.parseInt(key);
-    }
-
-    protected long _parseLong(String key) throws IllegalArgumentException
-    {
-        return Long.parseLong(key);
-    }
-
-    protected double _parseDouble(String key) throws IllegalArgumentException
-    {
-        return NumberInput.parseDouble(key);
-    }
-
-    /*
-    /**********************************************************
-    /* First: the standard "String as String" deserializer
-    /**********************************************************
-     */
-
-    final static class StringKD extends StdKeyDeserializer
-    {
-        private final static StringKD sString = new StringKD(String.class);
-        private final static StringKD sObject = new StringKD(Object.class);
-        
-        private StringKD(Class<?> nominalType) { super(nominalType); }
-
-        public static StringKD forType(Class<?> nominalType)
-        {
-            if (nominalType == String.class) {
-                return sString;
-            }
-            if (nominalType == Object.class) {
-                return sObject;
-            }
-            return new StringKD(nominalType);
-        }
-        
-        @Override
-        public String _parse(String key, DeserializationContext ctxt) throws JsonMappingException {
-            return key;
-        }
-    }    
-    
-    /*
-    /**********************************************************
-    /* Key deserializer implementations; wrappers
-    /**********************************************************
-     */
-
-    final static class BoolKD extends StdKeyDeserializer
-    {
-        BoolKD() { super(Boolean.class); }
-
-        @Override
-        public Boolean _parse(String key, DeserializationContext ctxt) throws JsonMappingException
-        {
-            if ("true".equals(key)) {
-                return Boolean.TRUE;
-            }
-            if ("false".equals(key)) {
-                return Boolean.FALSE;
-            }
-            throw ctxt.weirdKeyException(_keyClass, key, "value not 'true' or 'false'");
-        }
-    }
-
-    final static class ByteKD extends StdKeyDeserializer
-    {
-        ByteKD() { super(Byte.class); }
-
-        @Override
-		public Byte _parse(String key, DeserializationContext ctxt) throws JsonMappingException
-        {
-            int value = _parseInt(key);
-            if (value < Byte.MIN_VALUE || value > Byte.MAX_VALUE) {
-                throw ctxt.weirdKeyException(_keyClass, key, "overflow, value can not be represented as 8-bit value");
-            }
-            return Byte.valueOf((byte) value);
-        }
-    }
-
-    final static class ShortKD extends StdKeyDeserializer
-    {
-        ShortKD() { super(Integer.class); }
-
-        @Override
-		public Short _parse(String key, DeserializationContext ctxt) throws JsonMappingException
-        {
-            int value = _parseInt(key);
-            if (value < Short.MIN_VALUE || value > Short.MAX_VALUE) {
-                throw ctxt.weirdKeyException(_keyClass, key, "overflow, value can not be represented as 16-bit value");
-            }
-            return Short.valueOf((short) value);
-        }
-    }
-
-    /**
-     * Dealing with Characters is bit trickier: let's assume it must be a String, and that
-     * Unicode numeric value is never used.
-     */
-    final static class CharKD extends StdKeyDeserializer
-    {
-        CharKD() { super(Character.class); }
-
-        @Override
-		public Character _parse(String key, DeserializationContext ctxt) throws JsonMappingException
-        {
-            if (key.length() == 1) {
-                return Character.valueOf(key.charAt(0));
-            }
-            throw ctxt.weirdKeyException(_keyClass, key, "can only convert 1-character Strings");
-        }
-    }
-
-    final static class IntKD extends StdKeyDeserializer
-    {
-        IntKD() { super(Integer.class); }
-
-        @Override
-		public Integer _parse(String key, DeserializationContext ctxt) throws JsonMappingException
-        {
-            return _parseInt(key);
-        }
-    }
-
-    final static class LongKD extends StdKeyDeserializer
-    {
-        LongKD() { super(Long.class); }
-
-        @Override
-        public Long _parse(String key, DeserializationContext ctxt) throws JsonMappingException
-        {
-            return _parseLong(key);
-        }
-    }
-
-    final static class DoubleKD extends StdKeyDeserializer
-    {
-        DoubleKD() { super(Double.class); }
-
-        @Override
-        public Double _parse(String key, DeserializationContext ctxt) throws JsonMappingException
-        {
-            return _parseDouble(key);
-        }
-    }
-
-    final static class FloatKD extends StdKeyDeserializer
-    {
-        FloatKD() { super(Float.class); }
-
-        @Override
-        public Float _parse(String key, DeserializationContext ctxt) throws JsonMappingException
-        {
-            /* 22-Jan-2009, tatu: Bounds/range checks would be tricky
-             *   here, so let's not bother even trying...
-             */
-            return Float.valueOf((float) _parseDouble(key));
-        }
-    }
-
-    /*
-    /**********************************************************
-    /* Key deserializer implementations; other
-    /**********************************************************
-     */
-
-    final static class EnumKD extends StdKeyDeserializer
-    {
-        protected final EnumResolver<?> _resolver;
-
-        protected final AnnotatedMethod _factory;
-
-        protected EnumKD(EnumResolver<?> er, AnnotatedMethod factory) {
-            super(er.getEnumClass());
-            _resolver = er;
-            _factory = factory;
-        }
-
-        @Override
-        public Object _parse(String key, DeserializationContext ctxt) throws JsonMappingException
-        {
-            if (_factory != null) {
-                try {
-                    return _factory.call1(key);
-                } catch (Exception e) {
-                    ClassUtil.unwrapAndThrowAsIAE(e);
-                }
-            }
-            Enum<?> e = _resolver.findEnum(key);
-            if (e == null) {
-                throw ctxt.weirdKeyException(_keyClass, key, "not one of values for Enum class");
-            }
-            return e;
-        }
-    }
-
-    /**
-     * Key deserializer that calls a single-string-arg constructor
-     * to instantiate desired key type.
-     */
-    final static class StringCtorKeyDeserializer extends StdKeyDeserializer
-    {
-        protected final Constructor<?> _ctor;
-
-        public StringCtorKeyDeserializer(Constructor<?> ctor) {
-            super(ctor.getDeclaringClass());
-            _ctor = ctor;
-        }
-
-        @Override
-        public Object _parse(String key, DeserializationContext ctxt) throws Exception
-        {
-            return _ctor.newInstance(key);
-        }
-    }
-
-    /**
-     * Key deserializer that calls a static no-args factory method
-     * to instantiate desired key type.
-     */
-    final static class StringFactoryKeyDeserializer extends StdKeyDeserializer
-    {
-        final Method _factoryMethod;
-
-        public StringFactoryKeyDeserializer(Method fm) {
-            super(fm.getDeclaringClass());
-            _factoryMethod = fm;
-        }
-
-        @Override
-        public Object _parse(String key, DeserializationContext ctxt) throws Exception
-        {
-            return _factoryMethod.invoke(null, key);
-        }
-    }
-
-    // as per [JACKSON-657]
-    final static class DateKD extends StdKeyDeserializer
-    {
-        protected DateKD() {
-            super(java.util.Date.class);
-        }
-
-        @Override
-        public java.util.Date _parse(String key, DeserializationContext ctxt)
-            throws IllegalArgumentException, JsonMappingException
-        {
-            return ctxt.parseDate(key);
-        }
-    }
-        
-    // as per [JACKSON-657]
-    final static class CalendarKD extends StdKeyDeserializer
-    {
-        protected CalendarKD() {
-            super(java.util.Calendar.class);
-        }
-
-        @Override
-        public java.util.Calendar _parse(String key, DeserializationContext ctxt)
-            throws IllegalArgumentException, JsonMappingException
-        {
-            java.util.Date date = ctxt.parseDate(key);
-            return (date == null)  ? null : ctxt.constructCalendar(date);
-        }
-    }
-
-    // as per [JACKSON-726]
-    final static class UuidKD extends StdKeyDeserializer
-    {
-        protected UuidKD() {
-            super(UUID.class);
-        }
-
-        @Override
-        public UUID _parse(String key, DeserializationContext ctxt)
-            throws IllegalArgumentException, JsonMappingException
-        {
-            return UUID.fromString(key);
-        }
-    }
-}
-

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

@@ -1,108 +0,0 @@
-package sh.calaba.org.codehaus.jackson.map.deser.std;
-
-import java.lang.reflect.Constructor;
-import java.lang.reflect.Method;
-import java.util.*;
-
-import sh.calaba.org.codehaus.jackson.map.DeserializationConfig;
-import sh.calaba.org.codehaus.jackson.map.KeyDeserializer;
-import sh.calaba.org.codehaus.jackson.map.introspect.AnnotatedMethod;
-import sh.calaba.org.codehaus.jackson.map.introspect.BasicBeanDescription;
-import sh.calaba.org.codehaus.jackson.map.type.*;
-import sh.calaba.org.codehaus.jackson.map.util.ClassUtil;
-import sh.calaba.org.codehaus.jackson.map.util.EnumResolver;
-import sh.calaba.org.codehaus.jackson.type.JavaType;
-
-/**
- * Helper class used to contain simple/well-known key deserializers.
- * Following kinds of Objects can be handled currently:
- *<ul>
- * <li>Primitive wrappers</li>
- * <li>Enums (usually not needed, since EnumMap doesn't call us)</li>
- * <li>Anything with constructor that takes a single String arg
- *   (if not explicitly @JsonIgnore'd)</li>
- * <li>Anything with 'static T valueOf(String)' factory method
- *   (if not explicitly @JsonIgnore'd)</li>
- *</ul>
- */
-public class StdKeyDeserializers
-{
-    protected final HashMap<JavaType, KeyDeserializer> _keyDeserializers = new HashMap<JavaType, KeyDeserializer>();
-
-    protected StdKeyDeserializers()
-    {
-        add(new StdKeyDeserializer.BoolKD());
-        add(new StdKeyDeserializer.ByteKD());
-        add(new StdKeyDeserializer.CharKD());
-        add(new StdKeyDeserializer.ShortKD());
-        add(new StdKeyDeserializer.IntKD());
-        add(new StdKeyDeserializer.LongKD());
-        add(new StdKeyDeserializer.FloatKD());
-        add(new StdKeyDeserializer.DoubleKD());
-        add(new StdKeyDeserializer.DateKD());
-        add(new StdKeyDeserializer.CalendarKD());
-        add(new StdKeyDeserializer.UuidKD());
-    }
-
-    private void add(StdKeyDeserializer kdeser)
-    {
-        Class<?> keyClass = kdeser.getKeyClass();
-        /* As with other cases involving primitive types, we can use
-         * default TypeFactory ok, even if it's not our first choice:
-         */
-        _keyDeserializers.put(TypeFactory.defaultInstance().uncheckedSimpleType(keyClass), kdeser);
-    }
-
-    public static HashMap<JavaType, KeyDeserializer> constructAll()
-    {
-        return new StdKeyDeserializers()._keyDeserializers;
-    }
-
-    /*
-    /**********************************************************
-    /* Factory methods
-    /**********************************************************
-     */
-
-    public static KeyDeserializer constructStringKeyDeserializer(DeserializationConfig config, JavaType type)
-    {
-        return StdKeyDeserializer.StringKD.forType(type.getClass());
-    }
-
-    public static KeyDeserializer constructEnumKeyDeserializer(EnumResolver<?> enumResolver) {
-        return new StdKeyDeserializer.EnumKD(enumResolver, null);
-    }
-
-    public static KeyDeserializer constructEnumKeyDeserializer(EnumResolver<?> enumResolver,
-            AnnotatedMethod factory) {
-        return new StdKeyDeserializer.EnumKD(enumResolver, factory);
-    }
-
-    public static KeyDeserializer findStringBasedKeyDeserializer(DeserializationConfig config, JavaType type)
-    {
-        /* We don't need full deserialization information, just need to
-         * know creators.
-         */
-    	BasicBeanDescription beanDesc = config.introspect(type);
-        // Ok, so: can we find T(String) constructor?
-        Constructor<?> ctor = beanDesc.findSingleArgConstructor(String.class);
-        if (ctor != null) {
-            if (config.isEnabled(DeserializationConfig.Feature.CAN_OVERRIDE_ACCESS_MODIFIERS)) {
-                ClassUtil.checkAndFixAccess(ctor);
-            }
-            return new StdKeyDeserializer.StringCtorKeyDeserializer(ctor);
-        }
-        /* or if not, "static T valueOf(String)" (or equivalent marked
-         * with @JsonCreator annotation?)
-         */
-        Method m = beanDesc.findFactoryMethod(String.class);
-        if (m != null){
-            if (config.isEnabled(DeserializationConfig.Feature.CAN_OVERRIDE_ACCESS_MODIFIERS)) {
-                ClassUtil.checkAndFixAccess(m);
-            }
-            return new StdKeyDeserializer.StringFactoryKeyDeserializer(m);
-        }
-        // nope, no such luck...
-        return null;
-    }
-}

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

@@ -1,34 +0,0 @@
-package sh.calaba.org.codehaus.jackson.map.deser.std;
-
-import java.io.IOException;
-
-import sh.calaba.org.codehaus.jackson.JsonParser;
-import sh.calaba.org.codehaus.jackson.JsonProcessingException;
-import sh.calaba.org.codehaus.jackson.map.DeserializationContext;
-import sh.calaba.org.codehaus.jackson.map.TypeDeserializer;
-import sh.calaba.org.codehaus.jackson.type.JavaType;
-
-/**
- * Base class for deserializers that handle types that are serialized
- * as JSON scalars (non-structured, i.e. non-Object, non-Array, values).
- * 
- * @since 1.9 (moved from higher-level package)
- */
-public abstract class StdScalarDeserializer<T> extends StdDeserializer<T>
-{
-    protected StdScalarDeserializer(Class<?> vc) {
-        super(vc);
-    }
-
-    protected StdScalarDeserializer(JavaType valueType) {
-        super(valueType);
-    }
-    
-    @Override
-    public Object deserializeWithType(JsonParser jp, DeserializationContext ctxt,
-            TypeDeserializer typeDeserializer)
-        throws IOException, JsonProcessingException
-    {
-        return typeDeserializer.deserializeTypedFromScalar(jp, ctxt);
-    }
-}