calabash-android 0.4.7.pre6 → 0.4.7.pre7

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

@@ -0,0 +1,265 @@
+package sh.calaba.org.codehaus.jackson.map.type;
+
+import java.util.*;
+
+import sh.calaba.org.codehaus.jackson.type.JavaType;
+
+/**
+ * Type that represents Map-like types; things that consist of key/value pairs but that
+ * do not necessarily implement {@link java.util.Map}, but that do not have enough
+ * introspection functionality to allow for some level of generic handling.
+ * This specifically allows framework to check for configuration and annotation
+ * settings used for Map types, and pass these to custom handlers that may be more
+ * familiar with actual type.
+ *
+ * @since 1.8
+ */
+public class MapLikeType extends TypeBase
+{
+    /**
+     * Type of keys of Map.
+     */
+    protected final JavaType _keyType;
+
+    /**
+     * Type of values of Map.
+     */
+    protected final JavaType _valueType;
+
+    /*
+    /**********************************************************
+    /* Life-cycle
+    /**********************************************************
+     */
+
+    @Deprecated // since 1.9
+    protected MapLikeType(Class<?> mapType, JavaType keyT, JavaType valueT)
+    {
+        super(mapType, keyT.hashCode() ^ valueT.hashCode(), null, null);
+        _keyType = keyT;
+        _valueType = valueT;
+    }
+
+    protected MapLikeType(Class<?> mapType, JavaType keyT, JavaType valueT,
+            Object valueHandler, Object typeHandler)
+    {
+        super(mapType, keyT.hashCode() ^ valueT.hashCode(), valueHandler, typeHandler);
+        _keyType = keyT;
+        _valueType = valueT;
+    }
+    
+    public static MapLikeType construct(Class<?> rawType, JavaType keyT, JavaType valueT)
+    {
+        // nominally component types will be just Object.class
+        return new MapLikeType(rawType, keyT, valueT, null, null);
+    }
+
+    @Override
+    protected JavaType _narrow(Class<?> subclass)
+    {
+        return new MapLikeType(subclass, _keyType, _valueType, _valueHandler, _typeHandler);
+    }
+
+    @Override
+    public JavaType narrowContentsBy(Class<?> contentClass)
+    {
+        // Can do a quick check first:
+        if (contentClass == _valueType.getRawClass()) {
+            return this;
+        }
+        return new MapLikeType(_class, _keyType, _valueType.narrowBy(contentClass),
+               _valueHandler, _typeHandler);
+    }
+
+    @Override
+    public JavaType widenContentsBy(Class<?> contentClass)
+    {
+        if (contentClass == _valueType.getRawClass()) {
+            return this;
+        }
+        return new MapLikeType(_class, _keyType, _valueType.widenBy(contentClass),
+                _valueHandler, _typeHandler);
+    }
+    
+    public JavaType narrowKey(Class<?> keySubclass)
+    {
+        // Can do a quick check first:
+        if (keySubclass == _keyType.getRawClass()) {
+            return this;
+        }
+        return new MapLikeType(_class, _keyType.narrowBy(keySubclass), _valueType,
+                _valueHandler, _typeHandler);
+    }
+
+    /**
+     * @since 1.8
+     */
+    public JavaType widenKey(Class<?> keySubclass)
+    {
+        // Can do a quick check first:
+        if (keySubclass == _keyType.getRawClass()) {
+            return this;
+        }
+        return new MapLikeType(_class, _keyType.widenBy(keySubclass), _valueType,
+                _valueHandler, _typeHandler);
+    }
+    
+    // Since 1.7:
+    @Override
+    public MapLikeType withTypeHandler(Object h)
+    {
+        return new MapLikeType(_class, _keyType, _valueType, _valueHandler, h);
+    }
+
+    // Since 1.7:
+    @Override
+    public MapLikeType withContentTypeHandler(Object h)
+    {
+        return new MapLikeType(_class, _keyType, _valueType.withTypeHandler(h),
+                _valueHandler, _typeHandler);
+    }
+
+    // Since 1.9:
+    @Override
+    public MapLikeType withValueHandler(Object h) {
+        return new MapLikeType(_class, _keyType, _valueType, h, _typeHandler);
+    }
+
+    // Since 1.9:
+    @Override
+    public MapLikeType withContentValueHandler(Object h) {
+        return new MapLikeType(_class, _keyType, _valueType.withValueHandler(h),
+                _valueHandler, _typeHandler);
+    }
+    
+    @Override
+    protected String buildCanonicalName() {
+        StringBuilder sb = new StringBuilder();
+        sb.append(_class.getName());
+        if (_keyType != null) {
+            sb.append('<');
+            sb.append(_keyType.toCanonical());
+            sb.append(',');
+            sb.append(_valueType.toCanonical());
+            sb.append('>');
+        }
+        return sb.toString();
+    }
+ 
+    /*
+    /**********************************************************
+    /* Public API
+    /**********************************************************
+     */
+
+    @Override
+    public boolean isContainerType() { return true; }
+
+    @Override
+    public boolean isMapLikeType() { return true; }
+    
+    @Override
+    public JavaType getKeyType() { return _keyType; }
+
+    @Override
+    public JavaType getContentType() { return _valueType; }
+
+    @Override
+    public int containedTypeCount() { return 2; }
+    
+    @Override
+    public JavaType containedType(int index) {
+        if (index == 0) return _keyType;
+        if (index == 1) return _valueType;
+        return null;
+    }
+
+    /**
+     * Not sure if we should count on this, but type names
+     * for core interfaces are "K" and "V" respectively.
+     * For now let's assume this should work.
+     */
+    @Override
+    public String containedTypeName(int index) {
+        if (index == 0) return "K";
+        if (index == 1) return "V";
+        return null;
+    }
+
+    @Override
+    public StringBuilder getErasedSignature(StringBuilder sb) {
+        return _classSignature(_class, sb, true);
+    }
+    
+    @Override
+    public StringBuilder getGenericSignature(StringBuilder sb)
+    {
+        _classSignature(_class, sb, false);
+        sb.append('<');
+        _keyType.getGenericSignature(sb);
+        _valueType.getGenericSignature(sb);
+        sb.append(">;");
+        return sb;
+    }
+ 
+    /*
+    /**********************************************************
+    /* Extended API
+    /**********************************************************
+     */
+
+    /**
+     * @since 1.9
+     */
+    public MapLikeType withKeyTypeHandler(Object h)
+    {
+        return new MapLikeType(_class, _keyType.withTypeHandler(h), _valueType,
+                _valueHandler, _typeHandler);
+    }
+
+    /**
+     * @since 1.9
+     */
+    public MapLikeType withKeyValueHandler(Object h) {
+        return new MapLikeType(_class, _keyType.withValueHandler(h), _valueType,
+                _valueHandler, _typeHandler);
+    }
+    
+    /**
+     * Method that can be used for checking whether this type is a
+     * "real" Collection type; meaning whether it represents a parameterized
+     * subtype of {@link java.util.Collection} or just something that acts
+     * like one.
+     * 
+     * @since 1.8
+     */
+    public boolean isTrueMapType() {
+        return Map.class.isAssignableFrom(_class);
+    }
+
+    /*
+    /**********************************************************
+    /* Standard methods
+    /**********************************************************
+     */
+
+    @Override
+    public String toString()
+    {
+        return "[map-like type; class "+_class.getName()+", "+_keyType+" -> "+_valueType+"]";
+    }
+    
+    @Override
+    public boolean equals(Object o)
+    {
+        if (o == this) return true;
+        if (o == null) return false;
+        if (o.getClass() != getClass()) return false;
+
+        MapLikeType other = (MapLikeType) o;
+        return (_class == other._class)
+            && _keyType.equals(other._keyType)
+            && _valueType.equals(other._valueType);
+    }
+    
+}

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

