calabash-android 0.4.7.pre6 → 0.4.7.pre7

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

@@ -0,0 +1,38 @@
+package sh.calaba.org.codehaus.jackson.map.ser.std;
+
+import java.lang.reflect.Type;
+import java.io.IOException;
+
+import sh.calaba.org.codehaus.jackson.*;
+import sh.calaba.org.codehaus.jackson.map.*;
+import sh.calaba.org.codehaus.jackson.map.annotate.JacksonStdImpl;
+
+/**
+ * This is a simple dummy serializer that will just output literal
+ * JSON null value whenever serialization is requested.
+ * Used as the default "null serializer" (which is used for serializing
+ * null object references unless overridden), as well as for some
+ * more exotic types (java.lang.Void).
+ */
+@JacksonStdImpl
+public class NullSerializer
+    extends SerializerBase<Object>
+{
+    public final static NullSerializer instance = new NullSerializer();
+    
+    private NullSerializer() { super(Object.class); }
+    
+    @Override
+    public void serialize(Object value, JsonGenerator jgen, SerializerProvider provider)
+        throws IOException, JsonGenerationException
+    {
+        jgen.writeNull();
+    }
+    
+    @Override
+    public JsonNode getSchema(SerializerProvider provider, Type typeHint)
+        throws JsonMappingException
+    {
+        return createSchemaNode("null");
+    }
+}

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

