calabash-android 0.4.7.pre4 → 0.4.7.pre6

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

@@ -1,94 +0,0 @@
-package sh.calaba.org.codehaus.jackson.map.type;
-
-/**
- * Key class, used as an efficient and accurate key
- * for locating per-class values, such as
- * {@link sh.calaba.org.codehaus.jackson.map.JsonSerializer}s.
- *<p>
- * The reason for having a separate key class instead of
- * directly using {@link Class} as key is mostly
- * to allow for redefining <code>hashCode</code> method --
- * for some strange reason, {@link Class} does not
- * redefine {@link Object#hashCode} and thus uses identity
- * hash, which is pretty slow. This makes key access using
- * {@link Class} unnecessarily slow.
- *<p>
- * Note: since class is not strictly immutable, caller must
- * know what it is doing, if changing field values.
- */
-public final class ClassKey
-    implements Comparable<ClassKey>
-{
-    private String _className;
-
-    private Class<?> _class;
-
-    /**
-     * Let's cache hash code straight away, since we are
-     * almost certain to need it.
-     */
-    private int _hashCode;
-
-    public ClassKey() 
-    {
-        _class = null;
-        _className = null;
-        _hashCode = 0;
-    }
-
-    public ClassKey(Class<?> clz)
-    {
-        _class = clz;
-        _className = clz.getName();
-        _hashCode = _className.hashCode();
-    }
-
-    public void reset(Class<?> clz)
-    {
-        _class = clz;
-        _className = clz.getName();
-        _hashCode = _className.hashCode();
-    }
-
-    /*
-    /**********************************************************
-    /* Comparable
-    /**********************************************************
-     */
-
-    @Override
-    public int compareTo(ClassKey other)
-    {
-        // Just need to sort by name, ok to collide (unless used in TreeMap/Set!)
-        return _className.compareTo(other._className);
-    }
-
-    /*
-    /**********************************************************
-    /* Standard methods
-    /**********************************************************
-     */
-
-    @Override
-        public boolean equals(Object o)
-    {
-        if (o == this) return true;
-        if (o == null) return false;
-        if (o.getClass() != getClass()) return false;
-        ClassKey other = (ClassKey) o;
-
-        /* Is it possible to have different Class object for same name + class loader combo?
-         * Let's assume answer is no: if this is wrong, will need to uncomment following functionality
-         */
-        /*
-        return (other._className.equals(_className))
-            && (other._class.getClassLoader() == _class.getClassLoader());
-        */
-        return other._class == _class;
-    }
-
-    @Override public int hashCode() { return _hashCode; }
-
-    @Override public String toString() { return _className; }
-    
-}

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

