calabash-android 0.4.7.pre6 → 0.4.7.pre7

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

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

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

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