calabash-android 0.4.7.pre6 → 0.4.7.pre7

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

@@ -0,0 +1,37 @@
+package sh.calaba.org.codehaus.jackson.map.deser.std;
+
+import sh.calaba.org.codehaus.jackson.map.JsonDeserializer;
+import sh.calaba.org.codehaus.jackson.type.JavaType;
+
+/**
+ * Intermediate base deserializer class that adds more shared accessor
+ * so that other classes can access information about contained (value)
+ * types
+ * 
+ * @since 1.9 (renamed from 'sh.calaba.org.codehaus.jackson.map.deser.ContainerDeserializer')
+ */
+public abstract class ContainerDeserializerBase<T>
+    extends StdDeserializer<T>
+{
+    protected ContainerDeserializerBase(Class<?> selfType)
+    {
+        super(selfType);
+    }
+
+    /*
+    /**********************************************************
+    /* Extended API
+    /**********************************************************
+     */
+
+    /**
+     * Accessor for declared type of contained value elements; either exact
+     * type, or one of its supertypes.
+     */
+    public abstract JavaType getContentType();
+
+    /**
+     * Accesor for deserializer use for deserializing content values.
+     */
+    public abstract JsonDeserializer<Object> getContentDeserializer();
+}

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

@@ -0,0 +1,30 @@
+package sh.calaba.org.codehaus.jackson.map.deser.std;
+
+import java.io.IOException;
+import java.util.Date;
+
+import sh.calaba.org.codehaus.jackson.JsonParser;
+import sh.calaba.org.codehaus.jackson.JsonProcessingException;
+import sh.calaba.org.codehaus.jackson.map.DeserializationContext;
+
+/**
+ * Simple deserializer for handling {@link java.util.Date} values.
+ *<p>
+ * One way to customize Date formats accepted is to override method
+ * {@link DeserializationContext#parseDate} that this basic
+ * deserializer calls.
+ * 
+ * @since 1.9 (moved from higher-level package)
+ */
+public class DateDeserializer
+    extends StdScalarDeserializer<Date>
+{
+    public DateDeserializer() { super(Date.class); }
+    
+    @Override
+    public java.util.Date deserialize(JsonParser jp, DeserializationContext ctxt)
+        throws IOException, JsonProcessingException
+    {
+        return _parseDate(jp, ctxt);
+    }
+}

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

