testautoa 0.4.0.pre16

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

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

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

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

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);
+    }
+    
+}