calabash-android 0.5.2 → 0.5.3

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

@@ -1,84 +0,0 @@
-package sh.calaba.org.codehaus.jackson.map.ser.std;
-
-import java.io.IOException;
-import java.lang.reflect.Type;
-
-import sh.calaba.org.codehaus.jackson.*;
-import sh.calaba.org.codehaus.jackson.io.SerializedString;
-import sh.calaba.org.codehaus.jackson.map.*;
-import sh.calaba.org.codehaus.jackson.map.annotate.JacksonStdImpl;
-import sh.calaba.org.codehaus.jackson.map.introspect.BasicBeanDescription;
-import sh.calaba.org.codehaus.jackson.map.util.EnumValues;
-import sh.calaba.org.codehaus.jackson.node.ArrayNode;
-import sh.calaba.org.codehaus.jackson.node.ObjectNode;
-import sh.calaba.org.codehaus.jackson.type.JavaType;
-
-/**
- * Standard serializer used for {@link java.lang.Enum} types.
- *<p>
- * Based on {@link ScalarSerializerBase} since the JSON value is
- * scalar (String).
- * 
- * @author tatu
- */
-@JacksonStdImpl
-public class EnumSerializer
-    extends ScalarSerializerBase<Enum<?>>
-{
-    /**
-     * This map contains pre-resolved values (since there are ways
-     * to customize actual String constants to use) to use as
-     * serializations.
-     */
-    protected final EnumValues _values;
-
-    public EnumSerializer(EnumValues v) {
-        super(Enum.class, false);
-        _values = v;
-    }
-
-    public static EnumSerializer construct(Class<Enum<?>> enumClass, SerializationConfig config,
-            BasicBeanDescription beanDesc)
-    {
-        // [JACKSON-212]: If toString() is to be used instead, leave EnumValues null
-        AnnotationIntrospector intr = config.getAnnotationIntrospector();
-        EnumValues v = config.isEnabled(SerializationConfig.Feature.WRITE_ENUMS_USING_TO_STRING)
-            ? EnumValues.constructFromToString(enumClass, intr) : EnumValues.constructFromName(enumClass, intr);
-        return new EnumSerializer(v);
-    }
-    
-    @Override
-    public final void serialize(Enum<?> en, JsonGenerator jgen, SerializerProvider provider)
-        throws IOException, JsonGenerationException
-    {
-        // [JACKSON-684]: serialize as index?
-        if (provider.isEnabled(SerializationConfig.Feature.WRITE_ENUMS_USING_INDEX)) {
-            jgen.writeNumber(en.ordinal());
-            return;
-        }
-        jgen.writeString(_values.serializedValueFor(en));
-    }
-    
-    @Override
-    public JsonNode getSchema(SerializerProvider provider, Type typeHint)
-    {
-        // [JACKSON-684]: serialize as index?
-        if (provider.isEnabled(SerializationConfig.Feature.WRITE_ENUMS_USING_INDEX)) {
-            return createSchemaNode("integer", true);
-        }
-        ObjectNode objectNode = createSchemaNode("string", true);
-        if (typeHint != null) {
-            JavaType type = provider.constructType(typeHint);
-            if (type.isEnumType()) {
-                ArrayNode enumNode = objectNode.putArray("enum");
-                for (SerializedString value : _values.values()) {
-                    enumNode.add(value.getValue());
-                }
-            }
-        }
-        return objectNode;
-    }
-
-    public EnumValues getEnumValues() { return _values; }
-}
-

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