@@ -0,0 +1,139 @@
+package sh.calaba.org.codehaus.jackson.map.deser.std;
+
+import java.io.IOException;
+import java.lang.reflect.Method;
+
+import sh.calaba.org.codehaus.jackson.JsonParser;
+import sh.calaba.org.codehaus.jackson.JsonProcessingException;
+import sh.calaba.org.codehaus.jackson.JsonToken;
+import sh.calaba.org.codehaus.jackson.map.DeserializationConfig;
+import sh.calaba.org.codehaus.jackson.map.DeserializationContext;
+import sh.calaba.org.codehaus.jackson.map.JsonDeserializer;
+import sh.calaba.org.codehaus.jackson.map.annotate.JsonCachable;
+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;
+
+/**
+ * Deserializer class that can deserialize instances of
+ * specified Enum class from Strings and Integers.
+ * 
+ * @since 1.9 (moved from higher-level package)
+ */
+@JsonCachable
+public class EnumDeserializer
+    extends StdScalarDeserializer<Enum<?>>
+{
+    protected final EnumResolver<?> _resolver;
+    
+    public EnumDeserializer(EnumResolver<?> res)
+    {
+        super(Enum.class);
+        _resolver = res;
+    }
+
+    /**
+     * Factory method used when Enum instances are to be deserialized
+     * using a creator (static factory method)
+     * 
+     * @return Deserializer based on given factory method, if type was suitable;
+     *  null if type can not be used
+     * 
+     * @since 1.6
+     */
+    public static JsonDeserializer<?> deserializerForCreator(DeserializationConfig config,
+            Class<?> enumClass, AnnotatedMethod factory)
+    {
+        // note: caller has verified there's just one arg; but we must verify its type
+        if (factory.getParameterType(0) != String.class) {
+            throw new IllegalArgumentException("Parameter #0 type for factory method ("+factory+") not suitable, must be java.lang.String");
+        }
+        if (config.isEnabled(DeserializationConfig.Feature.CAN_OVERRIDE_ACCESS_MODIFIERS)) {
+            ClassUtil.checkAndFixAccess(factory.getMember());
+        }
+        return new FactoryBasedDeserializer(enumClass, factory);
+    }
+    
+    /*
+    /**********************************************************
+    /* Default JsonDeserializer implementation
+    /**********************************************************
+     */
+
+    @Override
+    public Enum<?> deserialize(JsonParser jp, DeserializationContext ctxt)
+        throws IOException, JsonProcessingException
+    {
+        JsonToken curr = jp.getCurrentToken();
+        
+        // Usually should just get string value; but in some cases FIELD_NAME (enum as key)
+        if (curr == JsonToken.VALUE_STRING || curr == JsonToken.FIELD_NAME) {
+            String name = jp.getText();
+            Enum<?> result = _resolver.findEnum(name);
+            if (result == null) {
+                throw ctxt.weirdStringException(_resolver.getEnumClass(), "value not one of declared Enum instance names");
+            }
+            return result;
+        }
+        // But let's consider int acceptable as well (if within ordinal range)
+        if (curr == JsonToken.VALUE_NUMBER_INT) {
+            /* ... unless told not to do that. :-)
+             * (as per [JACKSON-412]
+             */
+            if (ctxt.isEnabled(DeserializationConfig.Feature.FAIL_ON_NUMBERS_FOR_ENUMS)) {
+                throw ctxt.mappingException("Not allowed to deserialize Enum value out of JSON number (disable DeserializationConfig.Feature.FAIL_ON_NUMBERS_FOR_ENUMS to allow)");
+            }
+            
+            int index = jp.getIntValue();
+            Enum<?> result = _resolver.getEnum(index);
+            if (result == null) {
+                throw ctxt.weirdNumberException(_resolver.getEnumClass(), "index value outside legal index range [0.."+_resolver.lastValidIndex()+"]");
+            }
+            return result;
+        }
+        throw ctxt.mappingException(_resolver.getEnumClass());
+    }
+
+    /*
+    /**********************************************************
+    /* Default JsonDeserializer implementation
+    /**********************************************************
+     */
+
+    /**
+     * Deserializer that uses a single-String static factory method
+     * for locating Enum values by String id.
+     */
+    protected static class FactoryBasedDeserializer
+        extends StdScalarDeserializer<Object>
+    {
+        protected final Class<?> _enumClass;
+        protected final Method _factory;
+        
+        public FactoryBasedDeserializer(Class<?> cls, AnnotatedMethod f)
+        {
+            super(Enum.class);
+            _enumClass = cls;
+            _factory = f.getAnnotated();
+        }
+
+        @Override
+        public Object deserialize(JsonParser jp, DeserializationContext ctxt)
+            throws IOException, JsonProcessingException
+        {
+            JsonToken curr = jp.getCurrentToken();
+            
+            // Usually should just get string value:
+            if (curr != JsonToken.VALUE_STRING && curr != JsonToken.FIELD_NAME) {
+                throw ctxt.mappingException(_enumClass);
+            }
+            String value = jp.getText();
+            try {
+                return _factory.invoke(_enumClass, value);
+            } catch (Exception e) {
+                ClassUtil.unwrapAndThrowAsIAE(e);
+            }
+            return null;
+        }
+    }
+}

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

