calabash-android 0.0.1

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

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

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

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

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

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