calabash-android 0.4.7.pre6 → 0.4.7.pre7

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

@@ -0,0 +1,43 @@
+package sh.calaba.org.codehaus.jackson.map.ser.std;
+
+import java.io.IOException;
+import java.lang.reflect.Type;
+import java.util.Calendar;
+
+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.SerializationConfig;
+import sh.calaba.org.codehaus.jackson.map.SerializerProvider;
+import sh.calaba.org.codehaus.jackson.map.annotate.JacksonStdImpl;
+
+/**
+ * Standard serializer for {@link java.util.Calendar}.
+ * As with other time/date types, is configurable to produce timestamps
+ * (standard Java 64-bit timestamp) or textual formats (usually ISO-8601).
+ * 
+ * @since 1.9 (moved from 'sh.calaba.org.codehaus.jackson.map.ser.StdSerializers#CalendarSerializer}
+ */
+@JacksonStdImpl
+public class CalendarSerializer
+    extends ScalarSerializerBase<Calendar>
+{
+    public static CalendarSerializer instance = new CalendarSerializer();
+
+    public CalendarSerializer() { super(Calendar.class); }
+    
+    @Override
+    public void serialize(Calendar value, JsonGenerator jgen, SerializerProvider provider)
+        throws IOException, JsonGenerationException
+    {
+        provider.defaultSerializeDateValue(value.getTimeInMillis(), jgen);
+    }
+
+    @Override
+    public JsonNode getSchema(SerializerProvider provider, Type typeHint)
+    {
+        //TODO: (ryan) add a format for the date in the schema?
+        return createSchemaNode(provider.isEnabled(SerializationConfig.Feature.WRITE_DATES_AS_TIMESTAMPS)
+                ? "number" : "string", true);
+    }
+}

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

@@ -0,0 +1,113 @@
+package sh.calaba.org.codehaus.jackson.map.ser.std;
+
+import java.io.IOException;
+import java.util.Collection;
+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.ser.impl.PropertySerializerMap;
+import sh.calaba.org.codehaus.jackson.type.JavaType;
+
+/**
+ * Fallback serializer for cases where Collection is not known to be
+ * of type for which more specializer serializer exists (such as
+ * index-accessible List).
+ * If so, we will just construct an {@link java.util.Iterator}
+ * to iterate over elements.
+ */
+public class CollectionSerializer
+    extends AsArraySerializerBase<Collection<?>>
+{
+    public CollectionSerializer(JavaType elemType, boolean staticTyping, TypeSerializer vts,
+            BeanProperty property, JsonSerializer<Object> valueSerializer)
+    {
+        super(Collection.class, elemType, staticTyping, vts, property, valueSerializer);
+    }
+    
+    @Override
+    public ContainerSerializerBase<?> _withValueTypeSerializer(TypeSerializer vts) {
+        return new CollectionSerializer(_elementType, _staticTyping, vts, _property, _elementSerializer);
+    }
+    
+    @Override
+    public void serializeContents(Collection<?> value, JsonGenerator jgen, SerializerProvider provider)
+        throws IOException, JsonGenerationException
+    {
+        if (_elementSerializer != null) {
+            serializeContentsUsing(value, jgen, provider, _elementSerializer);
+            return;
+        }
+        Iterator<?> it = value.iterator();
+        if (!it.hasNext()) {
+            return;
+        }
+        PropertySerializerMap serializers = _dynamicSerializers;
+        final TypeSerializer typeSer = _valueTypeSerializer;
+
+        int i = 0;
+        try {
+            do {
+                Object elem = it.next();
+                if (elem == null) {
+                    provider.defaultSerializeNull(jgen);
+                } else {
+                    Class<?> cc = elem.getClass();
+                    JsonSerializer<Object> serializer = serializers.serializerFor(cc);
+                    if (serializer == null) {
+                        // To fix [JACKSON-508]
+                        if (_elementType.hasGenericTypes()) {
+                            serializer = _findAndAddDynamic(serializers,
+                                    provider.constructSpecializedType(_elementType, cc), provider);
+                        } else {
+                            serializer = _findAndAddDynamic(serializers, cc, provider);
+                        }
+                        serializers = _dynamicSerializers;
+                    }
+                    if (typeSer == null) {
+                        serializer.serialize(elem, jgen, provider);
+                    } else {
+                        serializer.serializeWithType(elem, jgen, provider, typeSer);
+                    }
+                }
+                ++i;
+            } while (it.hasNext());
+        } catch (Exception e) {
+            // [JACKSON-55] Need to add reference information
+            wrapAndThrow(provider, e, value, i);
+        }
+    }
+
+    public void serializeContentsUsing(Collection<?> value, JsonGenerator jgen, SerializerProvider provider,
+            JsonSerializer<Object> ser)
+        throws IOException, JsonGenerationException
+    {
+        Iterator<?> it = value.iterator();
+        if (it.hasNext()) {
+            TypeSerializer typeSer = _valueTypeSerializer;
+            int i = 0;
+            do {
+                Object elem = it.next();
+                try {
+                    if (elem == null) {
+                        provider.defaultSerializeNull(jgen);
+                    } else {
+                        if (typeSer == null) {
+                            ser.serialize(elem, jgen, provider);
+                        } else {
+                            ser.serializeWithType(elem, jgen, provider, typeSer);
+                        }
+                    }
+                    ++i;
+                } catch (Exception e) {
+                    // [JACKSON-55] Need to add reference information
+                    wrapAndThrow(provider, e, value, i);
+                }
+            } while (it.hasNext());
+        }
+    }
+}

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

