calabash-android 0.5.2 → 0.5.3

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

@@ -1,39 +0,0 @@
-package sh.calaba.org.codehaus.jackson.map.jsontype;
-
-import java.util.Collection;
-
-import sh.calaba.org.codehaus.jackson.map.AnnotationIntrospector;
-import sh.calaba.org.codehaus.jackson.map.MapperConfig;
-import sh.calaba.org.codehaus.jackson.map.introspect.AnnotatedClass;
-import sh.calaba.org.codehaus.jackson.map.introspect.AnnotatedMember;
-
-/**
- * Helper object used for handling registration on resolving of supertypes
- * to subtypes.
- * 
- * @since 1.5
- */
-public abstract class SubtypeResolver
-{
-    /**
-     * Method for registering specified subtypes (possibly including type
-     * names); for type entries without name, non-qualified class name
-     * as used as name (unless overridden by annotation).
-     */
-    public abstract void registerSubtypes(NamedType... types);
-
-    public abstract void registerSubtypes(Class<?>... classes);
-    
-    /**
-     * Method for finding out all reachable subtypes for a property specified
-     * by given element (method or field)
-     */
-    public abstract Collection<NamedType> collectAndResolveSubtypes(AnnotatedMember property,
-            MapperConfig<?> config, AnnotationIntrospector ai);
-
-    /**
-     * Method for finding out all reachable subtypes for given type.
-     */
-    public abstract Collection<NamedType> collectAndResolveSubtypes(AnnotatedClass basetype,
-            MapperConfig<?> config, AnnotationIntrospector ai);
-}

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

@@ -1,74 +0,0 @@
-package sh.calaba.org.codehaus.jackson.map.jsontype;
-
-import sh.calaba.org.codehaus.jackson.annotate.JsonTypeInfo;
-import sh.calaba.org.codehaus.jackson.type.JavaType;
-
-/**
- * Interface that defines standard API for converting types
- * to type identifiers and vice versa. Used by type resolvers
- * ({@link sh.calaba.org.codehaus.jackson.map.TypeSerializer},
- * {@link sh.calaba.org.codehaus.jackson.map.TypeDeserializer}) for converting
- * between type and matching id; id is stored in JSON and needed for
- * creating instances of proper subtypes when deserializing values.
- * 
- * @since 1.5
- */
-public interface TypeIdResolver
-{
-    /*
-    /**********************************************************
-    /* Initialization/configuration methods
-    /**********************************************************
-     */
-
-    /**
-     * Method that will be called once before any type resolution calls;
-     * used to initialize instance with configuration. This is necessary
-     * since instances may be created via reflection, without ability to
-     * call specific constructor to pass in configuration settings.
-     * 
-     * @param baseType Base type for which this id resolver instance is
-     *   used
-     */
-    public void init(JavaType baseType);
-
-    /*
-    /**********************************************************
-    /* Conversions between types and type ids
-    /**********************************************************
-     */
-    
-    /**
-     * Method called to serialize type of the type of given value
-     * as a String to include in serialized JSON content.
-     */
-    public String idFromValue(Object value);
-
-    /**
-     * Alternative method used for determining type from combination of
-     * value and type, using suggested type (that serializer provides)
-     * and possibly value of that type. Most common implementation will
-     * use suggested type as is.
-     * 
-     * @since 1.8
-     */
-    public String idFromValueAndType(Object value, Class<?> suggestedType);
-
-    /**
-     * Method called to resolve type from given type identifier.
-     */
-    public JavaType typeFromId(String id);
-
-    /*
-    /**********************************************************
-    /* Accessors for metadata
-    /**********************************************************
-     */
-
-     /**
-      * Accessor for mechanism that this resolver uses for determining
-      * type id from type. Mostly informational; not required to be called
-      * or used.
-      */
-     public JsonTypeInfo.Id getMechanism();
-}

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