@@ -0,0 +1,90 @@
+package sh.calaba.org.codehaus.jackson.map.deser.std;
+
+import java.io.IOException;
+import java.util.*;
+
+import sh.calaba.org.codehaus.jackson.JsonParser;
+import sh.calaba.org.codehaus.jackson.JsonProcessingException;
+import sh.calaba.org.codehaus.jackson.JsonToken;
+import sh.calaba.org.codehaus.jackson.map.DeserializationContext;
+import sh.calaba.org.codehaus.jackson.map.JsonDeserializer;
+import sh.calaba.org.codehaus.jackson.map.TypeDeserializer;
+import sh.calaba.org.codehaus.jackson.map.deser.std.StdDeserializer;
+import sh.calaba.org.codehaus.jackson.map.util.EnumResolver;
+
+/**
+ * 
+ * <p>
+ * Note: casting within this class is all messed up -- just could not figure out a way
+ * to properly deal with recursive definition of "EnumMap<K extends Enum<K>, V>
+ * 
+ * @author tsaloranta
+ * 
+ * @since 1.9 (renamed from 'sh.calaba.org.codehaus.jackson.map.deser.EnumMapDeserializer')
+ */
+@SuppressWarnings({ "unchecked", "rawtypes" }) 
+public class EnumMapDeserializer
+    extends StdDeserializer<EnumMap<?,?>>
+{
+    protected final Class<?> _enumClass;
+
+    protected final JsonDeserializer<Enum<?>> _keyDeserializer;
+
+    protected final JsonDeserializer<Object> _valueDeserializer;
+
+    @Deprecated
+    public EnumMapDeserializer(EnumResolver<?> enumRes, JsonDeserializer<Object> valueDeser)
+    {
+        this(enumRes.getEnumClass(), new EnumDeserializer(enumRes), valueDeser);
+    }
+
+    public EnumMapDeserializer(Class<?> enumClass, JsonDeserializer<?> keyDeserializer,
+            JsonDeserializer<Object> valueDeser)
+    {
+        super(EnumMap.class);
+        _enumClass = enumClass;
+        _keyDeserializer = (JsonDeserializer<Enum<?>>) keyDeserializer;
+        _valueDeserializer = valueDeser;
+    }
+    
+    @Override
+    public EnumMap<?,?> deserialize(JsonParser jp, DeserializationContext ctxt)
+        throws IOException, JsonProcessingException
+    {
+        // Ok: must point to START_OBJECT
+        if (jp.getCurrentToken() != JsonToken.START_OBJECT) {
+            throw ctxt.mappingException(EnumMap.class);
+        }
+        EnumMap result = constructMap();
+
+        while ((jp.nextToken()) != JsonToken.END_OBJECT) {
+            Enum<?> key = _keyDeserializer.deserialize(jp, ctxt);
+            if (key == null) {
+                throw ctxt.weirdStringException(_enumClass, "value not one of declared Enum instance names");
+            }
+            // And then the value...
+            JsonToken t = jp.nextToken();
+            /* note: MUST check for nulls separately: deserializers will
+             * not handle them (and maybe fail or return bogus data)
+             */
+            Object value = (t == JsonToken.VALUE_NULL) ?
+                null :  _valueDeserializer.deserialize(jp, ctxt);
+            result.put(key, value);
+        }
+        return result;
+    }
+
+    @Override
+    public Object deserializeWithType(JsonParser jp, DeserializationContext ctxt,
+            TypeDeserializer typeDeserializer)
+        throws IOException, JsonProcessingException
+    {
+        // In future could check current token... for now this should be enough:
+        return typeDeserializer.deserializeTypedFromObject(jp, ctxt);
+    }
+    
+    private EnumMap<?,?> constructMap()
+    {
+    	return new EnumMap(_enumClass);
+    }
+}

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