@@ -0,0 +1,281 @@
+package sh.calaba.org.codehaus.jackson.map.ser.std;
+
+import java.io.IOException;
+import java.lang.reflect.InvocationTargetException;
+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.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;
+import sh.calaba.org.codehaus.jackson.map.ser.impl.PropertySerializerMap;
+import sh.calaba.org.codehaus.jackson.map.type.ArrayType;
+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;
+
+/**
+ * Generic serializer for Object arrays (<code>Object[]</code>).
+ * 
+ * @since 1.9 (moved from 'sh.calaba.org.codehaus.jackson.map.ser.impl.ObjectArraySerializer')
+ */
+@JacksonStdImpl
+public class ObjectArraySerializer
+    extends StdArraySerializers.ArraySerializerBase<Object[]>
+    implements ResolvableSerializer
+{
+    /**
+     * Whether we are using static typing (using declared types, ignoring
+     * runtime type) or not for elements.
+     */
+    protected final boolean _staticTyping;
+
+    /**
+     * Declared type of element entries
+     */
+    protected final JavaType _elementType;
+
+    /**
+     * Value serializer to use, if it can be statically determined.
+     * 
+     * @since 1.5
+     */
+    protected JsonSerializer<Object> _elementSerializer;
+
+    /**
+     * If element type can not be statically determined, mapping from
+     * runtime type to serializer is handled using this object
+     * 
+     * @since 1.7
+     */
+    protected PropertySerializerMap _dynamicSerializers;
+    
+    /**
+     * @deprecated since 1.8
+     */
+    @Deprecated
+    public ObjectArraySerializer(JavaType elemType, boolean staticTyping,
+            TypeSerializer vts, BeanProperty property)
+    {
+        this(elemType, staticTyping, vts, property, null);
+    }
+    
+    public ObjectArraySerializer(JavaType elemType, boolean staticTyping,
+            TypeSerializer vts, BeanProperty property, JsonSerializer<Object> elementSerializer)
+    {
+        super(Object[].class, vts, property);
+        _elementType = elemType;
+        _staticTyping = staticTyping;
+        _dynamicSerializers = PropertySerializerMap.emptyMap();
+        _elementSerializer = elementSerializer;
+    }
+
+    @Override
+    public ContainerSerializerBase<?> _withValueTypeSerializer(TypeSerializer vts)
+    {
+        return new ObjectArraySerializer(_elementType, _staticTyping, vts, _property, _elementSerializer);
+    }
+    
+    @Override
+    public void serializeContents(Object[] value, JsonGenerator jgen, SerializerProvider provider)
+        throws IOException, JsonGenerationException
+    {
+        final int len = value.length;
+        if (len == 0) {
+            return;
+        }
+        if (_elementSerializer != null) {
+            serializeContentsUsing(value, jgen, provider, _elementSerializer);
+            return;
+        }
+        if (_valueTypeSerializer != null) {
+            serializeTypedContents(value, jgen, provider);
+            return;
+        }
+        int i = 0;
+        Object elem = null;
+        try {
+            PropertySerializerMap serializers = _dynamicSerializers;
+            for (; i < len; ++i) {
+                elem = value[i];
+                if (elem == null) {
+                    provider.defaultSerializeNull(jgen);
+                    continue;
+                }
+                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);
+                    }
+                }
+                serializer.serialize(elem, jgen, provider);
+            }
+        } catch (IOException ioe) {
+            throw ioe;
+        } catch (Exception e) {
+            // [JACKSON-55] Need to add reference information
+            /* 05-Mar-2009, tatu: But one nasty edge is when we get
+             *   StackOverflow: usually due to infinite loop. But that gets
+             *   hidden within an InvocationTargetException...
+             */
+            Throwable t = e;
+            while (t instanceof InvocationTargetException && t.getCause() != null) {
+                t = t.getCause();
+            }
+            if (t instanceof Error) {
+                throw (Error) t;
+            }
+            throw JsonMappingException.wrapWithPath(t, elem, i);
+        }
+    }
+
+    public void serializeContentsUsing(Object[] value, JsonGenerator jgen, SerializerProvider provider,
+            JsonSerializer<Object> ser)
+        throws IOException, JsonGenerationException
+    {
+        final int len = value.length;
+        final TypeSerializer typeSer = _valueTypeSerializer;
+
+        int i = 0;
+        Object elem = null;
+        try {
+            for (; i < len; ++i) {
+                elem = value[i];
+                if (elem == null) {
+                    provider.defaultSerializeNull(jgen);
+                    continue;
+                }
+                if (typeSer == null) {
+                    ser.serialize(elem, jgen, provider);
+                } else {
+                    ser.serializeWithType(elem, jgen, provider, typeSer);
+                }
+            }
+        } catch (IOException ioe) {
+            throw ioe;
+        } catch (Exception e) {
+            Throwable t = e;
+            while (t instanceof InvocationTargetException && t.getCause() != null) {
+                t = t.getCause();
+            }
+            if (t instanceof Error) {
+                throw (Error) t;
+            }
+            throw JsonMappingException.wrapWithPath(t, elem, i);
+        }
+    }
+
+    public void serializeTypedContents(Object[] value, JsonGenerator jgen, SerializerProvider provider)
+        throws IOException, JsonGenerationException
+    {
+        final int len = value.length;
+        final TypeSerializer typeSer = _valueTypeSerializer;
+        int i = 0;
+        Object elem = null;
+        try {
+            PropertySerializerMap serializers = _dynamicSerializers;
+            for (; i < len; ++i) {
+                elem = value[i];
+                if (elem == null) {
+                    provider.defaultSerializeNull(jgen);
+                    continue;
+                }
+                Class<?> cc = elem.getClass();
+                JsonSerializer<Object> serializer = serializers.serializerFor(cc);
+                if (serializer == null) {
+                    serializer = _findAndAddDynamic(serializers, cc, provider);
+                }
+                serializer.serializeWithType(elem, jgen, provider, typeSer);
+            }
+        } catch (IOException ioe) {
+            throw ioe;
+        } catch (Exception e) {
+            Throwable t = e;
+            while (t instanceof InvocationTargetException && t.getCause() != null) {
+                t = t.getCause();
+            }
+            if (t instanceof Error) {
+                throw (Error) t;
+            }
+            throw JsonMappingException.wrapWithPath(t, elem, i);
+        }
+    }
+    
+    @Override
+    public JsonNode getSchema(SerializerProvider provider, Type typeHint)
+        throws JsonMappingException
+    {
+        ObjectNode o = createSchemaNode("array", true);
+        if (typeHint != null) {
+            JavaType javaType = provider.constructType(typeHint);
+            if (javaType.isArrayType()) {
+                Class<?> componentType = ((ArrayType) javaType).getContentType().getRawClass();
+                // 15-Oct-2010, tatu: We can't serialize plain Object.class; but what should it produce here? Untyped?
+                if (componentType == Object.class) {
+                    o.put("items", JsonSchema.getDefaultSchemaNode());
+                } else {
+                    JsonSerializer<Object> ser = provider.findValueSerializer(componentType, _property);
+                    JsonNode schemaNode = (ser instanceof SchemaAware) ?
+                            ((SchemaAware) ser).getSchema(provider, null) :
+                            JsonSchema.getDefaultSchemaNode();
+                    o.put("items", schemaNode);
+                }
+            }
+        }
+        return o;
+    }
+
+    /**
+     * Need to get callback to resolve value serializer, if static typing
+     * is used (either being forced, or because value type is final)
+     */
+    @Override
+    public void resolve(SerializerProvider provider)
+        throws JsonMappingException
+    {
+        if (_staticTyping && _elementSerializer == null) {
+            _elementSerializer = provider.findValueSerializer(_elementType, _property);
+        }
+    }        
+
+    /**
+     * @since 1.7
+     */
+    protected final JsonSerializer<Object> _findAndAddDynamic(PropertySerializerMap map,
+            Class<?> type, SerializerProvider provider) throws JsonMappingException
+    {
+        PropertySerializerMap.SerializerAndMapResult result = map.findAndAddSerializer(type, provider, _property);
+        // did we get a new map of serializers? If so, start using it
+        if (map != result.map) {
+            _dynamicSerializers = result.map;
+        }
+        return result.serializer;
+    }
+
+    /**
+     * @since 1.8
+     */
+    protected final JsonSerializer<Object> _findAndAddDynamic(PropertySerializerMap map,
+            JavaType type, SerializerProvider provider) throws JsonMappingException
+    {
+        PropertySerializerMap.SerializerAndMapResult result = map.findAndAddSerializer(type, provider, _property);
+        // did we get a new map of serializers? If so, start using it
+        if (map != result.map) {
+            _dynamicSerializers = result.map;
+        }
+        return result.serializer;
+    }
+
+}

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

