calabash-android 0.0.1

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

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

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

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

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

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

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