@@ -0,0 +1,89 @@
+package sh.calaba.org.codehaus.jackson.map.deser.std;
+
+import java.io.IOException;
+import java.util.*;
+
+import sh.calaba.org.codehaus.jackson.JsonParser;
+import sh.calaba.org.codehaus.jackson.JsonProcessingException;
+import sh.calaba.org.codehaus.jackson.JsonToken;
+import sh.calaba.org.codehaus.jackson.map.DeserializationContext;
+import sh.calaba.org.codehaus.jackson.map.JsonDeserializer;
+import sh.calaba.org.codehaus.jackson.map.TypeDeserializer;
+import sh.calaba.org.codehaus.jackson.map.util.EnumResolver;
+
+/**
+ * 
+ * <p>
+ * Note: casting within this class is all messed up -- just could not figure out a way
+ * to properly deal with recursive definition of "EnumSet<K extends Enum<K>, V>
+ * 
+ * @author tsaloranta
+ * 
+ * @since 1.9 (moved from higher-level package)
+ */
+@SuppressWarnings("rawtypes")
+public class EnumSetDeserializer
+    extends StdDeserializer<EnumSet<?>>
+{
+    protected final Class<Enum> _enumClass;
+
+    protected final JsonDeserializer<Enum<?>> _enumDeserializer;
+
+    @SuppressWarnings("unchecked" )
+    public EnumSetDeserializer(EnumResolver enumRes)
+    {
+        // fugly, but what we can we do...
+        this((Class<Enum>) ((Class<?>) enumRes.getEnumClass()),
+                new EnumDeserializer(enumRes));
+    }
+
+    @SuppressWarnings("unchecked" )
+    public EnumSetDeserializer(Class<?> enumClass, JsonDeserializer<?> deser)
+    {
+        super(EnumSet.class);
+        _enumClass = (Class<Enum>) enumClass;
+        _enumDeserializer = (JsonDeserializer<Enum<?>>) deser;
+    }
+    
+    @SuppressWarnings("unchecked") 
+    @Override
+    public EnumSet<?> deserialize(JsonParser jp, DeserializationContext ctxt)
+        throws IOException, JsonProcessingException
+    {
+        // Ok: must point to START_ARRAY (or equivalent)
+        if (!jp.isExpectedStartArrayToken()) {
+            throw ctxt.mappingException(EnumSet.class);
+        }
+        EnumSet result = constructSet();
+        JsonToken t;
+
+        while ((t = jp.nextToken()) != JsonToken.END_ARRAY) {
+            /* What to do with nulls? Fail or ignore? Fail, for now
+             * (note: would fail if we passed it to EnumDeserializer, too,
+             * but in general nulls should never be passed to non-container
+             * deserializers)
+             */
+            if (t == JsonToken.VALUE_NULL) {
+                throw ctxt.mappingException(_enumClass);
+            }
+            Enum<?> value = _enumDeserializer.deserialize(jp, ctxt);
+            result.add(value);
+        }
+        return result;
+    }
+
+    @Override
+    public Object deserializeWithType(JsonParser jp, DeserializationContext ctxt,
+            TypeDeserializer typeDeserializer)
+        throws IOException, JsonProcessingException
+    {
+        return typeDeserializer.deserializeTypedFromArray(jp, ctxt);
+    }
+    
+    @SuppressWarnings("unchecked") 
+    private EnumSet constructSet()
+    {
+    	// superbly ugly... but apparently necessary
+    	return EnumSet.noneOf(_enumClass);
+    }
+}

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