@@ -0,0 +1,146 @@
+package sh.calaba.org.codehaus.jackson.map.type;
+
+import sh.calaba.org.codehaus.jackson.type.JavaType;
+
+/**
+ * Type that represents "true" Java Map types.
+ */
+public final class MapType extends MapLikeType
+{
+    /*
+    /**********************************************************
+    /* Life-cycle
+    /**********************************************************
+     */
+
+    @Deprecated
+    private MapType(Class<?> mapType, JavaType keyT, JavaType valueT) {
+        this(mapType, keyT, valueT, null, null);
+    }
+
+    private MapType(Class<?> mapType, JavaType keyT, JavaType valueT,
+            Object valueHandler, Object typeHandler) {
+        super(mapType, keyT, valueT, valueHandler, typeHandler);
+    }
+    
+    public static MapType construct(Class<?> rawType, JavaType keyT, JavaType valueT) {
+        // nominally component types will be just Object.class
+        return new MapType(rawType, keyT, valueT, null, null);
+    }
+
+    @Override
+    protected JavaType _narrow(Class<?> subclass) {
+        return new MapType(subclass, _keyType, _valueType,
+                _valueHandler, _typeHandler);
+    }
+
+    @Override
+    public JavaType narrowContentsBy(Class<?> contentClass)
+    {
+        // Can do a quick check first:
+        if (contentClass == _valueType.getRawClass()) {
+            return this;
+        }
+        return new MapType(_class, _keyType, _valueType.narrowBy(contentClass),
+                _valueHandler, _typeHandler);
+    }
+
+    @Override
+    public JavaType widenContentsBy(Class<?> contentClass)
+    {
+        if (contentClass == _valueType.getRawClass()) {
+            return this;
+        }
+        return new MapType(_class, _keyType, _valueType.widenBy(contentClass),
+                _valueHandler, _typeHandler);
+    }
+    
+    @Override
+    public JavaType narrowKey(Class<?> keySubclass)
+    {
+        // Can do a quick check first:
+        if (keySubclass == _keyType.getRawClass()) {
+            return this;
+        }
+        return new MapType(_class, _keyType.narrowBy(keySubclass), _valueType,
+                _valueHandler, _typeHandler);
+    }
+
+    /**
+     * @since 1.8
+     */
+    @Override
+    public JavaType widenKey(Class<?> keySubclass)
+    {
+        // Can do a quick check first:
+        if (keySubclass == _keyType.getRawClass()) {
+            return this;
+        }
+        return new MapType(_class, _keyType.widenBy(keySubclass), _valueType,
+                _valueHandler, _typeHandler);
+    }
+    
+    // Since 1.7:
+    @Override
+    public MapType withTypeHandler(Object h) {
+        return new MapType(_class, _keyType, _valueType, _valueHandler, h);
+    }
+
+    // Since 1.7:
+    @Override
+    public MapType withContentTypeHandler(Object h)
+    {
+        return new MapType(_class, _keyType, _valueType.withTypeHandler(h),
+                _valueHandler, _typeHandler);
+    }
+    
+    // Since 1.9:
+    @Override
+    public MapType withValueHandler(Object h) {
+        return new MapType(_class, _keyType, _valueType, h, _typeHandler);
+    }
+
+    // Since 1.9:
+    @Override
+    public MapType withContentValueHandler(Object h) {
+        return new MapType(_class, _keyType, _valueType.withValueHandler(h),
+                _valueHandler, _typeHandler);
+    }
+
+    /*
+    /**********************************************************
+    /* Extended API
+    /**********************************************************
+     */
+    
+    /**
+     * @since 1.9
+     */
+    @Override
+    public MapType withKeyTypeHandler(Object h)
+    {
+        return new MapType(_class, _keyType.withTypeHandler(h), _valueType,
+                _valueHandler, _typeHandler);
+    }
+
+    /**
+     * @since 1.9
+     */
+    @Override
+    public MapType withKeyValueHandler(Object h) {
+        return new MapType(_class, _keyType.withValueHandler(h), _valueType,
+                _valueHandler, _typeHandler);
+    }
+    
+    /*
+    /**********************************************************
+    /* Standard methods
+    /**********************************************************
+     */
+
+    @Override
+    public String toString()
+    {
+        return "[map type; class "+_class.getName()+", "+_keyType+" -> "+_valueType+"]";
+    }
+}

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