@@ -0,0 +1,51 @@
+package sh.calaba.org.codehaus.jackson.map.ser.std;
+
+import sh.calaba.org.codehaus.jackson.map.TypeSerializer;
+
+/**
+ * Intermediate base class for types that contain element(s) of
+ * other types. Used for example for List, Map, Object array and
+ * Iterator serializers.
+ * 
+ * @since 1.5
+ */
+public abstract class ContainerSerializerBase<T>
+    extends SerializerBase<T>
+{
+    /*
+    /**********************************************************
+    /* Construction, initialization
+    /**********************************************************
+     */
+
+    protected ContainerSerializerBase(Class<T> t) {
+        super(t);
+    }
+    
+    /**
+     * Alternate constructor that is (alas!) needed to work
+     * around kinks of generic type handling
+     * 
+     * @param t
+     */
+    protected ContainerSerializerBase(Class<?> t, boolean dummy) {
+        super(t, dummy);
+    }
+
+    /**
+     * Factory(-like) method that can be used to construct a new container
+     * serializer that uses specified {@link TypeSerializer} for decorating
+     * contained values with additional type information.
+     * 
+     * @param vts Type serializer to use for contained values; can be null,
+     *    in which case 'this' serializer is returned as is
+     * @return Serializer instance that uses given type serializer for values if
+     *    that is possible (or if not, just 'this' serializer)
+     */
+    public ContainerSerializerBase<?> withValueTypeSerializer(TypeSerializer vts) {
+        if (vts == null) return this;
+        return _withValueTypeSerializer(vts);
+    }
+
+    public abstract ContainerSerializerBase<?> _withValueTypeSerializer(TypeSerializer vts);
+}

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

@@ -0,0 +1,42 @@
+package sh.calaba.org.codehaus.jackson.map.ser.std;
+
+import java.io.IOException;
+import java.lang.reflect.Type;
+import java.util.Date;
+
+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.SerializationConfig;
+import sh.calaba.org.codehaus.jackson.map.SerializerProvider;
+import sh.calaba.org.codehaus.jackson.map.annotate.JacksonStdImpl;
+
+/**
+ * For efficiency, we will serialize Dates as longs, instead of
+ * potentially more readable Strings.
+ *<p>
+ * @since 1.9 (moved from 'sh.calaba.org.codehaus.jackson.map.ser.StdSerializers#UtilDateSerializer}
+ */
+@JacksonStdImpl
+public class DateSerializer
+    extends ScalarSerializerBase<java.util.Date>
+{
+    public static DateSerializer instance = new DateSerializer();
+    
+    public DateSerializer() { super(Date.class); }
+
+    @Override
+    public void serialize(Date value, JsonGenerator jgen, SerializerProvider provider)
+        throws IOException, JsonGenerationException
+    {
+        provider.defaultSerializeDateValue(value, jgen);
+    }
+
+    @Override
+    public JsonNode getSchema(SerializerProvider provider, Type typeHint)
+    {
+        //todo: (ryan) add a format for the date in the schema?
+        return createSchemaNode(provider.isEnabled(SerializationConfig.Feature.WRITE_DATES_AS_TIMESTAMPS)
+                ? "number" : "string", true);
+    }
+}

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

