RubyGems - calabash-android - Versions diffs - 0.5.2 → 0.5.3 - Mend

calabash-android 0.5.2 → 0.5.3

Files changed (640) hide show

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

@@ -1,202 +0,0 @@
-package sh.calaba.org.codehaus.jackson.map.jsontype.impl;
-import java.util.Collection;
-import sh.calaba.org.codehaus.jackson.annotate.JsonTypeInfo;
-import sh.calaba.org.codehaus.jackson.map.*;
-import sh.calaba.org.codehaus.jackson.map.jsontype.NamedType;
-import sh.calaba.org.codehaus.jackson.map.jsontype.TypeIdResolver;
-import sh.calaba.org.codehaus.jackson.map.jsontype.TypeResolverBuilder;
-import sh.calaba.org.codehaus.jackson.type.JavaType;
-/**
- * Default {@link TypeResolverBuilder} implementation.
- *
- * @author tatu
- * @since 1.5
- */
-public class StdTypeResolverBuilder
-    implements TypeResolverBuilder<StdTypeResolverBuilder>
-{
-    // Configuration settings:
-    protected JsonTypeInfo.Id _idType;
-    protected JsonTypeInfo.As _includeAs;
-    protected String _typeProperty;
-    /**
-     * @since 1.9
-     */
-    protected Class<?> _defaultImpl;
-    // Objects
-    protected TypeIdResolver _customIdResolver;
-    /*
-    /**********************************************************
-    /* Accessors
-    /**********************************************************
-     */
-    @Override
-    public Class<?> getDefaultImpl() {
-        return _defaultImpl;
-    }
-    /*
-    /**********************************************************
-    /* Construction, initialization, actual building
-    /**********************************************************
-     */
-    public StdTypeResolverBuilder() { }
-    public static StdTypeResolverBuilder noTypeInfoBuilder() {
-        return new StdTypeResolverBuilder().init(JsonTypeInfo.Id.NONE, null);
-    }
-    @Override
-    public StdTypeResolverBuilder init(JsonTypeInfo.Id idType, TypeIdResolver idRes)
-    {
-        // sanity checks
-        if (idType == null) {
-            throw new IllegalArgumentException("idType can not be null");
-        }
-        _idType = idType;
-        _customIdResolver = idRes;
-        // Let's also initialize property name as per idType default
-        _typeProperty = idType.getDefaultPropertyName();
-        return this;
-    }
-    @Override
-    public TypeSerializer buildTypeSerializer(SerializationConfig config,
-            JavaType baseType, Collection<NamedType> subtypes, BeanProperty property)
-    {
-        if (_idType == JsonTypeInfo.Id.NONE) {
-            return null;
-        }
-        TypeIdResolver idRes = idResolver(config, baseType, subtypes, true, false);
-        switch (_includeAs) {
-        case WRAPPER_ARRAY:
-            return new AsArrayTypeSerializer(idRes, property);
-        case PROPERTY:
-            return new AsPropertyTypeSerializer(idRes, property, _typeProperty);
-        case WRAPPER_OBJECT:
-            return new AsWrapperTypeSerializer(idRes, property);
-        case EXTERNAL_PROPERTY:
-            return new AsExternalTypeSerializer(idRes, property, _typeProperty);
-        }
-        throw new IllegalStateException("Do not know how to construct standard type serializer for inclusion type: "+_includeAs);
-    }
-    @Override
-    public TypeDeserializer buildTypeDeserializer(DeserializationConfig config,
-            JavaType baseType, Collection<NamedType> subtypes, BeanProperty property)
-    {
-        if (_idType == JsonTypeInfo.Id.NONE) {
-            return null;
-        }
-        TypeIdResolver idRes = idResolver(config, baseType, subtypes, false, true);
-        // First, method for converting type info to type id:
-        switch (_includeAs) {
-        case WRAPPER_ARRAY:
-            return new AsArrayTypeDeserializer(baseType, idRes, property, _defaultImpl);
-        case PROPERTY:
-            return new AsPropertyTypeDeserializer(baseType, idRes, property,
-                    _defaultImpl, _typeProperty);
-        case WRAPPER_OBJECT:
-            return new AsWrapperTypeDeserializer(baseType, idRes, property, _defaultImpl);
-        case EXTERNAL_PROPERTY:
-            return new AsExternalTypeDeserializer(baseType, idRes, property,
-                    _defaultImpl, _typeProperty);
-        }
-        throw new IllegalStateException("Do not know how to construct standard type serializer for inclusion type: "+_includeAs);
-    }
-    /*
-    /**********************************************************
-    /* Construction, configuration
-    /**********************************************************
-     */
-    @Override
-    public StdTypeResolverBuilder inclusion(JsonTypeInfo.As includeAs) {
-        if (includeAs == null) {
-            throw new IllegalArgumentException("includeAs can not be null");
-        }
-        _includeAs = includeAs;
-        return this;
-    }
-    /**
-     * Method for constructing an instance with specified type property name
-     * (property name to use for type id when using "as-property" inclusion).
-     */
-    @Override
-    public StdTypeResolverBuilder typeProperty(String typeIdPropName)
-    {
-        // ok to have null/empty; will restore to use defaults
-        if (typeIdPropName == null || typeIdPropName.length() == 0) {
-            typeIdPropName = _idType.getDefaultPropertyName();
-        }
-        _typeProperty = typeIdPropName;
-        return this;
-    }
-    @Override
-    public StdTypeResolverBuilder defaultImpl(Class<?> defaultImpl)
-    {
-        _defaultImpl = defaultImpl;
-        return this;
-    }
-    /*
-    /**********************************************************
-    /* Accessors
-    /**********************************************************
-     */
-    public String getTypeProperty() { return _typeProperty; }
-    /*
-    /**********************************************************
-    /* Internal methods
-    /**********************************************************
-     */
-    /**
-     * Helper method that will either return configured custom
-     * type id resolver, or construct a standard resolver
-     * given configuration.
-     */
-    protected TypeIdResolver idResolver(MapperConfig<?> config,
-            JavaType baseType, Collection<NamedType> subtypes,
-            boolean forSer, boolean forDeser)
-    {
-        // Custom id resolver?
-        if (_customIdResolver != null) {
-            return _customIdResolver;
-        }
-        if (_idType == null) {
-            throw new IllegalStateException("Can not build, 'init()' not yet called");
-        }
-        switch (_idType) {
-        case CLASS:
-            return new ClassNameIdResolver(baseType, config.getTypeFactory());
-        case MINIMAL_CLASS:
-            return new MinimalClassNameIdResolver(baseType, config.getTypeFactory());
-        case NAME:
-            return TypeNameIdResolver.construct(config, baseType, subtypes, forSer, forDeser);
-        case NONE: // hmmh. should never get this far with 'none'
-            return null;
-        case CUSTOM: // need custom resolver...
-        }
-        throw new IllegalStateException("Do not know how to construct standard type id resolver for idType: "+_idType);
-    }
-}

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