@@ -1,204 +0,0 @@
-package sh.calaba.org.codehaus.jackson.map.type;
-
-import java.util.Collection;
-
-import sh.calaba.org.codehaus.jackson.type.JavaType;
-
-/**
- * Type that represents things that act similar to {@link java.util.Collection};
- * but may or may not be instances of that interface.
- * 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 CollectionLikeType extends TypeBase
-{
-    /**
-     * Type of elements in collection
-     */
-    protected final JavaType _elementType;
-
-    /*
-    /**********************************************************
-    /* Life-cycle
-    /**********************************************************
-     */
-
-    @Deprecated // since 1.9
-    protected CollectionLikeType(Class<?> collT, JavaType elemT)
-    {
-        super(collT,  elemT.hashCode(), null, null);
-        _elementType = elemT;
-    }
-
-    protected CollectionLikeType(Class<?> collT, JavaType elemT,
-            Object valueHandler, Object typeHandler)
-    {
-        super(collT, elemT.hashCode(), valueHandler, typeHandler);
-        _elementType = elemT;
-    }
-    
-    @Override
-    protected JavaType _narrow(Class<?> subclass) {
-        return new CollectionLikeType(subclass, _elementType,
-                _valueHandler, _typeHandler);
-    }
-
-    @Override
-    public JavaType narrowContentsBy(Class<?> contentClass)
-    {
-        // Can do a quick check first:
-        if (contentClass == _elementType.getRawClass()) {
-            return this;
-        }
-        return new CollectionLikeType(_class, _elementType.narrowBy(contentClass),
-                _valueHandler, _typeHandler);    }
-
-    @Override
-    public JavaType widenContentsBy(Class<?> contentClass)
-    {
-        // Can do a quick check first:
-        if (contentClass == _elementType.getRawClass()) {
-            return this;
-        }
-        return new CollectionLikeType(_class, _elementType.widenBy(contentClass),
-                _valueHandler, _typeHandler);
-    }
-    
-    public static CollectionLikeType construct(Class<?> rawType, JavaType elemT)
-    {
-        // nominally component types will be just Object.class
-        return new CollectionLikeType(rawType, elemT, null, null);
-    }
-
-    // Since 1.7:
-    @Override
-    public CollectionLikeType withTypeHandler(Object h)
-    {
-        return new CollectionLikeType(_class, _elementType, _valueHandler, h);
-    }
-
-    // Since 1.7:
-    @Override
-    public CollectionLikeType withContentTypeHandler(Object h)
-    {
-        return new CollectionLikeType(_class, _elementType.withTypeHandler(h),
-                _valueHandler, _typeHandler);
-    }
-
-    // Since 1.9:
-    @Override
-    public CollectionLikeType withValueHandler(Object h) {
-        return new CollectionLikeType(_class, _elementType, h, _typeHandler);
-    }
-
-    // Since 1.9:
-    @Override
-    public CollectionLikeType withContentValueHandler(Object h) {
-        return new CollectionLikeType(_class, _elementType.withValueHandler(h),
-                _valueHandler, _typeHandler);
-    }
-    
-    /*
-    /**********************************************************
-    /* Public API
-    /**********************************************************
-     */
-
-    @Override
-    public boolean isContainerType() { return true; }
-
-    @Override
-    public boolean isCollectionLikeType() { return true; }
-    
-    @Override
-    public JavaType getContentType() { return _elementType; }
-
-    @Override
-    public int containedTypeCount() { return 1; }
-
-    @Override
-    public JavaType containedType(int index) {
-            return (index == 0) ? _elementType : null;
-    }
-
-    /**
-     * Not sure if we should count on this, but type names
-     * for core interfaces use "E" for element type
-     */
-    @Override
-    public String containedTypeName(int index) {
-        if (index == 0) return "E";
-        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('<');
-        _elementType.getGenericSignature(sb);
-        sb.append(">;");
-        return sb;
-    }
-    
-    @Override
-    protected String buildCanonicalName() {
-        StringBuilder sb = new StringBuilder();
-        sb.append(_class.getName());
-        if (_elementType != null) {
-            sb.append('<');
-            sb.append(_elementType.toCanonical());
-            sb.append('>');
-        }
-        return sb.toString();
-    }
-
-    /*
-    /**********************************************************
-    /* Extended API
-    /**********************************************************
-     */
-
-    /**
-     * 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 isTrueCollectionType() {
-        return Collection.class.isAssignableFrom(_class);
-    }
-
-    /*
-    /**********************************************************
-    /* Standard methods
-    /**********************************************************
-     */
-
-    @Override
-    public boolean equals(Object o)
-    {
-        if (o == this) return true;
-        if (o == null) return false;
-        if (o.getClass() != getClass()) return false;
-
-        CollectionLikeType other = (CollectionLikeType) o;
-        return  (_class == other._class) && _elementType.equals(other._elementType);
-    }
-
-    @Override
-    public String toString()
-    {
-        return "[collection-like type; class "+_class.getName()+", contains "+_elementType+"]";
-    }
-
-}

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