@@ -0,0 +1,218 @@
+package sh.calaba.org.codehaus.jackson.map.ser.std;
+
+import java.io.IOException;
+import java.lang.reflect.ParameterizedType;
+import java.lang.reflect.Type;
+import java.util.*;
+
+import sh.calaba.org.codehaus.jackson.*;
+import sh.calaba.org.codehaus.jackson.map.*;
+import sh.calaba.org.codehaus.jackson.map.annotate.JacksonStdImpl;
+import sh.calaba.org.codehaus.jackson.map.util.EnumValues;
+import sh.calaba.org.codehaus.jackson.node.JsonNodeFactory;
+import sh.calaba.org.codehaus.jackson.node.ObjectNode;
+import sh.calaba.org.codehaus.jackson.schema.JsonSchema;
+import sh.calaba.org.codehaus.jackson.schema.SchemaAware;
+import sh.calaba.org.codehaus.jackson.type.JavaType;
+
+/**
+ * Specialized serializer for {@link EnumMap}s. Somewhat tricky to
+ * implement because actual Enum value type may not be available;
+ * and if not, it can only be gotten from actual instance.
+ */
+@JacksonStdImpl
+public class EnumMapSerializer
+    extends ContainerSerializerBase<EnumMap<? extends Enum<?>, ?>>
+    implements ResolvableSerializer
+{
+    protected final boolean _staticTyping;
+
+    /**
+     * If we know enumeration used as key, this will contain
+     * value set to use for serialization
+     */
+    protected final EnumValues _keyEnums;
+
+    protected final JavaType _valueType;
+
+    /**
+     * Property being serialized with this instance
+     * 
+     * @since 1.7
+     */
+    protected final BeanProperty _property;
+    
+    /**
+     * Value serializer to use, if it can be statically determined
+     * 
+     * @since 1.5
+     */
+    protected JsonSerializer<Object> _valueSerializer;
+
+    /**
+     * Type serializer used for values, if any.
+     */
+    protected final TypeSerializer _valueTypeSerializer;
+
+    /**
+     * @deprecated Since 1.8, use variant that takes value serializer
+     */
+    @Deprecated
+    public EnumMapSerializer(JavaType valueType, boolean staticTyping, EnumValues keyEnums,
+            TypeSerializer vts, BeanProperty property)
+    {
+        this(valueType, staticTyping, keyEnums, vts, property, null);
+    }
+
+    public EnumMapSerializer(JavaType valueType, boolean staticTyping, EnumValues keyEnums,
+            TypeSerializer vts, BeanProperty property, JsonSerializer<Object> valueSerializer)
+    {
+        super(EnumMap.class, false);
+        _staticTyping = staticTyping || (valueType != null && valueType.isFinal());
+        _valueType = valueType;
+        _keyEnums = keyEnums;
+        _valueTypeSerializer = vts;
+        _property = property;
+        _valueSerializer = valueSerializer;
+    }
+
+    @Override
+    public ContainerSerializerBase<?> _withValueTypeSerializer(TypeSerializer vts)
+    {
+        return new EnumMapSerializer(_valueType, _staticTyping, _keyEnums, vts,  _property, _valueSerializer);
+    }
+    
+    @Override
+    public void serialize(EnumMap<? extends Enum<?>,?> value, JsonGenerator jgen, SerializerProvider provider)
+        throws IOException, JsonGenerationException
+    {
+        jgen.writeStartObject();
+        if (!value.isEmpty()) {
+            serializeContents(value, jgen, provider);
+        }        
+        jgen.writeEndObject();
+    }
+
+    @Override
+    public void serializeWithType(EnumMap<? extends Enum<?>,?> value, JsonGenerator jgen, SerializerProvider provider,
+            TypeSerializer typeSer)
+        throws IOException, JsonGenerationException
+    {
+        typeSer.writeTypePrefixForObject(value, jgen);
+        if (!value.isEmpty()) {
+            serializeContents(value, jgen, provider);
+        }
+        typeSer.writeTypeSuffixForObject(value, jgen);
+    }
+    
+    protected void serializeContents(EnumMap<? extends Enum<?>,?> value, JsonGenerator jgen, SerializerProvider provider)
+        throws IOException, JsonGenerationException
+    {
+        if (_valueSerializer != null) {
+            serializeContentsUsing(value, jgen, provider, _valueSerializer);
+            return;
+        }
+        JsonSerializer<Object> prevSerializer = null;
+        Class<?> prevClass = null;
+        EnumValues keyEnums = _keyEnums;
+
+        for (Map.Entry<? extends Enum<?>,?> entry : value.entrySet()) {
+            // First, serialize key
+            Enum<?> key = entry.getKey();
+            if (keyEnums == null) {
+                /* 15-Oct-2009, tatu: This is clumsy, but still the simplest efficient
+                 * way to do it currently, as Serializers get cached. (it does assume we'll always use
+                 * default serializer tho -- so ideally code should be rewritten)
+                 */
+                // ... and lovely two-step casting process too...
+                SerializerBase<?> ser = (SerializerBase<?>) provider.findValueSerializer(
+                        key.getDeclaringClass(), _property);
+                keyEnums = ((EnumSerializer) ser).getEnumValues();
+            }
+            jgen.writeFieldName(keyEnums.serializedValueFor(key));
+            // And then value
+            Object valueElem = entry.getValue();
+            if (valueElem == null) {
+                provider.defaultSerializeNull(jgen);
+            } else {
+                Class<?> cc = valueElem.getClass();
+                JsonSerializer<Object> currSerializer;
+                if (cc == prevClass) {
+                    currSerializer = prevSerializer;
+                } else {
+                    currSerializer = provider.findValueSerializer(cc, _property);
+                    prevSerializer = currSerializer;
+                    prevClass = cc;
+                }
+                try {
+                    currSerializer.serialize(valueElem, jgen, provider);
+                } catch (Exception e) {
+                    // [JACKSON-55] Need to add reference information
+                    wrapAndThrow(provider, e, value, entry.getKey().name());
+                }
+            }
+        }
+    }
+
+    protected void serializeContentsUsing(EnumMap<? extends Enum<?>,?> value, JsonGenerator jgen, SerializerProvider provider,
+            JsonSerializer<Object> valueSer)
+        throws IOException, JsonGenerationException
+    {
+        EnumValues keyEnums = _keyEnums;
+        for (Map.Entry<? extends Enum<?>,?> entry : value.entrySet()) {
+            Enum<?> key = entry.getKey();
+            if (keyEnums == null) {
+                // clumsy, but has to do for now:
+                SerializerBase<?> ser = (SerializerBase<?>) provider.findValueSerializer(key.getDeclaringClass(),
+                        _property);
+                keyEnums = ((EnumSerializer) ser).getEnumValues();
+            }
+            jgen.writeFieldName(keyEnums.serializedValueFor(key));
+            Object valueElem = entry.getValue();
+            if (valueElem == null) {
+                provider.defaultSerializeNull(jgen);
+            } else {
+                try {
+                    valueSer.serialize(valueElem, jgen, provider);
+                } catch (Exception e) {
+                    wrapAndThrow(provider, e, value, entry.getKey().name());
+                }
+            }
+        }
+    }
+
+    @Override
+    public void resolve(SerializerProvider provider)
+        throws JsonMappingException
+    {
+        if (_staticTyping && _valueSerializer == null) {
+            _valueSerializer = provider.findValueSerializer(_valueType, _property);
+        }
+    }
+    
+    @SuppressWarnings("unchecked")
+    @Override
+    public JsonNode getSchema(SerializerProvider provider, Type typeHint)
+        throws JsonMappingException
+    {
+        ObjectNode o = createSchemaNode("object", true);
+        if (typeHint instanceof ParameterizedType) {
+            Type[] typeArgs = ((ParameterizedType) typeHint).getActualTypeArguments();
+            if (typeArgs.length == 2) {
+                JavaType enumType = provider.constructType(typeArgs[0]);
+                JavaType valueType = provider.constructType(typeArgs[1]);
+                ObjectNode propsNode = JsonNodeFactory.instance.objectNode();
+                Class<Enum<?>> enumClass = (Class<Enum<?>>) enumType.getRawClass();
+                for (Enum<?> enumValue : enumClass.getEnumConstants()) {
+                    JsonSerializer<Object> ser = provider.findValueSerializer(valueType.getRawClass(), _property);
+                    JsonNode schemaNode = (ser instanceof SchemaAware) ?
+                            ((SchemaAware) ser).getSchema(provider, null) :
+                            JsonSchema.getDefaultSchemaNode();
+                    propsNode.put(provider.getConfig().getAnnotationIntrospector().findEnumValue((Enum<?>)enumValue), schemaNode);
+                }
+                o.put("properties", propsNode);
+            }
+        }
+        return o;
+    }
+}