@@ -1,47 +0,0 @@
-package sh.calaba.org.codehaus.jackson.map.ser.std;
-
-import java.io.IOException;
-import java.util.EnumSet;
-
-import sh.calaba.org.codehaus.jackson.JsonGenerationException;
-import sh.calaba.org.codehaus.jackson.JsonGenerator;
-import sh.calaba.org.codehaus.jackson.map.BeanProperty;
-import sh.calaba.org.codehaus.jackson.map.JsonSerializer;
-import sh.calaba.org.codehaus.jackson.map.SerializerProvider;
-import sh.calaba.org.codehaus.jackson.map.TypeSerializer;
-import sh.calaba.org.codehaus.jackson.type.JavaType;
-
-public class EnumSetSerializer
-    extends AsArraySerializerBase<EnumSet<? extends Enum<?>>>
-{
-    public EnumSetSerializer(JavaType elemType, BeanProperty property)
-    {
-        super(EnumSet.class, elemType, true, null, property, null);
-    }
-
-    @Override
-    public ContainerSerializerBase<?> _withValueTypeSerializer(TypeSerializer vts) {
-        // no typing for enums (always "hard" type)
-        return this;
-    }
-    
-    @Override
-    public void serializeContents(EnumSet<? extends Enum<?>> value, JsonGenerator jgen, SerializerProvider provider)
-        throws IOException, JsonGenerationException
-    {
-        JsonSerializer<Object> enumSer = _elementSerializer;
-        /* Need to dynamically find instance serializer; unfortunately
-         * that seems to be the only way to figure out type (no accessors
-         * to the enum class that set knows)
-         */
-        for (Enum<?> en : value) {
-            if (enumSer == null) {
-                /* 12-Jan-2010, tatu: Since enums can not be polymorphic, let's
-                 *   not bother with typed serializer variant here
-                 */
-                enumSer = provider.findValueSerializer(en.getDeclaringClass(), _property);
-            }
-            enumSer.serialize(en, jgen, provider);
-        }
-    }
-}

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

@@ -1,116 +0,0 @@
-package sh.calaba.org.codehaus.jackson.map.ser.std;
-
-import java.io.IOException;
-import java.util.*;
-
-import sh.calaba.org.codehaus.jackson.JsonGenerationException;
-import sh.calaba.org.codehaus.jackson.JsonGenerator;
-import sh.calaba.org.codehaus.jackson.JsonNode;
-import sh.calaba.org.codehaus.jackson.map.BeanProperty;
-import sh.calaba.org.codehaus.jackson.map.JsonMappingException;
-import sh.calaba.org.codehaus.jackson.map.JsonSerializer;
-import sh.calaba.org.codehaus.jackson.map.ResolvableSerializer;
-import sh.calaba.org.codehaus.jackson.map.SerializerProvider;
-import sh.calaba.org.codehaus.jackson.map.TypeSerializer;
-import sh.calaba.org.codehaus.jackson.map.annotate.JacksonStdImpl;
-
-/**
- * Efficient implement for serializing {@link List}s that contains Strings and are random-accessible.
- * The only complexity is due to possibility that serializer for {@link String}
- * may be overridde; because of this, logic is needed to ensure that the default
- * serializer is in use to use fastest mode, or if not, to defer to custom
- * String serializer.
- * 
- * @since 1.7
- */
-@JacksonStdImpl
-public final class IndexedStringListSerializer
-    extends StaticListSerializerBase<List<String>>
-    implements ResolvableSerializer
-{
-    protected JsonSerializer<String> _serializer;
-    
-    public IndexedStringListSerializer(BeanProperty property) {
-        super(List.class, property);
-    }
-
-    @Override protected JsonNode contentSchema() {
-        return createSchemaNode("string", true);
-    }
-
-    @SuppressWarnings("unchecked")
-    @Override
-    public void resolve(SerializerProvider provider) throws JsonMappingException
-    {
-        JsonSerializer<?> ser = provider.findValueSerializer(String.class, _property);
-        if (!isDefaultSerializer(ser)) {
-            _serializer = (JsonSerializer<String>) ser;
-        }
-    }
-
-    @Override
-    public void serialize(List<String> value, JsonGenerator jgen, SerializerProvider provider)
-        throws IOException, JsonGenerationException
-    {
-        jgen.writeStartArray();
-        if (_serializer == null) {
-            serializeContents(value, jgen, provider);
-        } else {
-            serializeUsingCustom(value, jgen, provider);
-        }
-        jgen.writeEndArray();
-    }
-    
-    @Override
-    public void serializeWithType(List<String> value, JsonGenerator jgen, SerializerProvider provider,
-            TypeSerializer typeSer)
-        throws IOException, JsonGenerationException
-    {
-        typeSer.writeTypePrefixForArray(value, jgen);
-        if (_serializer == null) {
-            serializeContents(value, jgen, provider);
-        } else {
-            serializeUsingCustom(value, jgen, provider);
-        }
-        typeSer.writeTypeSuffixForArray(value, jgen);
-    }
-    
-    private final void serializeContents(List<String> value, JsonGenerator jgen, SerializerProvider provider)
-        throws IOException, JsonGenerationException
-    {
-        int i = 0;
-        try {
-            final int len = value.size();
-            for (; i < len; ++i) {
-                String str = value.get(i);
-                if (str == null) {
-                    provider.defaultSerializeNull(jgen);
-                } else {
-                    jgen.writeString(str);
-                }
-            }
-        } catch (Exception e) {
-            wrapAndThrow(provider, e, value, i);
-        }
-    }
-
-    private final void serializeUsingCustom(List<String> value, JsonGenerator jgen, SerializerProvider provider)
-        throws IOException, JsonGenerationException
-    {
-        int i = 0;
-        try {
-            final int len = value.size();
-            final JsonSerializer<String> ser = _serializer;
-            for (i = 0; i < len; ++i) {
-                String str = value.get(i);
-                if (str == null) {
-                    provider.defaultSerializeNull(jgen);
-                } else {
-                    ser.serialize(str, jgen, provider);
-                }
-            }
-        } catch (Exception e) {
-            wrapAndThrow(provider, e, value, i);
-        }
-    }
-}

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