@@ -1,151 +0,0 @@
-package sh.calaba.org.codehaus.jackson.map.jsontype;
-
-import java.util.Collection;
-
-import sh.calaba.org.codehaus.jackson.annotate.JsonTypeInfo;
-import sh.calaba.org.codehaus.jackson.annotate.JsonTypeInfo.As;
-import sh.calaba.org.codehaus.jackson.map.BeanProperty;
-import sh.calaba.org.codehaus.jackson.map.DeserializationConfig;
-import sh.calaba.org.codehaus.jackson.map.SerializationConfig;
-import sh.calaba.org.codehaus.jackson.map.TypeDeserializer;
-import sh.calaba.org.codehaus.jackson.map.TypeSerializer;
-import sh.calaba.org.codehaus.jackson.type.JavaType;
-
-/**
- * Interface that defines builders that are configured based on
- * annotations (like {@link JsonTypeInfo} or JAXB annotations),
- * and produce type serializers and deserializers used for
- * handling type information embedded in JSON to allow for safe
- * polymorphic type handling.
- *<p>
- * Builder is first initialized by calling {@link #init} method, and then
- * configured using <code>setXxx</code> (and <code>registerXxx</code>)
- * methods. Finally, after calling all configuration methods,
- * {@link #buildTypeSerializer} or {@link #buildTypeDeserializer}
- * will be called to get actual type resolver constructed
- * and used for resolving types for configured base type and its
- * subtypes.
- *<p>
- * Note that instances are used for two related but distinct use cases:
- *<ul>
- * <li>To create builders to use with explicit type information
- *    inclusion (usually via <code>@JsonTypeInfo</code> annotation)
- *   </li>
- * <li>To create builders when "default typing" is used; if so, type information
- *   is automatically included for certain kind of types, regardless of annotations
- *   </li>
- *</ul>
- * Important distinction between the cases is that in first case, calls to
- * create builders are only made when builders are certainly needed; whereas
- * in second case builder has to first verify whether type information is
- * applicable for given type, and if not, just return null to indicate this.
- * 
- * @since 1.5
- * @author tatu
- */
-public interface TypeResolverBuilder<T extends TypeResolverBuilder<T>>
-{
-    /*
-    /**********************************************************
-    /* Accessors
-    /**********************************************************
-     */
-
-    /**
-     * Accessor for currently configured default type; implementation
-     * class that may be used in case no valid type information is
-     * available during type resolution
-     * 
-     * @since 1.9
-     */
-    public Class<?> getDefaultImpl();
-    
-    /*
-    /**********************************************************
-    /* Actual builder methods
-    /**********************************************************
-     */
-
-    /**
-     * Method for building type serializer based on current configuration
-     * of this builder.
-     * 
-     * @param baseType Base type that constructed resolver will
-     *    handle; super type of all types it will be used for.
-     */
-    public TypeSerializer buildTypeSerializer(SerializationConfig config,
-            JavaType baseType, Collection<NamedType> subtypes, BeanProperty property);
-
-    /**
-     * Method for building type deserializer based on current configuration
-     * of this builder.
-     * 
-     * @param baseType Base type that constructed resolver will
-     *    handle; super type of all types it will be used for.
-     * @param subtypes Known subtypes of the base type.
-     */
-    public TypeDeserializer buildTypeDeserializer( DeserializationConfig config,
-            JavaType baseType, Collection<NamedType> subtypes, BeanProperty property);
-    
-    /*
-    /**********************************************************
-    /* Initialization method(s) that must be called before other
-    /* configuration
-    /**********************************************************
-     */
-
-    /**
-     * Initialization method that is called right after constructing
-     * the builder instance.
-     *
-     * @param idType Which type metadata is used
-     * @param res (optional) Custom type id resolver used, if any
-     * 
-     * @return Resulting builder instance (usually this builder,
-     *   but not necessarily)
-     */
-    public T init(JsonTypeInfo.Id idType, TypeIdResolver res);
-    
-    /*
-    /**********************************************************
-    /* Methods for configuring resolver to build 
-    /**********************************************************
-     */
-    
-    /**
-     * Method for specifying mechanism to use for including type metadata
-     * in JSON.
-     * If not explicitly called, setting defaults to
-     * {@link As#PROPERTY}.
-     * 
-     * @param includeAs Mechanism used for including type metadata in JSON
-     * 
-     * @return Resulting builder instance (usually this builder,
-     *   but not necessarily)
-     */
-    public T inclusion(As includeAs);
-
-    /**
-     * Method for specifying name of property used for including type
-     * information. Not used for all inclusion mechanisms;
-     * usually only used with {@link As#PROPERTY}.
-     *<p>
-     * If not explicitly called, name of property to use is based on
-     * defaults for {@link sh.calaba.org.codehaus.jackson.annotate.JsonTypeInfo.Id} configured.
-     * 
-     * @param propName Name of JSON property to use for including
-     *    type information
-     * 
-     * @return Resulting builder instance (usually this builder,
-     *   but not necessarily)
-     */
-    public T typeProperty(String propName);
-
-    /**
-     * Method for specifying default implementation to use if type id 
-     * is either not available, or can not be resolved.
-     * 
-     * @since 1.9
-     */
-    public T defaultImpl(Class<?> defaultImpl);
-}