@@ -0,0 +1,265 @@
+package sh.calaba.org.codehaus.jackson.map.deser.std;
+
+import java.io.*;
+import java.net.InetAddress;
+import java.net.URI;
+import java.net.URL;
+import java.nio.charset.Charset;
+import java.util.*;
+import java.util.regex.Pattern;
+
+import sh.calaba.org.codehaus.jackson.JsonParser;
+import sh.calaba.org.codehaus.jackson.JsonProcessingException;
+import sh.calaba.org.codehaus.jackson.JsonToken;
+import sh.calaba.org.codehaus.jackson.map.DeserializationContext;
+
+/**
+ * Base class for simple deserializer which only accept JSON String
+ * values as the source.
+ * 
+ * @since 1.9 (moved from higher-level package)
+ */
+public abstract class FromStringDeserializer<T>
+    extends StdScalarDeserializer<T>
+{
+    protected FromStringDeserializer(Class<?> vc) {
+        super(vc);
+    }
+
+    public static Iterable<FromStringDeserializer<?>>all()
+    {
+        ArrayList<FromStringDeserializer<?>> all = new ArrayList<FromStringDeserializer<?>>();
+
+        all.add(new UUIDDeserializer());
+        all.add(new URLDeserializer());
+        all.add(new URIDeserializer());
+        all.add(new CurrencyDeserializer());
+        all.add(new PatternDeserializer());
+        // since 1.7:
+        all.add(new LocaleDeserializer());
+        // 1.8:
+        all.add(new InetAddressDeserializer());
+        all.add(new TimeZoneDeserializer());
+        // 1.9
+        all.add(new CharsetDeserializer());
+
+        return all;
+    }
+    
+    @SuppressWarnings("unchecked")
+    @Override
+    public final T deserialize(JsonParser jp, DeserializationContext ctxt)
+        throws IOException, JsonProcessingException
+    {
+        if (jp.getCurrentToken() == JsonToken.VALUE_STRING) {
+            String text = jp.getText().trim();
+            // 15-Oct-2010, tatu: Empty String usually means null, so
+            if (text.length() == 0) {
+                return null;
+            }
+            try {
+                T result = _deserialize(text, ctxt);
+                if (result != null) {
+                    return result;
+                }
+            } catch (IllegalArgumentException iae) {
+                // nothing to do here, yet? We'll fail anyway
+            }
+            throw ctxt.weirdStringException(_valueClass, "not a valid textual representation");
+        }
+        if (jp.getCurrentToken() == JsonToken.VALUE_EMBEDDED_OBJECT) {
+            // Trivial cases; null to null, instance of type itself returned as is
+            Object ob = jp.getEmbeddedObject();
+            if (ob == null) {
+                return null;
+            }
+            if (_valueClass.isAssignableFrom(ob.getClass())) {
+                return (T) ob;
+            }
+            return _deserializeEmbedded(ob, ctxt);
+        }
+        throw ctxt.mappingException(_valueClass);
+    }
+        
+    protected abstract T _deserialize(String value, DeserializationContext ctxt)
+        throws IOException, JsonProcessingException;
+
+    protected T _deserializeEmbedded(Object ob, DeserializationContext ctxt)
+        throws IOException, JsonProcessingException
+    {
+        // default impl: error out
+        throw ctxt.mappingException("Don't know how to convert embedded Object of type "
+                +ob.getClass().getName()+" into "+_valueClass.getName());
+    }
+    
+    /*
+    /**********************************************************
+    /* Then concrete implementations
+    /**********************************************************
+     */
+
+    public static class UUIDDeserializer
+        extends FromStringDeserializer<UUID>
+    {
+        public UUIDDeserializer() { super(UUID.class); }
+
+        @Override
+        protected UUID _deserialize(String value, DeserializationContext ctxt)
+            throws IOException, JsonProcessingException
+        {
+            return UUID.fromString(value);
+        }
+
+        @Override
+        protected UUID _deserializeEmbedded(Object ob, DeserializationContext ctxt)
+            throws IOException, JsonProcessingException
+        {
+            if (ob instanceof byte[]) {
+                byte[] bytes = (byte[]) ob;
+                if (bytes.length != 16) {
+                    ctxt.mappingException("Can only construct UUIDs from 16 byte arrays; got "+bytes.length+" bytes");
+                }
+                // clumsy, but should work for now...
+                DataInputStream in = new DataInputStream(new ByteArrayInputStream(bytes));
+                long l1 = in.readLong();
+                long l2 = in.readLong();
+                return new UUID(l1, l2);
+            }
+            super._deserializeEmbedded(ob, ctxt);
+            return null; // never gets here
+        }
+    }
+
+    public static class URLDeserializer
+        extends FromStringDeserializer<URL>
+    {
+        public URLDeserializer() { super(URL.class); }
+        
+        @Override
+        protected URL _deserialize(String value, DeserializationContext ctxt)
+            throws IOException
+        {
+            return new URL(value);
+        }
+    }
+
+    public static class URIDeserializer
+        extends FromStringDeserializer<URI>
+    {
+        public URIDeserializer() { super(URI.class); }
+
+        @Override
+        protected URI _deserialize(String value, DeserializationContext ctxt)
+            throws IllegalArgumentException
+        {
+            return URI.create(value);
+        }
+    }
+
+    public static class CurrencyDeserializer
+        extends FromStringDeserializer<Currency>
+    {
+        public CurrencyDeserializer() { super(Currency.class); }
+        
+        @Override
+        protected Currency _deserialize(String value, DeserializationContext ctxt)
+            throws IllegalArgumentException
+        {
+            // will throw IAE if unknown:
+            return Currency.getInstance(value);
+        }
+    }
+
+    public static class PatternDeserializer
+        extends FromStringDeserializer<Pattern>
+    {
+        public PatternDeserializer() { super(Pattern.class); }
+        
+        @Override
+        protected Pattern _deserialize(String value, DeserializationContext ctxt)
+            throws IllegalArgumentException
+        {
+            // will throw IAE (or its subclass) if malformed
+            return Pattern.compile(value);
+        }
+    }
+
+    /**
+     * Kept protected as it's not meant to be extensible at this point
+     * 
+     * @since 1.7
+     */
+    protected static class LocaleDeserializer
+        extends FromStringDeserializer<Locale>
+    {
+        public LocaleDeserializer() { super(Locale.class); }
+        
+        @Override
+        protected Locale _deserialize(String value, DeserializationContext ctxt)
+            throws IOException
+        {
+            int ix = value.indexOf('_');
+            if (ix < 0) { // single argument
+                return new Locale(value);
+            }
+            String first = value.substring(0, ix);
+            value = value.substring(ix+1);
+            ix = value.indexOf('_');
+            if (ix < 0) { // two pieces
+                return new Locale(first, value);
+            }
+            String second = value.substring(0, ix);
+            return new Locale(first, second, value.substring(ix+1));
+        }
+    }
+
+    /**
+     * As per [JACKSON-484], also need special handling for InetAddress...
+     * 
+     * @since 1.7.4
+     */
+    protected static class InetAddressDeserializer
+        extends FromStringDeserializer<InetAddress>
+    {
+        public InetAddressDeserializer() { super(InetAddress.class); }
+
+        @Override
+        protected InetAddress _deserialize(String value, DeserializationContext ctxt)
+            throws IOException
+        {
+            return InetAddress.getByName(value);
+        }
+    }
+
+    // [JACKSON-789] (since 1.9.5)
+    protected static class CharsetDeserializer
+        extends FromStringDeserializer<Charset>
+    {
+        public CharsetDeserializer() { super(Charset.class); }
+    
+        @Override
+	    protected Charset _deserialize(String value, DeserializationContext ctxt)
+            throws IOException
+	    {
+		return Charset.forName(value);
+	    }
+    }
+
+    /**
+     * As per [JACKSON-522], also need special handling for InetAddress...
+     * 
+     * @since 1.7.4
+     */
+    protected static class TimeZoneDeserializer
+        extends FromStringDeserializer<TimeZone>
+    {
+        public TimeZoneDeserializer() { super(TimeZone.class); }
+
+        @Override
+        protected TimeZone _deserialize(String value, DeserializationContext ctxt)
+            throws IOException
+        {
+            return TimeZone.getTimeZone(value);
+        }
+    }
+}