@@ -1,154 +0,0 @@
-package sh.calaba.org.codehaus.jackson.map.jsontype.impl;
-import java.io.IOException;
-import java.util.HashMap;
-import sh.calaba.org.codehaus.jackson.*;
-import sh.calaba.org.codehaus.jackson.annotate.JsonTypeInfo;
-import sh.calaba.org.codehaus.jackson.map.BeanProperty;
-import sh.calaba.org.codehaus.jackson.map.DeserializationContext;
-import sh.calaba.org.codehaus.jackson.map.JsonDeserializer;
-import sh.calaba.org.codehaus.jackson.map.TypeDeserializer;
-import sh.calaba.org.codehaus.jackson.map.jsontype.TypeIdResolver;
-import sh.calaba.org.codehaus.jackson.type.JavaType;
-/**
- * @since 1.5
- * @author tatus
- */
-public abstract class TypeDeserializerBase extends TypeDeserializer
-{
-    protected final TypeIdResolver _idResolver;
-    protected final JavaType _baseType;
-    protected final BeanProperty _property;
-    /**
-     * Type to use as the default implementation, if type id is
-     * missing or can not be resolved.
-     *
-     * @since 1.9
-     */
-    protected final JavaType _defaultImpl;
-    /**
-     * For efficient operation we will lazily build mappings from type ids
-     * to actual deserializers, once needed.
-     */
-    protected final HashMap<String,JsonDeserializer<Object>> _deserializers;
-    /**
-     * @since 1.9
-     */
-    protected JsonDeserializer<Object> _defaultImplDeserializer;
-    /**
-     * @deprecated Since 1.9, use the constructor that takes 'defaultImpl'
-     */
-    @Deprecated
-    protected TypeDeserializerBase(JavaType baseType, TypeIdResolver idRes, BeanProperty property) {
-        this(baseType, idRes, property, null);
-    }
-    protected TypeDeserializerBase(JavaType baseType, TypeIdResolver idRes, BeanProperty property,
-            Class<?> defaultImpl)
-    {
-        _baseType = baseType;
-        _idResolver = idRes;
-        _property = property;
-        _deserializers = new HashMap<String,JsonDeserializer<Object>>();
-        if (defaultImpl == null) {
-            _defaultImpl = null;
-        } else {
-            /* 16-Oct-2011, tatu: should call this via TypeFactory; this is
-             *    not entirely safe... however, since Collections/Maps are
-             *    seldom (if ever) base types, may be ok.
-             */
-            _defaultImpl = baseType.forcedNarrowBy(defaultImpl);
-        }
-    }
-    @Override
-    public abstract JsonTypeInfo.As getTypeInclusion();
-    public String baseTypeName() { return _baseType.getRawClass().getName(); }
-    @Override
-    public String getPropertyName() { return null; }
-    @Override
-    public TypeIdResolver getTypeIdResolver() { return _idResolver; }
-    @Override
-    public Class<?> getDefaultImpl() {
-        return (_defaultImpl == null) ? null : _defaultImpl.getRawClass();
-    }
-    @Override
-    public String toString()
-    {
-    	StringBuilder sb = new StringBuilder();
-    	sb.append('[').append(getClass().getName());
-    	sb.append("; base-type:").append(_baseType);
-    	sb.append("; id-resolver: ").append(_idResolver);
-    	sb.append(']');
-    	return sb.toString();
-    }
-    /*
-    /**********************************************************
-    /* Helper methods for sub-classes
-    /**********************************************************
-     */
-    protected final JsonDeserializer<Object> _findDeserializer(DeserializationContext ctxt, String typeId)
-        throws IOException, JsonProcessingException
-    {
-        JsonDeserializer<Object> deser;
-        synchronized (_deserializers) {
-            deser = _deserializers.get(typeId);
-            if (deser == null) {
-                JavaType type = _idResolver.typeFromId(typeId);
-                if (type == null) {
-                    // As per [JACKSON-614], use the default impl if no type id available:
-                    if (_defaultImpl == null) {
-                        throw ctxt.unknownTypeException(_baseType, typeId);
-                    }
-                    deser = _findDefaultImplDeserializer(ctxt);
-                } else {
-                    /* 16-Dec-2010, tatu: Since nominal type we get here has no (generic) type parameters,
-                     *   we actually now need to explicitly narrow from base type (which may have parameterization)
-                     *   using raw type.
-                     *
-                     *   One complication, though; can not change 'type class' (simple type to container); otherwise
-                     *   we may try to narrow a SimpleType (Object.class) into MapType (Map.class), losing actual
-                     *   type in process (getting SimpleType of Map.class which will not work as expected)
-                     */
-                    if (_baseType != null && _baseType.getClass() == type.getClass()) {
-                        type = _baseType.narrowBy(type.getRawClass());
-                    }
-                    deser = ctxt.getDeserializerProvider().findValueDeserializer(ctxt.getConfig(), type, _property);
-                }
-                _deserializers.put(typeId, deser);
-            }
-        }
-        return deser;
-    }
-    protected final JsonDeserializer<Object> _findDefaultImplDeserializer(DeserializationContext ctxt)
-        throws IOException, JsonProcessingException
-    {
-        if (_defaultImpl == null) {
-            return null;
-        }
-        synchronized (_defaultImpl) {
-            if (_defaultImplDeserializer == null) {
-                _defaultImplDeserializer = ctxt.getDeserializerProvider().findValueDeserializer(ctxt.getConfig(),
-                        _defaultImpl, _property);
-            }
-            return _defaultImplDeserializer;
-        }
-    }
-}

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

