calabash-android 0.5.2 → 0.5.3

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

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

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

@@ -1,36 +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.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

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

@@ -1,73 +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.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

@@ -1,66 +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.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

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