@@ -1,51 +0,0 @@
-package sh.calaba.org.codehaus.jackson.map.ser.std;
-
-import java.io.IOException;
-import java.net.InetAddress;
-
-import sh.calaba.org.codehaus.jackson.JsonGenerationException;
-import sh.calaba.org.codehaus.jackson.JsonGenerator;
-import sh.calaba.org.codehaus.jackson.map.SerializerProvider;
-import sh.calaba.org.codehaus.jackson.map.TypeSerializer;
-
-/**
- * Simple serializer for {@link java.net.InetAddress}. Main complexity is
- * with registration, since same serializer is to be used for sub-classes.
- *
- * @since 1.8
- */
-public class InetAddressSerializer
-    extends ScalarSerializerBase<InetAddress>
-{
-    public final static InetAddressSerializer instance = new InetAddressSerializer();
-    
-    public InetAddressSerializer() { super(InetAddress.class); }
-
-    @Override
-    public void serialize(InetAddress value, JsonGenerator jgen, SerializerProvider provider)
-        throws IOException, JsonGenerationException
-    {
-        // Ok: get textual description; choose "more specific" part
-        String str = value.toString().trim();
-        int ix = str.indexOf('/');
-        if (ix >= 0) {
-            if (ix == 0) { // missing host name; use address
-                str = str.substring(1);
-            } else { // otherwise use name
-                str = str.substring(0, ix);
-            }
-        }
-        jgen.writeString(str);
-    }
-
-    @Override
-    public void serializeWithType(InetAddress value, JsonGenerator jgen, SerializerProvider provider,
-            TypeSerializer typeSer)
-        throws IOException, JsonGenerationException
-    {
-        // Better ensure we don't use specific sub-classes...
-        typeSer.writeTypePrefixForScalar(value, jgen, InetAddress.class);
-        serialize(value, jgen, provider);
-        typeSer.writeTypeSuffixForScalar(value, jgen);
-    }
-}

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

