calabash-android 0.4.7.pre6 → 0.4.7.pre7

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

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

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

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

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