@@ -0,0 +1,250 @@
+package sh.calaba.org.codehaus.jackson.map.type;
+
+import java.util.*;
+
+import sh.calaba.org.codehaus.jackson.type.JavaType;
+
+/**
+ * Simple types are defined as anything other than one of recognized
+ * container types (arrays, Collections, Maps). For our needs we
+ * need not know anything further, since we have no way of dealing
+ * with generic types other than Collections and Maps.
+ */
+public final class SimpleType
+    extends TypeBase
+{
+    /**
+     * Generic type arguments for this type.
+     */
+    protected final JavaType[] _typeParameters;
+
+    /**
+     * Names of generic type arguments for this type; will
+     * match values in {@link #_typeParameters}
+     */
+    protected final String[] _typeNames;
+    
+    /*
+    /**********************************************************
+    /* Life-cycle
+    /**********************************************************
+     */
+
+    protected SimpleType(Class<?> cls) {
+        this(cls, null, null, null, null);
+    }
+
+    @Deprecated // since 1.9
+    protected SimpleType(Class<?> cls, String[] typeNames, JavaType[] typeParams)
+    {
+        this(cls, typeNames, typeParams, null, null);
+    }
+
+    protected SimpleType(Class<?> cls, String[] typeNames, JavaType[] typeParams,
+            Object valueHandler, Object typeHandler)
+    {
+        super(cls, 0, valueHandler, typeHandler);
+        if (typeNames == null || typeNames.length == 0) {
+            _typeNames = null;
+            _typeParameters = null;
+        } else {
+            _typeNames = typeNames;
+            _typeParameters = typeParams;
+        }
+    }
+
+    /**
+     * Method used by core Jackson classes: NOT to be used by application code.
+     *<p>
+     * NOTE: public only because it is called by <code>ObjectMapper</code> which is
+     * not in same package
+     */
+    public static SimpleType constructUnsafe(Class<?> raw) {
+        return new SimpleType(raw, null, null, null, null);
+    }
+    
+    @Override
+    protected JavaType _narrow(Class<?> subclass)
+    {
+        // Should we check that there is a sub-class relationship?
+        return new SimpleType(subclass, _typeNames, _typeParameters, _valueHandler, _typeHandler);
+    }
+
+    @Override
+    public JavaType narrowContentsBy(Class<?> subclass)
+    {
+        // should never get called
+        throw new IllegalArgumentException("Internal error: SimpleType.narrowContentsBy() should never be called");
+    }
+
+    @Override
+    public JavaType widenContentsBy(Class<?> subclass)
+    {
+        // should never get called
+        throw new IllegalArgumentException("Internal error: SimpleType.widenContentsBy() should never be called");
+    }
+    
+    public static SimpleType construct(Class<?> cls)
+    {
+        /* Let's add sanity checks, just to ensure no
+         * Map/Collection entries are constructed
+         */
+        if (Map.class.isAssignableFrom(cls)) {
+            throw new IllegalArgumentException("Can not construct SimpleType for a Map (class: "+cls.getName()+")");
+        }
+        if (Collection.class.isAssignableFrom(cls)) {
+            throw new IllegalArgumentException("Can not construct SimpleType for a Collection (class: "+cls.getName()+")");
+        }
+        // ... and while we are at it, not array types either
+        if (cls.isArray()) {
+            throw new IllegalArgumentException("Can not construct SimpleType for an array (class: "+cls.getName()+")");
+        }
+        return new SimpleType(cls);
+    }
+
+    // Since 1.7:
+    @Override
+    public SimpleType withTypeHandler(Object h)
+    {
+        return new SimpleType(_class, _typeNames, _typeParameters, _valueHandler, h);
+    }
+
+    // Since 1.7:
+    @Override
+    public JavaType withContentTypeHandler(Object h) {
+        // no content type, so:
+        throw new IllegalArgumentException("Simple types have no content types; can not call withContenTypeHandler()");
+    }
+
+    // Since 1.9:
+    @Override
+    public SimpleType withValueHandler(Object h) {
+        if (h == _valueHandler) {
+            return this;
+        }
+        return new SimpleType(_class, _typeNames, _typeParameters, h, _typeHandler);
+    }
+    
+    // Since 1.9:
+    @Override
+    public  SimpleType withContentValueHandler(Object h) {
+        // no content type, so:
+        throw new IllegalArgumentException("Simple types have no content types; can not call withContenValueHandler()");
+    }
+    
+    @Override
+    protected String buildCanonicalName()
+    {
+        StringBuilder sb = new StringBuilder();
+        sb.append(_class.getName());
+        if (_typeParameters != null && _typeParameters.length > 0) {
+            sb.append('<');
+            boolean first = true;
+            for (JavaType t : _typeParameters) {
+                if (first) {
+                    first = false;
+                } else {
+                    sb.append(',');
+                }
+                sb.append(t.toCanonical());
+            }
+            sb.append('>');
+        }
+        return sb.toString();
+    }
+    
+    /*
+    /**********************************************************
+    /* Public API
+    /**********************************************************
+     */
+
+    @Override
+    public boolean isContainerType() { return false; }
+    
+    @Override
+    public int containedTypeCount() {
+        return (_typeParameters == null) ? 0 : _typeParameters.length;
+    }
+
+    @Override
+    public JavaType containedType(int index)
+    {
+        if (index < 0 || _typeParameters == null || index >= _typeParameters.length) {
+            return null;
+        }
+        return _typeParameters[index];
+    }
+
+    @Override
+    public String containedTypeName(int index)
+    {
+        if (index < 0 || _typeNames == null || index >= _typeNames.length) {
+            return null;
+        }
+        return _typeNames[index];
+    }
+    
+    @Override
+    public StringBuilder getErasedSignature(StringBuilder sb) {
+        return _classSignature(_class, sb, true);
+    }
+    
+    @Override
+    public StringBuilder getGenericSignature(StringBuilder sb)
+    {
+        _classSignature(_class, sb, false);
+        if (_typeParameters != null) {
+            sb.append('<');
+            for (JavaType param : _typeParameters) {
+                sb = param.getGenericSignature(sb);
+            }
+            sb.append('>');
+        }
+        sb.append(';');
+        return sb;
+    }
+    
+    /*
+    /**********************************************************
+    /* Standard methods
+    /**********************************************************
+     */
+
+    @Override
+    public String toString()
+    {
+        StringBuilder sb = new StringBuilder(40);
+        sb.append("[simple type, class ").append(buildCanonicalName()).append(']');
+        return sb.toString();
+    }
+
+    @Override
+    public boolean equals(Object o)
+    {
+        if (o == this) return true;
+        if (o == null) return false;
+        if (o.getClass() != getClass()) return false;
+
+        SimpleType other = (SimpleType) o;
+
+        // Classes must be identical... 
+        if (other._class != this._class) return false;
+
+        // And finally, generic bindings, if any
+        JavaType[] p1 = _typeParameters;
+        JavaType[] p2 = other._typeParameters;
+        if (p1 == null) {
+            return (p2 == null) || p2.length == 0;
+        }
+        if (p2 == null) return false;
+
+        if (p1.length != p2.length) return false;
+        for (int i = 0, len = p1.length; i < len; ++i) {
+            if (!p1[i].equals(p2[i])) {
+                return false;
+            }
+        }
+        return true;
+    }
+}