@@ -1,63 +0,0 @@
-package sh.calaba.org.codehaus.jackson.map.ser.std;
-
-import java.io.IOException;
-import java.util.Iterator;
-
-import sh.calaba.org.codehaus.jackson.JsonGenerationException;
-import sh.calaba.org.codehaus.jackson.JsonGenerator;
-import sh.calaba.org.codehaus.jackson.map.BeanProperty;
-import sh.calaba.org.codehaus.jackson.map.JsonSerializer;
-import sh.calaba.org.codehaus.jackson.map.SerializerProvider;
-import sh.calaba.org.codehaus.jackson.map.TypeSerializer;
-import sh.calaba.org.codehaus.jackson.map.annotate.JacksonStdImpl;
-import sh.calaba.org.codehaus.jackson.type.JavaType;
-
-@JacksonStdImpl
-public class IterableSerializer
-    extends AsArraySerializerBase<Iterable<?>>
-{
-    public IterableSerializer(JavaType elemType, boolean staticTyping, TypeSerializer vts, BeanProperty property)
-    {
-        super(Iterable.class, elemType, staticTyping, vts, property, null);
-    }
-
-    @Override
-    public ContainerSerializerBase<?> _withValueTypeSerializer(TypeSerializer vts) {
-        return new IterableSerializer(_elementType, _staticTyping, vts, _property);
-    }
-    
-    @Override
-    public void serializeContents(Iterable<?> value, JsonGenerator jgen, SerializerProvider provider)
-        throws IOException, JsonGenerationException
-    {
-        Iterator<?> it = value.iterator();
-        if (it.hasNext()) {
-            final TypeSerializer typeSer = _valueTypeSerializer;
-            JsonSerializer<Object> prevSerializer = null;
-            Class<?> prevClass = null;
-            
-            do {
-                Object elem = it.next();
-                if (elem == null) {
-                    provider.defaultSerializeNull(jgen);
-                } else {
-                    // Minor optimization to avoid most lookups:
-                    Class<?> cc = elem.getClass();
-                    JsonSerializer<Object> currSerializer;
-                    if (cc == prevClass) {
-                        currSerializer = prevSerializer;
-                    } else {
-                        currSerializer = provider.findValueSerializer(cc, _property);
-                        prevSerializer = currSerializer;
-                        prevClass = cc;
-                    }
-                    if (typeSer == null) {
-                        currSerializer.serialize(elem, jgen, provider);
-                    } else {
-                        currSerializer.serializeWithType(elem, jgen, provider, typeSer);
-                    }
-                }
-            } while (it.hasNext());
-        }
-    }
-}

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

