calabash-android 0.0.1

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

@@ -0,0 +1,95 @@
+package sh.calaba.org.codehaus.jackson.map.ser.std;
+
+import java.io.IOException;
+import java.util.Calendar;
+import java.util.Date;
+
+import sh.calaba.org.codehaus.jackson.JsonGenerationException;
+import sh.calaba.org.codehaus.jackson.JsonGenerator;
+import sh.calaba.org.codehaus.jackson.map.JsonSerializer;
+import sh.calaba.org.codehaus.jackson.map.SerializerProvider;
+import sh.calaba.org.codehaus.jackson.type.JavaType;
+
+public class StdKeySerializers
+{
+    protected final static JsonSerializer<Object> DEFAULT_KEY_SERIALIZER = new StdKeySerializer();
+
+    @SuppressWarnings("unchecked")
+    protected final static JsonSerializer<Object> DEFAULT_STRING_SERIALIZER
+        = (JsonSerializer<Object>)(JsonSerializer<?>) new StringKeySerializer();
+    
+    private StdKeySerializers() { }
+
+    @SuppressWarnings("unchecked")
+    public static JsonSerializer<Object> getStdKeySerializer(JavaType keyType)
+    {
+        if (keyType == null) {
+            return DEFAULT_KEY_SERIALIZER;
+        }
+        Class<?> cls = keyType.getRawClass();
+        if (cls == String.class) {
+            return DEFAULT_STRING_SERIALIZER;
+        }
+        if (cls == Object.class) {
+            return DEFAULT_KEY_SERIALIZER;
+        }
+        // [JACKSON-606] special handling for dates...
+        if (Date.class.isAssignableFrom(cls)) {
+            return (JsonSerializer<Object>) DateKeySerializer.instance;
+        }
+        if (Calendar.class.isAssignableFrom(cls)) {
+            return (JsonSerializer<Object>) CalendarKeySerializer.instance;
+        }
+        // If no match, just use default one:
+        return DEFAULT_KEY_SERIALIZER;
+    }
+
+    /*
+    /**********************************************************
+    /* Standard implementations
+    /**********************************************************
+     */
+
+    public static class StringKeySerializer
+        extends SerializerBase<String>
+    {
+        public StringKeySerializer() { super(String.class); }
+        
+        @Override
+        public void serialize(String value, JsonGenerator jgen, SerializerProvider provider)
+            throws IOException, JsonGenerationException
+        {
+            jgen.writeFieldName(value);
+        }
+    }
+
+    public static class DateKeySerializer
+        extends SerializerBase<Date>
+    {
+        protected final static JsonSerializer<?> instance = new DateKeySerializer();
+
+        public DateKeySerializer() { super(Date.class); }
+        
+        @Override
+        public void serialize(Date value, JsonGenerator jgen, SerializerProvider provider)
+            throws IOException, JsonGenerationException
+        {
+            provider.defaultSerializeDateKey(value, jgen);
+        }
+    }
+
+    public static class CalendarKeySerializer
+        extends SerializerBase<Calendar>
+    {
+        protected final static JsonSerializer<?> instance = new CalendarKeySerializer();
+
+        public CalendarKeySerializer() { super(Calendar.class); }
+        
+        @Override
+        public void serialize(Calendar value, JsonGenerator jgen, SerializerProvider provider)
+            throws IOException, JsonGenerationException
+        {
+            provider.defaultSerializeDateKey(value.getTimeInMillis(), jgen);
+        }
+    }
+}

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

