calabash-android 0.0.1

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

@@ -0,0 +1,121 @@
+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 wrapper that tries to use an extra JSON Object, with a single
+ * entry that has type name as key, to serialize type information.
+ * If this is not possible (value is serialize as array or primitive),
+ * will use {@link As#WRAPPER_ARRAY} mechanism as fallback: that is,
+ * just use a wrapping array with type information as the first element
+ * and value as second.
+ * 
+ * @since 1.5
+ * @author tatus
+ */
+public class AsWrapperTypeSerializer
+    extends TypeSerializerBase
+{
+    public AsWrapperTypeSerializer(TypeIdResolver idRes, BeanProperty property)
+    {
+        super(idRes, property);
+    }
+
+    @Override
+    public As getTypeInclusion() { return As.WRAPPER_OBJECT; }
+    
+    @Override
+    public void writeTypePrefixForObject(Object value, JsonGenerator jgen)
+        throws IOException, JsonProcessingException
+    {
+        // wrapper
+        jgen.writeStartObject();
+        // and then JSON Object start caller wants
+        jgen.writeObjectFieldStart(_idResolver.idFromValue(value));
+    }
+
+    @Override
+    public void writeTypePrefixForObject(Object value, JsonGenerator jgen,
+            Class<?> type)
+        throws IOException, JsonProcessingException
+    {
+        // wrapper
+        jgen.writeStartObject();
+        // and then JSON Object start caller wants
+        jgen.writeObjectFieldStart(_idResolver.idFromValueAndType(value, type));
+    }
+    
+    @Override
+    public void writeTypePrefixForArray(Object value, JsonGenerator jgen)
+        throws IOException, JsonProcessingException
+    {
+        // can still wrap ok
+        jgen.writeStartObject();
+        // and then JSON Array start caller wants
+        jgen.writeArrayFieldStart(_idResolver.idFromValue(value));
+    }
+
+    @Override
+    public void writeTypePrefixForArray(Object value, JsonGenerator jgen,
+            Class<?> type)
+        throws IOException, JsonProcessingException
+    {
+        // can still wrap ok
+        jgen.writeStartObject();
+        // and then JSON Array start caller wants
+        jgen.writeArrayFieldStart(_idResolver.idFromValueAndType(value, type));
+    }
+    
+    @Override
+    public void writeTypePrefixForScalar(Object value, JsonGenerator jgen)
+        throws IOException, JsonProcessingException
+    {
+        // can still wrap ok
+        jgen.writeStartObject();
+        jgen.writeFieldName(_idResolver.idFromValue(value));
+    }
+
+    @Override
+    public void writeTypePrefixForScalar(Object value, JsonGenerator jgen,
+            Class<?> type)
+        throws IOException, JsonProcessingException
+    {
+        // can still wrap ok
+        jgen.writeStartObject();
+        jgen.writeFieldName(_idResolver.idFromValueAndType(value, type));
+    }
+    
+    @Override
+    public void writeTypeSuffixForObject(Object value, JsonGenerator jgen)
+        throws IOException, JsonProcessingException
+    {
+        // first close JSON Object caller used
+        jgen.writeEndObject();
+        // and then wrapper
+        jgen.writeEndObject();
+    }
+
+    @Override
+    public void writeTypeSuffixForArray(Object value, JsonGenerator jgen)
+        throws IOException, JsonProcessingException
+    {
+        // first close array caller needed
+        jgen.writeEndArray();
+        // then wrapper object
+        jgen.writeEndObject();
+    }
+    
+    @Override
+    public void writeTypeSuffixForScalar(Object value, JsonGenerator jgen)
+        throws IOException, JsonProcessingException
+    {
+        // just need to close the wrapper object
+        jgen.writeEndObject();
+    }    
+}

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

@@ -0,0 +1,138 @@
+package sh.calaba.org.codehaus.jackson.map.jsontype.impl;
+
+import java.util.*;
+
+import sh.calaba.org.codehaus.jackson.annotate.JsonTypeInfo;
+import sh.calaba.org.codehaus.jackson.map.type.TypeFactory;
+import sh.calaba.org.codehaus.jackson.map.util.ClassUtil;
+import sh.calaba.org.codehaus.jackson.type.JavaType;
+
+/**
+ * {@link sh.calaba.org.codehaus.jackson.map.jsontype.TypeIdResolver} implementation
+ * that converts between fully-qualified
+ * Java class names and (JSON) Strings.
+ */
+public class ClassNameIdResolver
+    extends TypeIdResolverBase
+{
+    public ClassNameIdResolver(JavaType baseType, TypeFactory typeFactory) {
+        super(baseType, typeFactory);
+    }
+
+    @Override
+    public JsonTypeInfo.Id getMechanism() { return JsonTypeInfo.Id.CLASS; }
+
+    public void registerSubtype(Class<?> type, String name) {
+        // not used with class name - based resolvers
+    }
+    
+    @Override
+    public String idFromValue(Object value)
+    {
+        return _idFrom(value, value.getClass());
+    }
+
+    @Override
+    public String idFromValueAndType(Object value, Class<?> type)
+    {
+        return _idFrom(value, type);
+    }
+
+    @Override
+    public JavaType typeFromId(String id)
+    {
+        /* 30-Jan-2010, tatu: Most ids are basic class names; so let's first
+         *    check if any generics info is added; and only then ask factory
+         *    to do translation when necessary
+         */
+        if (id.indexOf('<') > 0) {
+            JavaType t = TypeFactory.fromCanonical(id);
+            // note: may want to try combining with specialization (esp for EnumMap)
+            return t;
+        }
+        try {
+            /* [JACKSON-350]: Default Class.forName() won't work too well; context class loader
+             *    seems like slightly better choice
+             */
+//          Class<?> cls = Class.forName(id);
+            ClassLoader loader = Thread.currentThread().getContextClassLoader();
+            Class<?> cls = Class.forName(id, true, loader);
+            return _typeFactory.constructSpecializedType(_baseType, cls);
+        } catch (ClassNotFoundException e) {
+            throw new IllegalArgumentException("Invalid type id '"+id+"' (for id type 'Id.class'): no such class found");
+        } catch (Exception e) {
+            throw new IllegalArgumentException("Invalid type id '"+id+"' (for id type 'Id.class'): "+e.getMessage(), e);
+        }
+    }
+
+    /*
+    /**********************************************************
+    /* Internal methods
+    /**********************************************************
+     */
+    
+    protected final String _idFrom(Object value, Class<?> cls)
+    {
+        // [JACKSON-380] Need to ensure that "enum subtypes" work too
+        if (Enum.class.isAssignableFrom(cls)) {
+            if (!cls.isEnum()) { // means that it's sub-class of base enum, so:
+                cls = cls.getSuperclass();
+            }
+        }
+        String str = cls.getName();
+        if (str.startsWith("java.util")) {
+            /* 25-Jan-2009, tatu: There are some internal classes that
+             *   we can not access as is. We need better mechanism; for
+             *   now this has to do...
+             */
+            /* Enum sets and maps are problematic since we MUST know
+             * type of contained enums, to be able to deserialize.
+             * In addition, EnumSet is not a concrete type either
+             */
+            if (value instanceof EnumSet<?>) { // Regular- and JumboEnumSet...
+                Class<?> enumClass = ClassUtil.findEnumType((EnumSet<?>) value);
+                // not optimal: but EnumSet is not a customizable type so this is sort of ok
+                str = TypeFactory.defaultInstance().constructCollectionType(EnumSet.class, enumClass).toCanonical();
+            } else if (value instanceof EnumMap<?,?>) {
+                Class<?> enumClass = ClassUtil.findEnumType((EnumMap<?,?>) value);
+                Class<?> valueClass = Object.class;
+                // not optimal: but EnumMap is not a customizable type so this is sort of ok
+                str = TypeFactory.defaultInstance().constructMapType(EnumMap.class, enumClass, valueClass).toCanonical();
+            } else {
+                String end = str.substring(9);
+                if ((end.startsWith(".Arrays$") || end.startsWith(".Collections$"))
+                       && str.indexOf("List") >= 0) {
+                    /* 17-Feb-2010, tatus: Another such case: result of
+                     *    Arrays.asList() is named like so in Sun JDK...
+                     *   Let's just plain old ArrayList in its place
+                     * NOTE: chances are there are plenty of similar cases
+                     * for other wrappers... (immutable, singleton, synced etc)
+                     */
+                    str = "java.util.ArrayList";
+                }
+            }
+        } else if (str.indexOf('$') >= 0) {
+            /* Other special handling may be needed for inner classes, [JACKSON-584].
+             * The best way to handle would be to find 'hidden' constructor; pass parent
+             * value etc (which is actually done for non-anonymous static classes!),
+             * but that is just not possible due to various things. So, we will instead
+             * try to generalize type into something we will be more likely to be able
+             * construct.
+             */
+            Class<?> outer = ClassUtil.getOuterClass(cls);
+            if (outer != null) {
+                /* one more check: let's actually not worry if the declared
+                 * static type is non-static as well; if so, deserializer does
+                 * have a chance at figuring it all out.
+                 */
+                Class<?> staticType = _baseType.getRawClass();
+                if (ClassUtil.getOuterClass(staticType) == null) {
+                    // Is this always correct? Seems like it should be...
+                    cls = _baseType.getRawClass();
+                    str = cls.getName();
+                }
+            }
+        }
+        return str;
+    }
+}

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

@@ -0,0 +1,66 @@
+package sh.calaba.org.codehaus.jackson.map.jsontype.impl;
+
+import sh.calaba.org.codehaus.jackson.annotate.JsonTypeInfo;
+import sh.calaba.org.codehaus.jackson.map.type.TypeFactory;
+import sh.calaba.org.codehaus.jackson.type.JavaType;
+
+public class MinimalClassNameIdResolver
+    extends ClassNameIdResolver
+{
+    /**
+     * Package name of the base class, to be used for determining common
+     * prefix that can be omitted from included type id.
+     * Does not include the trailing dot.
+     */
+    protected final String _basePackageName;
+
+    /**
+     * Same as {@link #_basePackageName}, but includes trailing dot.
+     */
+    protected final String _basePackagePrefix;
+    
+    protected MinimalClassNameIdResolver(JavaType baseType, TypeFactory typeFactory)
+    {
+        super(baseType, typeFactory);
+        String base = baseType.getRawClass().getName();
+        int ix = base.lastIndexOf('.');
+        if (ix < 0) { // can this ever occur?
+            _basePackageName = "";
+            _basePackagePrefix = ".";
+        } else {
+            _basePackagePrefix = base.substring(0, ix+1);
+            _basePackageName = base.substring(0, ix);
+        }
+    }
+
+    @Override
+    public JsonTypeInfo.Id getMechanism() { return JsonTypeInfo.Id.MINIMAL_CLASS; }
+    
+    @Override
+    public String idFromValue(Object value)
+    {
+        String n = value.getClass().getName();
+        if (n.startsWith(_basePackagePrefix)) {
+            // note: we will leave the leading dot in there
+            return n.substring(_basePackagePrefix.length()-1);
+        }
+        return n;
+    }
+
+    @Override
+    public JavaType typeFromId(String id)
+    {
+        if (id.startsWith(".")) {
+            StringBuilder sb = new StringBuilder(id.length() + _basePackageName.length());
+            if  (_basePackageName.length() == 0) {
+                // no package; must remove leading '.' from id
+                sb.append(id.substring(1));
+            } else {
+                // otherwise just concatenate package, with leading-dot-partial name
+                sb.append(_basePackageName).append(id);
+            }
+            id = sb.toString();
+        }
+        return super.typeFromId(id);
+    }
+}

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

@@ -0,0 +1,151 @@
+package sh.calaba.org.codehaus.jackson.map.jsontype.impl;
+
+import java.util.*;
+
+import sh.calaba.org.codehaus.jackson.map.AnnotationIntrospector;
+import sh.calaba.org.codehaus.jackson.map.MapperConfig;
+import sh.calaba.org.codehaus.jackson.map.introspect.*;
+import sh.calaba.org.codehaus.jackson.map.jsontype.NamedType;
+import sh.calaba.org.codehaus.jackson.map.jsontype.SubtypeResolver;
+
+/**
+ * @since 1.5
+ */
+public class StdSubtypeResolver extends SubtypeResolver
+{
+    protected LinkedHashSet<NamedType> _registeredSubtypes;
+
+    public StdSubtypeResolver() { }
+    
+    /*
+    /**********************************************************
+    /* Public API
+    /**********************************************************
+     */
+
+    @Override    
+    public void registerSubtypes(NamedType... types)
+    {
+        if (_registeredSubtypes == null) {
+            _registeredSubtypes = new LinkedHashSet<NamedType>();
+        }
+        for (NamedType type : types) {
+            _registeredSubtypes.add(type);
+        }
+    }
+
+    @Override
+    public void registerSubtypes(Class<?>... classes)
+    {
+        NamedType[] types = new NamedType[classes.length];
+        for (int i = 0, len = classes.length; i < len; ++i) {
+            types[i] = new NamedType(classes[i]);
+        }
+        registerSubtypes(types);
+    }
+    
+    /**
+     * 
+     * @param property Base member to use for type resolution: either annotated type (class),
+     *    or property (field, getter/setter)
+     */
+    @Override
+    public Collection<NamedType> collectAndResolveSubtypes(AnnotatedMember property,
+        MapperConfig<?> config, AnnotationIntrospector ai)
+    {
+        HashMap<NamedType, NamedType> collected = new HashMap<NamedType, NamedType>();
+        // start with registered subtypes (which have precedence)
+        if (_registeredSubtypes != null) {
+            Class<?> rawBase = property.getRawType();
+            for (NamedType subtype : _registeredSubtypes) {
+                // is it a subtype of root type?
+                if (rawBase.isAssignableFrom(subtype.getType())) { // yes
+                    AnnotatedClass curr = AnnotatedClass.constructWithoutSuperTypes(subtype.getType(), ai, config);
+                    _collectAndResolve(curr, subtype, config, ai, collected);
+                }
+            }
+        }
+
+        // then annotated types for property itself
+        Collection<NamedType> st = ai.findSubtypes(property);
+        if (st != null) {
+            for (NamedType nt : st) {
+                AnnotatedClass ac = AnnotatedClass.constructWithoutSuperTypes(nt.getType(), ai, config);
+                _collectAndResolve(ac, nt, config, ai, collected);
+            }            
+        }
+        NamedType rootType = new NamedType(property.getRawType(), null);
+        AnnotatedClass ac = AnnotatedClass.constructWithoutSuperTypes(property.getRawType(), ai, config);
+            
+        // and finally subtypes via annotations from base type (recursively)
+        _collectAndResolve(ac, rootType, config, ai, collected);
+        return new ArrayList<NamedType>(collected.values());
+    }
+
+    @Override
+    public Collection<NamedType> collectAndResolveSubtypes(AnnotatedClass type,
+            MapperConfig<?> config, AnnotationIntrospector ai)
+    {
+        HashMap<NamedType, NamedType> subtypes = new HashMap<NamedType, NamedType>();
+        // [JACKSON-257] then consider registered subtypes (which have precedence over annotations)
+        if (_registeredSubtypes != null) {
+            Class<?> rawBase = type.getRawType();
+            for (NamedType subtype : _registeredSubtypes) {
+                // is it a subtype of root type?
+                if (rawBase.isAssignableFrom(subtype.getType())) { // yes
+                    AnnotatedClass curr = AnnotatedClass.constructWithoutSuperTypes(subtype.getType(), ai, config);
+                    _collectAndResolve(curr, subtype, config, ai, subtypes);
+                }
+            }
+        }
+        // and then check subtypes via annotations from base type (recursively)
+        NamedType rootType = new NamedType(type.getRawType(), null);
+        _collectAndResolve(type, rootType, config, ai, subtypes);
+        return new ArrayList<NamedType>(subtypes.values());
+    }
+
+    /*
+    /**********************************************************
+    /* Internal methods
+    /**********************************************************
+     */
+    
+    /**
+     * Method called to find subtypes for a specific type (class)
+     */
+    protected void _collectAndResolve(AnnotatedClass annotatedType, NamedType namedType,
+            MapperConfig<?> config, AnnotationIntrospector ai, HashMap<NamedType, NamedType> collectedSubtypes)
+    {
+        if (!namedType.hasName()) {
+            String name = ai.findTypeName(annotatedType);
+            if (name != null) {
+                namedType = new NamedType(namedType.getType(), name);
+            }
+        }
+
+        // First things first: is base type itself included?
+        if (collectedSubtypes.containsKey(namedType)) {
+            // if so, no recursion; however, may need to update name?
+            if (namedType.hasName()) {
+                NamedType prev = collectedSubtypes.get(namedType);
+                if (!prev.hasName()) {
+                    collectedSubtypes.put(namedType, namedType);
+                }
+            }
+            return;
+        }
+        // if it wasn't, add and check subtypes recursively
+        collectedSubtypes.put(namedType, namedType);
+        Collection<NamedType> st = ai.findSubtypes(annotatedType);
+        if (st != null && !st.isEmpty()) {
+            for (NamedType subtype : st) {
+                AnnotatedClass subtypeClass = AnnotatedClass.constructWithoutSuperTypes(subtype.getType(), ai, config);
+                // One more thing: name may be either in reference, or in subtype:
+                if (!subtype.hasName()) {
+                    subtype = new NamedType(subtype.getType(), ai.findTypeName(subtypeClass));
+                }
+                _collectAndResolve(subtypeClass, subtype, config, ai, collectedSubtypes);
+            }
+        }
+    }
+}