@@ -1,94 +0,0 @@
-package sh.calaba.org.codehaus.jackson.map.type;
-
-import sh.calaba.org.codehaus.jackson.type.JavaType;
-
-/**
- * Type that represents Java Collection types (Lists, Sets).
- */
-public final class CollectionType
-    extends CollectionLikeType
-{
-    /*
-    /**********************************************************
-    /* Life-cycle
-    /**********************************************************
-     */
-
-    private CollectionType(Class<?> collT, JavaType elemT,
-            Object valueHandler, Object typeHandler)
-    {
-        super(collT,  elemT, valueHandler, typeHandler);
-    }
-
-    @Override
-    protected JavaType _narrow(Class<?> subclass) {
-        return new CollectionType(subclass, _elementType, null, null);
-    }
-
-    @Override
-    public JavaType narrowContentsBy(Class<?> contentClass)
-    {
-        // Can do a quick check first:
-        if (contentClass == _elementType.getRawClass()) {
-            return this;
-        }
-        return new CollectionType(_class, _elementType.narrowBy(contentClass),
-                _valueHandler, _typeHandler);
-    }
-
-    @Override
-    public JavaType widenContentsBy(Class<?> contentClass)
-    {
-        // Can do a quick check first:
-        if (contentClass == _elementType.getRawClass()) {
-            return this;
-        }
-        return new CollectionType(_class, _elementType.widenBy(contentClass),
-                _valueHandler, _typeHandler);
-    }
-    
-    public static CollectionType construct(Class<?> rawType, JavaType elemT)
-    {
-        // nominally component types will be just Object.class
-        return new CollectionType(rawType, elemT, null, null);
-    }
-
-    // Since 1.7:
-    @Override
-    public CollectionType withTypeHandler(Object h) {
-        return new CollectionType(_class, _elementType, _valueHandler, h);
-    }
-
-    // Since 1.7:
-    @Override
-    public CollectionType withContentTypeHandler(Object h)
-    {
-        return new CollectionType(_class, _elementType.withTypeHandler(h),
-                _valueHandler, _typeHandler);
-    }
-
-    // Since 1.9:
-    @Override
-    public CollectionType withValueHandler(Object h) {
-        return new CollectionType(_class, _elementType, h, _typeHandler);
-    }
-
-    // Since 1.9:
-    @Override
-    public  CollectionType withContentValueHandler(Object h) {
-        return new CollectionType(_class, _elementType.withValueHandler(h),
-                _valueHandler, _typeHandler);
-    }
-    
-    /*
-    /**********************************************************
-    /* Standard methods
-    /**********************************************************
-     */
-
-    @Override
-    public String toString()
-    {
-        return "[collection type; class "+_class.getName()+", contains "+_elementType+"]";
-    }
-}

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

@@ -1,88 +0,0 @@
-package sh.calaba.org.codehaus.jackson.map.type;
-
-import java.lang.reflect.*;
-
-/**
- * Simple replacement for {@link java.lang.Class} (and/or various Type subtypes)
- * that is used as part of single-path extends/implements chain to express
- * specific relationship between one subtype and one supertype. This is needed
- * for resolving type parameters. Instances are doubly-linked so that chain
- * can be traversed in both directions
- * 
- * @since 1.6
- */
-public class HierarchicType
-{
-    /**
-     * Type which will be either plain {@link java.lang.Class} or
-     * {@link java.lang.reflect.ParameterizedType}.
-     */
-    protected final Type _actualType;
-    
-    protected final Class<?> _rawClass;
-
-    protected final ParameterizedType _genericType;
-    
-    protected HierarchicType _superType;
-
-    protected HierarchicType _subType;
-    
-    public HierarchicType(Type type)
-    {
-        this._actualType = type;
-        if (type instanceof Class<?>) {
-            _rawClass = (Class<?>) type;
-            _genericType = null;
-        } else if (type instanceof ParameterizedType) {
-            _genericType = (ParameterizedType) type;
-            _rawClass = (Class<?>) _genericType.getRawType();
-        } else { // should never happen... can't extend GenericArrayType?
-            throw new IllegalArgumentException("Type "+type.getClass().getName()+" can not be used to construct HierarchicType");
-        }
-    }
-
-    private HierarchicType(Type actualType, Class<?> rawClass, ParameterizedType genericType,
-        HierarchicType superType, HierarchicType subType)
-    {
-        _actualType = actualType;
-        _rawClass = rawClass;
-        _genericType = genericType;
-        _superType = superType;
-        _subType = subType;
-    }
-    
-    /**
-     * Method that can be used to create a deep clone of this hierarchic type, including
-     * super types (but not subtypes)
-     * 
-     * @since 1.9
-     */
-    public HierarchicType deepCloneWithoutSubtype()
-    {
-        HierarchicType sup = (_superType == null) ? null : _superType.deepCloneWithoutSubtype();
-        HierarchicType result = new HierarchicType(_actualType, _rawClass, _genericType, sup, null);
-        if (sup != null) {
-            sup.setSubType(result);
-        }
-        return result;
-    }
-    
-    public void setSuperType(HierarchicType sup) { _superType = sup; }
-    public final HierarchicType getSuperType() { return _superType; }
-    public void setSubType(HierarchicType sub) { _subType = sub; }
-    public final HierarchicType getSubType() { return _subType; }
-    
-    public final boolean isGeneric() { return _genericType != null; }
-    public final ParameterizedType asGeneric() { return _genericType; }
-
-    public final Class<?> getRawClass() { return _rawClass; }
-    
-    @Override
-    public String toString() {
-        if (_genericType != null) {
-            return _genericType.toString();
-        }
-        return _rawClass.getName();
-    }
-    
-}