@@ -1,233 +0,0 @@
-package sh.calaba.org.codehaus.jackson.map.ser.std;
-
-import java.io.IOException;
-import java.lang.reflect.InvocationTargetException;
-import java.lang.reflect.Method;
-import java.lang.reflect.Modifier;
-import java.lang.reflect.Type;
-
-import sh.calaba.org.codehaus.jackson.JsonGenerationException;
-import sh.calaba.org.codehaus.jackson.JsonGenerator;
-import sh.calaba.org.codehaus.jackson.JsonNode;
-import sh.calaba.org.codehaus.jackson.JsonProcessingException;
-import sh.calaba.org.codehaus.jackson.map.*;
-import sh.calaba.org.codehaus.jackson.map.annotate.JacksonStdImpl;
-import sh.calaba.org.codehaus.jackson.map.ser.BeanSerializer;
-import sh.calaba.org.codehaus.jackson.schema.JsonSchema;
-import sh.calaba.org.codehaus.jackson.schema.SchemaAware;
-import sh.calaba.org.codehaus.jackson.type.JavaType;
-
-/**
- * Serializer class that can serialize Object that have a
- * {@link sh.calaba.org.codehaus.jackson.annotate.JsonValue} annotation to
- * indicate that serialization should be done by calling the method
- * annotated, and serializing result it returns.
- * <p/>
- * Implementation note: we will post-process resulting serializer
- * (much like what is done with {@link BeanSerializer})
- * to figure out actual serializers for final types. This must be
- * done from {@link #resolve} method, and NOT from constructor;
- * otherwise we could end up with an infinite loop.
- */
-@JacksonStdImpl
-public class JsonValueSerializer
-    extends SerializerBase<Object>
-    implements ResolvableSerializer, SchemaAware
-{
-    protected final Method _accessorMethod;
-
-    protected JsonSerializer<Object> _valueSerializer;
-
-    protected final BeanProperty _property;
-    
-    /**
-     * This is a flag that is set in rare (?) cases where this serializer
-     * is used for "natural" types (boolean, int, String, double); and where
-     * we actually must force type information wrapping, even though
-     * one would not normally be added.
-     * 
-     * @since 1.7
-     */
-    protected boolean _forceTypeInformation;
-    
-    /**
-     * @param ser Explicit serializer to use, if caller knows it (which
-     *            occurs if and only if the "value method" was annotated with
-     *            {@link sh.calaba.org.codehaus.jackson.map.annotate.JsonSerialize#using}), otherwise
-     *            null
-     */
-    public JsonValueSerializer(Method valueMethod, JsonSerializer<Object> ser, BeanProperty property)
-    {
-        super(Object.class);
-        _accessorMethod = valueMethod;
-        _valueSerializer = ser;
-        _property = property;
-    }
-
-    @Override
-    public void serialize(Object bean, JsonGenerator jgen, SerializerProvider prov)
-        throws IOException, JsonGenerationException
-    {
-        try {
-            Object value = _accessorMethod.invoke(bean);
-
-            if (value == null) {
-                prov.defaultSerializeNull(jgen);
-                return;
-            }
-            JsonSerializer<Object> ser = _valueSerializer;
-            if (ser == null) {
-                Class<?> c = value.getClass();
-                /* 10-Mar-2010, tatu: Ideally we would actually separate out type
-                 *   serializer from value serializer; but, alas, there's no access
-                 *   to serializer factory at this point... 
-                 */
-                // let's cache it, may be needed soon again
-                ser = prov.findTypedValueSerializer(c, true, _property);
-            }
-            ser.serialize(value, jgen, prov);
-        } catch (IOException ioe) {
-            throw ioe;
-        } catch (Exception e) {
-            Throwable t = e;
-            // Need to unwrap this specific type, to see infinite recursion...
-            while (t instanceof InvocationTargetException && t.getCause() != null) {
-                t = t.getCause();
-            }
-            // Errors shouldn't be wrapped (and often can't, as well)
-            if (t instanceof Error) {
-                throw (Error) t;
-            }
-            // let's try to indicate the path best we can...
-            throw JsonMappingException.wrapWithPath(t, bean, _accessorMethod.getName() + "()");
-        }
-    }
-
-    @Override
-    public void serializeWithType(Object bean, JsonGenerator jgen, SerializerProvider provider,
-            TypeSerializer typeSer)
-        throws IOException, JsonProcessingException
-    {
-        // Regardless of other parts, first need to find value to serialize:
-        Object value = null;
-        try {
-            value = _accessorMethod.invoke(bean);
-
-            // and if we got null, can also just write it directly
-            if (value == null) {
-                provider.defaultSerializeNull(jgen);
-                return;
-            }
-            JsonSerializer<Object> ser = _valueSerializer;
-            if (ser != null) { // already got a serializer? fabulous, that be easy...
-                /* 09-Dec-2010, tatu: To work around natural type's refusal to add type info, we do
-                 *    this (note: type is for the wrapper type, not enclosed value!)
-                 */
-                if (_forceTypeInformation) {
-                    typeSer.writeTypePrefixForScalar(bean, jgen);
-                } 
-                ser.serializeWithType(value, jgen, provider, typeSer);
-                if (_forceTypeInformation) {
-                    typeSer.writeTypeSuffixForScalar(bean, jgen);
-                } 
-                return;
-            }
-            // But if not, it gets tad trickier (copied from main serialize() method)
-            Class<?> c = value.getClass();
-            ser = provider.findTypedValueSerializer(c, true, _property);
-            // note: now we have bundled type serializer, so should NOT call with typed version
-            ser.serialize(value, jgen, provider);
-        } catch (IOException ioe) {
-            throw ioe;
-        } catch (Exception e) {
-            Throwable t = e;
-            // Need to unwrap this specific type, to see infinite recursion...
-            while (t instanceof InvocationTargetException && t.getCause() != null) {
-                t = t.getCause();
-            }
-            // Errors shouldn't be wrapped (and often can't, as well)
-            if (t instanceof Error) {
-                throw (Error) t;
-            }
-            // let's try to indicate the path best we can...
-            throw JsonMappingException.wrapWithPath(t, bean, _accessorMethod.getName() + "()");
-        }
-    }
-    
-    @Override
-    public JsonNode getSchema(SerializerProvider provider, Type typeHint)
-        throws JsonMappingException
-    {
-        return (_valueSerializer instanceof SchemaAware) ?
-                ((SchemaAware) _valueSerializer).getSchema(provider, null) :
-                JsonSchema.getDefaultSchemaNode();
-    }
-    
-    /*
-    /*******************************************************
-    /* ResolvableSerializer impl
-    /*******************************************************
-     */
-
-    /**
-     * We can try to find the actual serializer for value, if we can
-     * statically figure out what the result type must be.
-     */
-    @Override
-    public void resolve(SerializerProvider provider)
-        throws JsonMappingException
-    {
-        if (_valueSerializer == null) {
-            /* Note: we can only assign serializer statically if the
-             * declared type is final -- if not, we don't really know
-             * the actual type until we get the instance.
-             */
-            // 10-Mar-2010, tatu: Except if static typing is to be used
-            if (provider.isEnabled(SerializationConfig.Feature.USE_STATIC_TYPING)
-                    || Modifier.isFinal(_accessorMethod.getReturnType().getModifiers())) {
-                JavaType t = provider.constructType(_accessorMethod.getGenericReturnType());
-                // false -> no need to cache
-                /* 10-Mar-2010, tatu: Ideally we would actually separate out type
-                 *   serializer from value serializer; but, alas, there's no access
-                 *   to serializer factory at this point... 
-                 */
-                _valueSerializer = provider.findTypedValueSerializer(t, false, _property);
-                /* 09-Dec-2010, tatu: Turns out we must add special handling for
-                 *   cases where "native" (aka "natural") type is being serialized,
-                 *   using standard serializer
-                 */
-                _forceTypeInformation = isNaturalTypeWithStdHandling(t, _valueSerializer);
-            }
-        }
-    }
-
-    protected boolean isNaturalTypeWithStdHandling(JavaType type, JsonSerializer<?> ser)
-    {
-        Class<?> cls = type.getRawClass();
-        // First: do we have a natural type being handled?
-        if (type.isPrimitive()) {
-            if (cls != Integer.TYPE && cls != Boolean.TYPE && cls != Double.TYPE) {
-                return false;
-            }
-        } else {
-            if (cls != String.class &&
-                    cls != Integer.class && cls != Boolean.class && cls != Double.class) {
-                return false;
-            }
-        }
-        // Second: and it's handled with standard serializer?
-        return (ser.getClass().getAnnotation(JacksonStdImpl.class)) != null;
-    }
-    
-    /*
-    /**********************************************************
-    /* Other methods
-    /**********************************************************
-     */
-
-    @Override
-    public String toString()
-    {
-        return "(@JsonValue serializer for method " + _accessorMethod.getDeclaringClass() + "#" + _accessorMethod.getName() + ")";
-    }
-}