@@ -0,0 +1,52 @@
+package sh.calaba.org.codehaus.jackson.map.ser.std;
+
+import java.lang.reflect.Type;
+import java.io.IOException;
+
+import sh.calaba.org.codehaus.jackson.*;
+import sh.calaba.org.codehaus.jackson.map.*;
+import sh.calaba.org.codehaus.jackson.map.annotate.JacksonStdImpl;
+
+/**
+ * This is a simple dummy serializer that will just output raw values by calling toString()
+ * on value to serialize.
+ * 
+ * @since 1.7
+ */
+@JacksonStdImpl
+public class RawSerializer<T>
+    extends SerializerBase<T>
+{
+    /**
+     * Constructor takes in expected type of values; but since caller
+     * typically can not really provide actual type parameter, we will
+     * just take wild card and coerce type.
+     */
+    public RawSerializer(Class<?> cls) {
+        super(cls, false);
+    }
+
+    @Override
+    public void serialize(T value, JsonGenerator jgen, SerializerProvider provider)
+        throws IOException, JsonGenerationException
+    {
+        jgen.writeRawValue(value.toString());
+    }
+
+    @Override
+    public void serializeWithType(T value, JsonGenerator jgen, SerializerProvider provider,
+            TypeSerializer typeSer)
+        throws IOException, JsonProcessingException
+    {
+        typeSer.writeTypePrefixForScalar(value, jgen);
+        serialize(value, jgen, provider);
+        typeSer.writeTypeSuffixForScalar(value, jgen);
+    }
+    
+    @Override
+    public JsonNode getSchema(SerializerProvider provider, Type typeHint)
+    {
+        // type not really known, but since it is a JSON string:
+        return createSchemaNode("string", true);
+    }
+}

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

@@ -0,0 +1,52 @@
+package sh.calaba.org.codehaus.jackson.map.ser.std;
+
+import java.io.IOException;
+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.map.JsonMappingException;
+import sh.calaba.org.codehaus.jackson.map.SerializerProvider;
+import sh.calaba.org.codehaus.jackson.map.TypeSerializer;
+
+public abstract class ScalarSerializerBase<T>
+    extends SerializerBase<T>
+{
+    protected ScalarSerializerBase(Class<T> t) {
+        super(t);
+    }
+
+    /**
+     * Alternate constructor that is (alas!) needed to work
+     * around kinks of generic type handling
+     */
+    @SuppressWarnings("unchecked")
+    protected ScalarSerializerBase(Class<?> t, boolean dummy) {
+        super((Class<T>) t);
+    }
+    
+    /**
+     * Default implementation will write type prefix, call regular serialization
+     * method (since assumption is that value itself does not need JSON
+     * Array or Object start/end markers), and then write type suffix.
+     * This should work for most cases; some sub-classes may want to
+     * change this behavior.
+     */
+    @Override
+    public void serializeWithType(T value, JsonGenerator jgen, SerializerProvider provider,
+            TypeSerializer typeSer)
+        throws IOException, JsonGenerationException
+    {
+        typeSer.writeTypePrefixForScalar(value, jgen);
+        serialize(value, jgen, provider);
+        typeSer.writeTypeSuffixForScalar(value, jgen);
+    }
+
+    @Override
+    public JsonNode getSchema(SerializerProvider provider, Type typeHint)
+        throws JsonMappingException
+    {
+        return createSchemaNode("string", true);
+    }
+}

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