@@ -1,37 +0,0 @@
-package sh.calaba.org.codehaus.jackson.map.jsontype.impl;
-import sh.calaba.org.codehaus.jackson.map.jsontype.TypeIdResolver;
-import sh.calaba.org.codehaus.jackson.map.type.TypeFactory;
-import sh.calaba.org.codehaus.jackson.type.JavaType;
-public abstract class TypeIdResolverBase
-    implements TypeIdResolver
-{
-    protected final TypeFactory _typeFactory;
-    /**
-     * Common base type for all polymorphic instances handled.
-     */
-    protected final JavaType _baseType;
-    protected TypeIdResolverBase(JavaType baseType, TypeFactory typeFactory)
-    {
-        _baseType = baseType;
-        _typeFactory = typeFactory;
-    }
-    @Override
-    public void init(JavaType bt) {
-        /* Standard type id resolvers do not need this;
-         * only useful for custom ones.
-         */
-    }
-    /**
-     * @since 1.9.4
-     */
-    public String idFromBaseType()
-    {
-        return idFromValueAndType(null, _baseType.getRawClass());
-    }
-}

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

@@ -1,154 +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.MapperConfig;
-import sh.calaba.org.codehaus.jackson.map.introspect.BasicBeanDescription;
-import sh.calaba.org.codehaus.jackson.map.jsontype.NamedType;
-import sh.calaba.org.codehaus.jackson.type.JavaType;
-public class TypeNameIdResolver
-    extends TypeIdResolverBase
-{
-    /**
-     * @since 1.8
-     */
-    protected final MapperConfig<?> _config;
-    /**
-     * Mappings from class name to type id, used for serialization
-     */
-    protected final HashMap<String, String> _typeToId;
-    /**
-     * Mappings from type id to JavaType, used for deserialization
-     */
-    protected final HashMap<String, JavaType> _idToType;
-    protected TypeNameIdResolver(MapperConfig<?> config, JavaType baseType,
-            HashMap<String, String> typeToId, HashMap<String, JavaType> idToType)
-    {
-        super(baseType, config.getTypeFactory());
-        _config = config;
-        _typeToId = typeToId;
-        _idToType = idToType;
-    }
-    public static TypeNameIdResolver construct(MapperConfig<?> config,
-            JavaType baseType,
-            Collection<NamedType> subtypes, boolean forSer, boolean forDeser)
-    {
-        // sanity check
-        if (forSer == forDeser) throw new IllegalArgumentException();
-        HashMap<String, String> typeToId = null;
-        HashMap<String, JavaType> idToType = null;
-        if (forSer) {
-            typeToId = new HashMap<String, String>();
-        }
-        if (forDeser) {
-            idToType = new HashMap<String, JavaType>();
-        }
-        if (subtypes != null) {
-            for (NamedType t : subtypes) {
-                /* no name? Need to figure out default; for now, let's just
-                 * use non-qualified class name
-                 */
-                Class<?> cls = t.getType();
-                String id = t.hasName() ? t.getName() : _defaultTypeId(cls);
-                if (forSer) {
-                    typeToId.put(cls.getName(), id);
-                }
-                if (forDeser) {
-                    /* 24-Feb-2011, tatu: [JACKSON-498] One more problem; sometimes
-                     *   we have same name for multiple types; if so, use most specific
-                     *   one.
-                     */
-                    JavaType prev = idToType.get(id);
-                    if (prev != null) { // Can only override if more specific
-                        if (cls.isAssignableFrom(prev.getRawClass())) { // nope, more generic (or same)
-                            continue;
-                        }
-                    }
-                    idToType.put(id, config.constructType(cls));
-                }
-            }
-        }
-        return new TypeNameIdResolver(config, baseType, typeToId, idToType);
-    }
-    @Override
-    public JsonTypeInfo.Id getMechanism() { return JsonTypeInfo.Id.NAME; }
-    @Override
-    public String idFromValue(Object value)
-    {
-        Class<?> cls = value.getClass();
-        final String key = cls.getName();
-        String name;
-        synchronized (_typeToId) {
-            name = _typeToId.get(key);
-            if (name == null) {
-                // 24-Feb-2011, tatu: As per [JACKSON-498], may need to dynamically look up name
-                // can either throw an exception, or use default name...
-                if (_config.isAnnotationProcessingEnabled()) {
-                    BasicBeanDescription beanDesc = _config.introspectClassAnnotations(cls);
-                    name = _config.getAnnotationIntrospector().findTypeName(beanDesc.getClassInfo());
-                }
-                if (name == null) {
-                    // And if still not found, let's choose default?
-                    name = _defaultTypeId(cls);
-                }
-                _typeToId.put(key, name);
-            }
-        }
-        return name;
-    }
-    @Override
-    public String idFromValueAndType(Object value, Class<?> type)
-    {
-        return idFromValue(value);
-    }
-    @Override
-    public JavaType typeFromId(String id)
-        throws IllegalArgumentException
-    {
-        JavaType t = _idToType.get(id);
-        /* Now: if no type is found, should we try to locate it by
-         * some other means? (specifically, if in same package as base type,
-         * could just try Class.forName)
-         * For now let's not add any such workarounds; can add if need be
-         */
-        return t;
-    }
-    @Override
-    public String toString()
-    {
-    	StringBuilder sb = new StringBuilder();
-    	sb.append('[').append(getClass().getName());
-    	sb.append("; id-to-type=").append(_idToType);
-    	sb.append(']');
-    	return sb.toString();
-    }
-    /*
-    /*********************************************************
-    /* Helper methods
-    /*********************************************************
-     */
-    /**
-     * If no name was explicitly given for a class, we will just
-     * use non-qualified class name
-     */
-    protected static String _defaultTypeId(Class<?> cls)
-    {
-        String n = cls.getName();
-        int ix = n.lastIndexOf('.');
-        return (ix < 0) ? n : n.substring(ix+1);
-    }
-}