@@ -0,0 +1,119 @@
+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 Collection}s that contain Strings.
+ * 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 class StringCollectionSerializer
+    extends StaticListSerializerBase<Collection<String>>
+    implements ResolvableSerializer
+{
+    protected JsonSerializer<String> _serializer;
+    
+    public StringCollectionSerializer(BeanProperty property) {
+        super(Collection.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(Collection<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(Collection<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(Collection<String> value, JsonGenerator jgen, SerializerProvider provider)
+        throws IOException, JsonGenerationException
+    {
+        if (_serializer != null) {
+            serializeUsingCustom(value, jgen, provider);
+            return;
+        }
+        int i = 0;
+        for (String str : value) {
+            try {
+                if (str == null) {
+                    provider.defaultSerializeNull(jgen);
+                } else {
+                    jgen.writeString(str);
+                }
+                ++i;
+            } catch (Exception e) {
+                wrapAndThrow(provider, e, value, i);
+            }
+        }
+    }
+
+    private void serializeUsingCustom(Collection<String> value, JsonGenerator jgen, SerializerProvider provider)
+        throws IOException, JsonGenerationException
+    {
+        final JsonSerializer<String> ser = _serializer;
+        int i = 0;
+        for (String str : value) {
+            try {
+                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/StringSerializer.java

@@ -0,0 +1,36 @@
+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.SerializerProvider;
+import sh.calaba.org.codehaus.jackson.map.annotate.JacksonStdImpl;
+
+/**
+ * This is the special serializer for regular {@link java.lang.String}s.
+ *<p>
+ * Since this is one of "native" types, no type information is ever
+ * included on serialization (unlike for most scalar types as of 1.5)
+ */
+@JacksonStdImpl
+public final class StringSerializer
+    extends NonTypedScalarSerializerBase<String>
+{
+    public StringSerializer() { super(String.class); }
+
+    @Override
+    public void serialize(String value, JsonGenerator jgen, SerializerProvider provider)
+        throws IOException, JsonGenerationException
+    {
+        jgen.writeString(value);
+    }
+
+    @Override
+    public JsonNode getSchema(SerializerProvider provider, Type typeHint)
+    {
+        return createSchemaNode("string", true);
+    }
+}

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

@@ -0,0 +1,38 @@
+package sh.calaba.org.codehaus.jackson.map.ser.std;
+
+import java.io.IOException;
+import java.util.TimeZone;
+
+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;
+
+/**
+ * @since 1.8
+ */
+public class TimeZoneSerializer
+    extends ScalarSerializerBase<TimeZone>
+{
+    public final static TimeZoneSerializer instance = new TimeZoneSerializer();
+    
+    public TimeZoneSerializer() { super(TimeZone.class); }
+
+    @Override
+    public void serialize(TimeZone value, JsonGenerator jgen, SerializerProvider provider)
+        throws IOException, JsonGenerationException
+    {
+        jgen.writeString(value.getID());
+    }
+
+    @Override
+    public void serializeWithType(TimeZone value, JsonGenerator jgen, SerializerProvider provider,
+            TypeSerializer typeSer)
+        throws IOException, JsonGenerationException
+    {
+        // Better ensure we don't use specific sub-classes:
+        typeSer.writeTypePrefixForScalar(value, jgen, TimeZone.class);
+        serialize(value, jgen, provider);
+        typeSer.writeTypeSuffixForScalar(value, jgen);
+    }
+}

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

@@ -0,0 +1,73 @@
+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;
+import sh.calaba.org.codehaus.jackson.map.annotate.JacksonStdImpl;
+
+/**
+ * Simple general purpose serializer, useful for any
+ * type for which {@link Object#toString} returns the desired JSON
+ * value.
+ */
+@JacksonStdImpl
+public class ToStringSerializer
+    extends SerializerBase<Object>
+{
+    /**
+     * Singleton instance to use.
+     */
+    public final static ToStringSerializer instance = new ToStringSerializer();
+
+    /**
+     *<p>
+     * Note: usually you should NOT create new instances, but instead use
+     * {@link #instance} which is stateless and fully thread-safe. However,
+     * there are cases where constructor is needed; for example,
+     * when using explicit serializer annotations like
+     * {@link sh.calaba.org.codehaus.jackson.map.annotate.JsonSerialize#using}.
+     */
+    public ToStringSerializer() { super(Object.class); }
+    
+    @Override
+    public void serialize(Object value, JsonGenerator jgen, SerializerProvider provider)
+        throws IOException, JsonGenerationException
+    {
+        jgen.writeString(value.toString());
+    }
+
+    /* 01-Mar-2011, tatu: We were serializing as "raw" String; but generally that
+     *   is not what we want, since lack of type information would imply real
+     *   String type.
+     */
+    /**
+     * 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(Object 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/TokenBufferSerializer.java

@@ -0,0 +1,66 @@
+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.SerializerProvider;
+import sh.calaba.org.codehaus.jackson.map.TypeSerializer;
+import sh.calaba.org.codehaus.jackson.map.annotate.JacksonStdImpl;
+import sh.calaba.org.codehaus.jackson.util.TokenBuffer;
+
+/**
+ * We also want to directly support serialization of {@link TokenBuffer};
+ * and since it is part of core package, it can not implement
+ * {@link sh.calaba.org.codehaus.jackson.map.JsonSerializable}
+ * (which is only included in the mapper package)
+ *
+ * @since 1.5
+ */
+@JacksonStdImpl
+public class TokenBufferSerializer
+    extends SerializerBase<TokenBuffer>
+{
+    public TokenBufferSerializer() { super(TokenBuffer.class); }
+
+    @Override
+    public void serialize(TokenBuffer value, JsonGenerator jgen, SerializerProvider provider)
+        throws IOException, JsonGenerationException
+    {
+        value.serialize(jgen);
+    }
+
+    /**
+     * Implementing typed output for contents of a TokenBuffer is very tricky,
+     * since we do not know for sure what its contents might look like (or, rather,
+     * we do know when serializing, but not necessarily when deserializing!)
+     * One possibility would be to check the current token, and use that to
+     * determine if we would output JSON Array, Object or scalar value.
+     * Jackson 1.5 did NOT include any type information; but this seems wrong,
+     * and so 1.6 WILL include type information.
+     *<p>
+     * Note that we just claim it is scalar; this should work ok and is simpler
+     * than doing introspection on both serialization and deserialization.
+     */
+    @Override
+    public final void serializeWithType(TokenBuffer 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)
+    {
+        /* 01-Jan-2010, tatu: Not 100% sure what we should say here:
+         *   type is basically not known. This seems closest
+         *   approximation
+         */
+        return createSchemaNode("any", true);
+    }
+}    

data/test-server/instrumentation-backend/src/sh/calaba/org/codehaus/jackson/map/type/ArrayType.java

@@ -0,0 +1,260 @@
+package sh.calaba.org.codehaus.jackson.map.type;
+
+import java.lang.reflect.Array;
+
+import sh.calaba.org.codehaus.jackson.type.JavaType;
+
+/**
+ * Array types represent Java arrays, both primitive and object valued.
+ * Further, Object-valued arrays can have element type of any other
+ * legal {@link JavaType}.
+ */
+public final class ArrayType
+    extends TypeBase
+{
+    /**
+     * Type of elements in the array.
+     */
+    protected final JavaType _componentType;
+
+    /**
+     * We will also keep track of shareable instance of empty array,
+     * since it usually needs to be constructed any way; and because
+     * it is essentially immutable and thus can be shared.
+     */
+    protected final Object _emptyArray;
+
+    private ArrayType(JavaType componentType, Object emptyInstance,
+            Object valueHandler, Object typeHandler)
+    {
+        super(emptyInstance.getClass(), componentType.hashCode(),
+                valueHandler, typeHandler);
+        _componentType = componentType;
+        _emptyArray = emptyInstance;
+    }
+
+    /**
+     * @deprecated Since 1.9, if you must directly instantiate,
+     *  call method that takes handlers
+     */
+    @Deprecated
+    public static ArrayType construct(JavaType componentType)
+    {
+        return construct(componentType, null, null);
+    }                                   
+
+    public static ArrayType construct(JavaType componentType,
+            Object valueHandler, Object typeHandler)
+    {
+        /* This is bit messy: there is apparently no other way to
+         * reconstruct actual concrete/raw array class from component
+         * type, than to construct an instance, get class (same is
+         * true for GenericArracyType as well; hence we won't bother
+         * passing that in).
+         */
+        Object emptyInstance = Array.newInstance(componentType.getRawClass(), 0);
+        return new ArrayType(componentType, emptyInstance, null, null);
+    }                                   
+    
+    // Since 1.7:
+    @Override
+    public ArrayType withTypeHandler(Object h)
+    {
+        if (h == _typeHandler) {
+            return this;
+        }
+        return new ArrayType(_componentType, _emptyArray, _valueHandler, h);
+    }
+
+    // Since 1.7:
+    @Override
+    public ArrayType withContentTypeHandler(Object h)
+    {
+        if (h == _componentType.getTypeHandler()) {
+            return this;
+        }
+        return new ArrayType(_componentType.withTypeHandler(h), _emptyArray,
+                _valueHandler, _typeHandler);
+    }
+
+    // Since 1.9:
+    @Override
+    public ArrayType withValueHandler(Object h) {
+        if (h == _valueHandler) {
+            return this;
+        }
+        return new ArrayType(_componentType, _emptyArray, h, _typeHandler);
+    }
+
+    // Since 1.9:
+    @Override
+    public ArrayType withContentValueHandler(Object h) {
+        if (h == _componentType.getValueHandler()) {
+            return this;
+        }
+        return new ArrayType(_componentType.withValueHandler(h), _emptyArray,
+                _valueHandler, _typeHandler);
+    }
+    
+    @Override
+    protected String buildCanonicalName() {
+        return _class.getName();
+    }
+    
+    /*
+    /**********************************************************
+    /* Methods for narrowing conversions
+    /**********************************************************
+     */
+
+    /**
+     * Handling of narrowing conversions for arrays is trickier: for now,
+     * it is not even allowed.
+     */
+    @Override
+    protected JavaType _narrow(Class<?> subclass)
+    {
+        /* Ok: need a bit of indirection here. First, must replace component
+         * type (and check that it is compatible), then re-construct.
+         */
+        if (!subclass.isArray()) { // sanity check, should never occur
+            throw new IllegalArgumentException("Incompatible narrowing operation: trying to narrow "+toString()+" to class "+subclass.getName());
+        }
+        /* Hmmh. This is an awkward back reference... but seems like the
+         * only simple way to do it.
+         */
+        Class<?> newCompClass = subclass.getComponentType();
+        /* 14-Mar-2011, tatu: it gets even worse, as we do not have access to
+         *   currently configured TypeFactory. This could theoretically cause
+         *   problems (when narrowing from array of Objects, to array of non-standard
+         *   Maps, for example); but for now need to defer solving this until
+         *   it actually becomes a real problem, not just potential one.
+         *   (famous last words?)
+         */
+        JavaType newCompType = TypeFactory.defaultInstance().constructType(newCompClass);
+        return construct(newCompType, _valueHandler, _typeHandler);
+    }
+
+    /**
+     * For array types, both main type and content type can be modified;
+     * but ultimately they are interchangeable.
+     */
+    @Override
+    public JavaType narrowContentsBy(Class<?> contentClass)
+    {
+        // Can do a quick check first:
+        if (contentClass == _componentType.getRawClass()) {
+            return this;
+        }
+        return construct(_componentType.narrowBy(contentClass),
+                _valueHandler, _typeHandler);
+    }
+
+    @Override
+    public JavaType widenContentsBy(Class<?> contentClass)
+    {
+        // Can do a quick check first:
+        if (contentClass == _componentType.getRawClass()) {
+            return this;
+        }
+        return construct(_componentType.widenBy(contentClass),
+                _valueHandler, _typeHandler);
+    }
+    
+    /*
+    /**********************************************************
+    /* Overridden methods
+    /**********************************************************
+     */
+
+    @Override
+    public boolean isArrayType() { return true; }
+    
+    /**
+     * For some odd reason, modifiers for array classes would
+     * claim they are abstract types. Not so, at least for our
+     * purposes.
+     */
+    @Override
+    public boolean isAbstract() { return false; }
+
+    /**
+     * For some odd reason, modifiers for array classes would
+     * claim they are abstract types. Not so, at least for our
+     * purposes.
+     */
+    @Override
+    public boolean isConcrete() { return true; }
+
+    @Override
+    public boolean hasGenericTypes() {
+        // arrays are not parameterized, but element type may be:
+        return _componentType.hasGenericTypes();
+    }
+    
+    /**
+     * Not sure what symbolic name is used internally, if any;
+     * let's follow naming of Collection types here.
+     * Should not really matter since array types have no
+     * super types.
+     */
+    @Override
+    public String containedTypeName(int index) {
+        if (index == 0) return "E";
+        return null;
+    }
+    
+    /*
+    /**********************************************************
+    /* Public API
+    /**********************************************************
+     */
+
+    @Override
+    public boolean isContainerType() { return true; }
+
+    @Override
+    public JavaType getContentType() { return  _componentType; }
+
+    @Override
+    public int containedTypeCount() { return 1; }
+    @Override
+    public JavaType containedType(int index) {
+            return (index == 0) ? _componentType : null;
+    }
+    
+    @Override
+    public StringBuilder getGenericSignature(StringBuilder sb) {
+        sb.append('[');
+        return _componentType.getGenericSignature(sb);
+    }
+
+    @Override
+    public StringBuilder getErasedSignature(StringBuilder sb) {
+        sb.append('[');
+        return _componentType.getErasedSignature(sb);
+    }
+    
+    /*
+    /**********************************************************
+    /* Standard methods
+    /**********************************************************
+     */
+
+    @Override
+    public String toString()
+    {
+        return "[array type, component type: "+_componentType+"]";
+    }
+
+    @Override
+    public boolean equals(Object o)
+    {
+        if (o == this) return true;
+        if (o == null) return false;
+        if (o.getClass() != getClass()) return false;
+
+        ArrayType other = (ArrayType) o;
+        return _componentType.equals(other._componentType);
+    }
+}