data/test-server/instrumentation-backend/src/sh/calaba/org/codehaus/jackson/map/jsontype/impl/AsArrayTypeDeserializer.java

@@ -1,126 +0,0 @@
-package sh.calaba.org.codehaus.jackson.map.jsontype.impl;
-
-import java.io.IOException;
-
-import sh.calaba.org.codehaus.jackson.*;
-import sh.calaba.org.codehaus.jackson.annotate.JsonTypeInfo.As;
-import sh.calaba.org.codehaus.jackson.map.*;
-import sh.calaba.org.codehaus.jackson.map.jsontype.TypeIdResolver;
-import sh.calaba.org.codehaus.jackson.type.JavaType;
-
-/**
- * Type deserializer used with {@link As#WRAPPER_ARRAY}
- * inclusion mechanism. Simple since JSON structure used is always
- * the same, regardless of structure used for actual value: wrapping
- * is done using a 2-element JSON Array where type id is the first
- * element, and actual object data as second element.
- * 
- * @author tatus
- */
-public class AsArrayTypeDeserializer extends TypeDeserializerBase
-{
-    @Deprecated // since 1.9
-    public AsArrayTypeDeserializer(JavaType bt, TypeIdResolver idRes, BeanProperty property) {
-        this(bt, idRes, property, null);
-    }
-
-    public AsArrayTypeDeserializer(JavaType bt, TypeIdResolver idRes, BeanProperty property,
-            Class<?> defaultImpl)
-    {
-        super(bt, idRes, property, defaultImpl);
-    }
-    
-    @Override
-    public As getTypeInclusion() {
-        return As.WRAPPER_ARRAY;
-    }
-
-    /**
-     * Method called when actual object is serialized as JSON Array.
-     */
-    @Override
-    public Object deserializeTypedFromArray(JsonParser jp, DeserializationContext ctxt)
-        throws IOException, JsonProcessingException
-    {
-        return _deserialize(jp, ctxt);
-    }
-
-    /**
-     * Method called when actual object is serialized as JSON Object
-     */
-    @Override
-    public Object deserializeTypedFromObject(JsonParser jp, DeserializationContext ctxt)
-        throws IOException, JsonProcessingException
-    {
-        return _deserialize(jp, ctxt);
-    }
-    
-    @Override
-    public Object deserializeTypedFromScalar(JsonParser jp, DeserializationContext ctxt)
-        throws IOException, JsonProcessingException
-    {
-        return _deserialize(jp, ctxt);
-    }    
-
-    @Override
-    public Object deserializeTypedFromAny(JsonParser jp, DeserializationContext ctxt)
-        throws IOException, JsonProcessingException
-    {
-        return _deserialize(jp, ctxt);
-    }    
-    
-    /*
-    /***************************************************************
-    /* Internal methods
-    /***************************************************************
-     */
-
-    /**
-     * Method that handles type information wrapper, locates actual
-     * subtype deserializer to use, and calls it to do actual
-     * deserialization.
-     */
-    private final Object _deserialize(JsonParser jp, DeserializationContext ctxt)
-        throws IOException, JsonProcessingException
-    {
-        boolean hadStartArray = jp.isExpectedStartArrayToken();
-        JsonDeserializer<Object> deser = _findDeserializer(ctxt, _locateTypeId(jp, ctxt));
-        Object value = deser.deserialize(jp, ctxt);
-        // And then need the closing END_ARRAY
-        if (hadStartArray && jp.nextToken() != JsonToken.END_ARRAY) {
-            throw ctxt.wrongTokenException(jp, JsonToken.END_ARRAY,
-                    "expected closing END_ARRAY after type information and deserialized value");
-        }
-        return value;
-    }    
-    
-    protected final String _locateTypeId(JsonParser jp, DeserializationContext ctxt)
-        throws IOException, JsonProcessingException
-    {
-        if (!jp.isExpectedStartArrayToken()) {
-            // Add instanceof check because we cannot add method to TypeIdResolver interface due to backwards
-            // compatibility issues.  We can however add it to the base method, which gets at least some of
-            // the functionality we want.  Falls back to old exception for other types of TypeIdResolvers
-            if (_idResolver instanceof TypeIdResolverBase) {
-                if (_defaultImpl != null) { // but let's require existence of default impl, as a safeguard
-                    return ((TypeIdResolverBase) _idResolver).idFromBaseType();
-                }
-            }
-            throw ctxt.wrongTokenException(jp, JsonToken.START_ARRAY,
-                    "need JSON Array to contain As.WRAPPER_ARRAY type information for class "+baseTypeName());
-        }
-        // And then type id as a String
-        if (jp.nextToken() != JsonToken.VALUE_STRING) {
-            if (_idResolver instanceof TypeIdResolverBase) {
-                if (_defaultImpl != null) { // but let's require existence of default impl, as a safeguard
-                    return ((TypeIdResolverBase) _idResolver).idFromBaseType();
-                }
-            }
-            throw ctxt.wrongTokenException(jp, JsonToken.VALUE_STRING,
-                    "need JSON String that contains type id (for subtype of "+baseTypeName()+")");
-        }
-        String result = jp.getText();
-        jp.nextToken();
-        return result;
-    }
-}