@@ -0,0 +1,99 @@
+package sh.calaba.org.codehaus.jackson.map.ser.std;
+
+import java.io.IOException;
+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.map.JsonMappingException;
+import sh.calaba.org.codehaus.jackson.map.JsonSerializable;
+import sh.calaba.org.codehaus.jackson.map.JsonSerializableWithType;
+import sh.calaba.org.codehaus.jackson.map.ObjectMapper;
+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.map.ser.SerializerBase;
+import sh.calaba.org.codehaus.jackson.map.type.TypeFactory;
+import sh.calaba.org.codehaus.jackson.node.ObjectNode;
+import sh.calaba.org.codehaus.jackson.schema.JsonSerializableSchema;
+
+/**
+ * Generic handler for types that implement {@link JsonSerializable}.
+ *<p>
+ * Note: given that this is used for anything that implements
+ * interface, can not be checked for direct class equivalence.
+ */
+@JacksonStdImpl
+@SuppressWarnings("deprecation")
+public class SerializableSerializer
+    extends SerializerBase<JsonSerializable>
+{
+    public final static SerializableSerializer instance = new SerializableSerializer();
+
+    protected SerializableSerializer() { super(JsonSerializable.class); }
+
+    @Override
+    public void serialize(JsonSerializable value, JsonGenerator jgen, SerializerProvider provider)
+        throws IOException, JsonGenerationException
+    {
+        value.serialize(jgen, provider);
+    }
+
+    @Override
+    public final void serializeWithType(JsonSerializable value, JsonGenerator jgen, SerializerProvider provider,
+            TypeSerializer typeSer)
+        throws IOException, JsonGenerationException
+    {
+        /* 24-Jan-2009, tatus: This is not quite optimal (perhaps we should
+         *   just create separate serializer...), but works until 2.0 will
+         *   deprecate non-typed interface
+         */
+        if (value instanceof JsonSerializableWithType) {
+            ((JsonSerializableWithType) value).serializeWithType(jgen, provider, typeSer);
+        } else {
+            this.serialize(value, jgen, provider);
+        }
+    }
+    
+    @Override
+    public JsonNode getSchema(SerializerProvider provider, Type typeHint)
+        throws JsonMappingException
+    {
+        ObjectNode objectNode = createObjectNode();
+        String schemaType = "any";
+        String objectProperties = null;
+        String itemDefinition = null;
+        if (typeHint != null) {
+            Class<?> rawClass = TypeFactory.type(typeHint).getRawClass();
+            if (rawClass.isAnnotationPresent(JsonSerializableSchema.class)) {
+                JsonSerializableSchema schemaInfo = rawClass.getAnnotation(JsonSerializableSchema.class);
+                schemaType = schemaInfo.schemaType();
+                if (!"##irrelevant".equals(schemaInfo.schemaObjectPropertiesDefinition())) {
+                    objectProperties = schemaInfo.schemaObjectPropertiesDefinition();
+                }
+                if (!"##irrelevant".equals(schemaInfo.schemaItemDefinition())) {
+                    itemDefinition = schemaInfo.schemaItemDefinition();
+                }
+            }
+        }
+        objectNode.put("type", schemaType);
+        if (objectProperties != null) {
+            try {
+                objectNode.put("properties", new ObjectMapper().readValue(objectProperties, JsonNode.class));
+            } catch (IOException e) {
+                throw new IllegalStateException(e);
+            }
+        }
+        if (itemDefinition != null) {
+            try {
+                objectNode.put("items", new ObjectMapper().readValue(itemDefinition, JsonNode.class));
+            } catch (IOException e) {
+                throw new IllegalStateException(e);
+            }
+        }
+        // always optional, no need to specify:
+        //objectNode.put("required", false);
+        return objectNode;
+    }
+}