calabash-android 0.5.2 → 0.5.3

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

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

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

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

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