data/test-server/instrumentation-backend/src/sh/calaba/org/codehaus/jackson/map/jsontype/impl/AsArrayTypeSerializer.java

@@ -1,110 +0,0 @@
-package sh.calaba.org.codehaus.jackson.map.jsontype.impl;
-
-import java.io.IOException;
-
-import sh.calaba.org.codehaus.jackson.JsonGenerator;
-import sh.calaba.org.codehaus.jackson.JsonProcessingException;
-import sh.calaba.org.codehaus.jackson.annotate.JsonTypeInfo.As;
-import sh.calaba.org.codehaus.jackson.map.BeanProperty;
-import sh.calaba.org.codehaus.jackson.map.jsontype.TypeIdResolver;
-
-/**
- * Type serializer that will embed type information in an array,
- * as the first element, and actual value as the second element.
- * 
- * @since 1.5
- * @author tatu
- */
-public class AsArrayTypeSerializer
-    extends TypeSerializerBase
-{
-    public AsArrayTypeSerializer(TypeIdResolver idRes, BeanProperty property)
-    {
-        super(idRes, property);
-    }
-
-    @Override
-    public As getTypeInclusion() { return As.WRAPPER_ARRAY; }
-    
-    @Override
-    public void writeTypePrefixForObject(Object value, JsonGenerator jgen)
-        throws IOException, JsonProcessingException
-    {
-        jgen.writeStartArray();
-        jgen.writeString(_idResolver.idFromValue(value));
-        jgen.writeStartObject();
-    }
-
-    @Override
-    public void writeTypePrefixForObject(Object value, JsonGenerator jgen,
-            Class<?> type)
-        throws IOException, JsonProcessingException
-    {
-        jgen.writeStartArray();
-        jgen.writeString(_idResolver.idFromValueAndType(value, type));
-        jgen.writeStartObject();
-    }
-    
-    @Override
-    public void writeTypePrefixForArray(Object value, JsonGenerator jgen)
-        throws IOException, JsonProcessingException
-    {
-        jgen.writeStartArray();
-        jgen.writeString(_idResolver.idFromValue(value));
-        jgen.writeStartArray();
-    }
-
-    @Override
-    public void writeTypePrefixForArray(Object value, JsonGenerator jgen,
-            Class<?> type)
-        throws IOException, JsonProcessingException
-    {
-        jgen.writeStartArray();
-        jgen.writeString(_idResolver.idFromValueAndType(value, type));
-        jgen.writeStartArray();
-    }
-    
-    @Override
-    public void writeTypePrefixForScalar(Object value, JsonGenerator jgen)
-            throws IOException, JsonProcessingException
-    {
-        // only need the wrapper array
-        jgen.writeStartArray();
-        jgen.writeString(_idResolver.idFromValue(value));
-    }
-
-    @Override
-    public void writeTypePrefixForScalar(Object value, JsonGenerator jgen,
-            Class<?> type)
-        throws IOException, JsonProcessingException
-    {
-        // only need the wrapper array
-        jgen.writeStartArray();
-        jgen.writeString(_idResolver.idFromValueAndType(value, type));
-    }
-    
-    @Override
-    public void writeTypeSuffixForObject(Object value, JsonGenerator jgen)
-            throws IOException, JsonProcessingException
-    {
-        jgen.writeEndObject();
-        jgen.writeEndArray();
-    }
-
-    @Override
-    public void writeTypeSuffixForArray(Object value, JsonGenerator jgen)
-            throws IOException, JsonProcessingException
-    {
-        // wrapper array first, and then array caller needs to close
-        jgen.writeEndArray();
-        jgen.writeEndArray();
-    }
-
-    @Override
-    public void writeTypeSuffixForScalar(Object value, JsonGenerator jgen)
-            throws IOException, JsonProcessingException
-    {
-        // just the wrapper array to close
-        jgen.writeEndArray();
-    }
-}