add wildcards support

add types repackaging to properly resolve complex generics cases
add type generic access methods by generic name
add ability to control descriptors cache

Author: xvik

CHANGELOG.md

@@ -1,3 +1,8 @@
+* Add wildcards support
+* Improve complex generics resolution
+* Add access by generic name methods in GenericsContext
+* Add ability to disable cache using property and method to clear current cache
+
 ### 1.0.0 (2014-11-19)
 
 * Initial release

src/main/java/ru/vyarus/java/generics/resolver/context/GenericsContext.java

@@ -104,6 +104,20 @@ public Type genericType(final int position) {
         return genericTypes().get(position);
     }
 
+    /**
+     * {@code class B<T, K>}.
+     * <pre>{@code class A extends B<Object, C<Long>>
+     * type(B.class).genericType("K") == ParametrizedType }</pre>
+     *
+     * @param genericName generic position (from 0)
+     * @return generic type
+     * @throws java.lang.IllegalArgumentException for wrong generic name
+     * @see #genericTypes() for details
+     */
+    public Type genericType(final String genericName) {
+        return typeGenerics.get(checkGenericName(genericName));
+    }
+
     /**
      * {@code class A extends B<Object, C<Long>>}.
      * <pre>{@code type(B.class).generic(1) == C.class }</pre>
@@ -117,6 +131,20 @@ public Class<?> generic(final int position) {
         return resolveClass(genericTypes().get(position));
     }
 
+    /**
+     * {@code class B<T, K>}.
+     * <pre>{@code class A extends B<Object, C<Long>>
+     * type(B.class).generic("K") == C.class }</pre>
+     *
+     * @param genericName generic name
+     * @return resolved generic class
+     * @throws java.lang.IllegalArgumentException for wrong generic name
+     * @see #resolveClass(java.lang.reflect.Type)
+     */
+    public Class<?> generic(final String genericName) {
+        return resolveClass(typeGenerics.get(checkGenericName(genericName)));
+    }
+
     /**
      * {@code class A extends B<Object, C<Long>>}.
      * <pre>{@code type(B.class).genericAsString(1) == "C<Long>" }</pre>
@@ -130,6 +158,20 @@ public String genericAsString(final int position) {
         return toStringType(genericType(position));
     }
 
+    /**
+     * {@code class B<T, K>}.
+     * <pre>{@code class A extends B<Object, C<Long>>
+     * type(B.class).genericAsString("K") == "C<Long>" }</pre>
+     *
+     * @param genericName generic name
+     * @return resolved generic string representation
+     * @throws java.lang.IllegalArgumentException for wrong generic name
+     * @see #toStringType(java.lang.reflect.Type)
+     */
+    public String genericAsString(final String genericName) {
+        return toStringType(typeGenerics.get(checkGenericName(genericName)));
+    }
+
     /**
      * {@code class A extends B<Object, C<Long>>} and {@code class B<T, K>}.
      * <pre>{@code type(B.class).genericsMap() == ["T": Object.class, "K": ParametrizedType]}</pre>
@@ -254,4 +296,12 @@ public String toStringType(final Type type) {
     public GenericsContext type(final Class<?> type) {
         return new GenericsContext(genericsInfo, type);
     }
+
+    private String checkGenericName(final String genericName) {
+        if (!typeGenerics.containsKey(genericName)) {
+            throw new IllegalArgumentException(String.format("Type %s doesn't contain generic with name '%s'",
+                    currentType.getName(), genericName));
+        }
+        return genericName;
+    }
 }

src/main/java/ru/vyarus/java/generics/resolver/context/GenericsInfoFactory.java

@@ -1,27 +1,33 @@
 package ru.vyarus.java.generics.resolver.context;
 
-import java.lang.reflect.ParameterizedType;
-import java.lang.reflect.Type;
-import java.lang.reflect.TypeVariable;
-import java.util.*;
+import ru.vyarus.java.generics.resolver.util.GenericInfoUtils;
+
+import java.util.Map;
+import java.util.WeakHashMap;
 import java.util.concurrent.locks.ReentrantLock;
 
 /**
  * Analyze class hierarchy and produce class hierarchy resolved generics object.
  * Resolved generics descriptors are cached.
  * <p>Note: when ignore classes used, cache will not work: such descriptors are always resolved.</p>
+ * <p>Cache may be disabled (e.g. when JRebel used) by using environment variable or system property e.g.:
+ * {@code System.setProperty(GenericsInfoFactory.CACHE_PROPERTY, 'false')}.
+ * Property value checked on cache write. To clear current cache state use static method.</p>
  *
  * @author Vyacheslav Rusakov
  * @since 16.10.2014
  */
 public final class GenericsInfoFactory {
 
+    /**
+     * System property or environment variable name to disable cache.
+     * If value is 'false' - cache disabled, otherwise cache enabled.
+     */
+    public static final String CACHE_PROPERTY = GenericsInfoFactory.class.getName() + ".cache";
+
     private static final Map<Class<?>, GenericsInfo> CACHE = new WeakHashMap<Class<?>, GenericsInfo>();
     // lock will not affect performance for cached descriptors, just to make sure nothing was build two times
     private static final ReentrantLock LOCK = new ReentrantLock();
-    @SuppressWarnings("PMD.LooseCoupling")
-    private static final LinkedHashMap<String, Type> EMPTY_MAP = new LinkedHashMap<String, Type>(0);
-    private static final String GROOVY_OBJECT = "GroovyObject";
 
     private GenericsInfoFactory() {
     }
@@ -35,20 +41,23 @@ private GenericsInfoFactory() {
      * @return descriptor for class hierarchy generics substitution
      */
     public static GenericsInfo create(final Class<?> type, final Class<?>... ignoreClasses) {
-        GenericsInfo descriptor = ignoreClasses.length > 0 ? buildDescriptor(type, ignoreClasses) : CACHE.get(type);
+        GenericsInfo descriptor = ignoreClasses.length > 0
+                ? GenericInfoUtils.create(type, ignoreClasses) : CACHE.get(type);
         if (descriptor == null) {
             LOCK.lock();
             try {
                 if (CACHE.get(type) != null) {
                     // descriptor could be created while thread wait for lock
                     descriptor = CACHE.get(type);
                 } else {
-                    descriptor = buildDescriptor(type);
-                    // internal check
-                    if (CACHE.get(type) != null) {
-                        throw new IllegalStateException("Bad concurrency: descriptor already present in cache");
+                    descriptor = GenericInfoUtils.create(type);
+                    if (isCacheEnabled()) {
+                        // internal check
+                        if (CACHE.get(type) != null) {
+                            throw new IllegalStateException("Bad concurrency: descriptor already present in cache");
+                        }
+                        CACHE.put(type, descriptor);
                     }
-                    CACHE.put(type, descriptor);
                 }
             } finally {
                 LOCK.unlock();
@@ -57,89 +66,34 @@ public static GenericsInfo create(final Class<?> type, final Class<?>... ignoreC
         return descriptor;
     }
 
-    private static GenericsInfo buildDescriptor(final Class<?> type, final Class<?>... ignoreClasses) {
-        final Map<Class<?>, LinkedHashMap<String, Type>> generics =
-                new HashMap<Class<?>, LinkedHashMap<String, Type>>();
-        analyzeType(generics, type, Arrays.asList(ignoreClasses));
-        return new GenericsInfo(type, generics);
-    }
-
-    private static void analyzeType(final Map<Class<?>, LinkedHashMap<String, Type>> types, final Class<?> type,
-                                    final List<Class<?>> ignoreClasses) {
-        Class<?> supertype = type;
-        while (true) {
-            for (Type iface : supertype.getGenericInterfaces()) {
-                analyzeInterface(types, iface, supertype, ignoreClasses);
-            }
-            final Class next = supertype.getSuperclass();
-            if (next == null || Object.class == next || ignoreClasses.contains(next)) {
-                break;
-            }
-            types.put(next, analyzeParent(supertype, types.get(supertype)));
-            supertype = next;
-        }
-    }
-
-    private static void analyzeInterface(final Map<Class<?>, LinkedHashMap<String, Type>> types, final Type iface,
-                                         final Class<?> supertype, final List<Class<?>> ignoreClasses) {
-        final Class interfaceType = iface instanceof ParameterizedType
-                ? (Class) ((ParameterizedType) iface).getRawType()
-                : (Class) iface;
-        if (!ignoreClasses.contains(interfaceType)) {
-            if (iface instanceof ParameterizedType) {
-                final ParameterizedType parametrization = (ParameterizedType) iface;
-                final LinkedHashMap<String, Type> generics =
-                        resolveGenerics(parametrization, types.get(supertype));
-
-                // no generics case and same resolved generics are ok (even if types in different branches of hierarchy)
-                if (types.containsKey(interfaceType) && !generics.equals(types.get(interfaceType))) {
-                    throw new IllegalStateException(String.format(
-                            "Duplicate interface %s declaration in hierarchy: "
-                                    + "can't properly resolve generics.", interfaceType.getName()));
-                }
-                types.put(interfaceType, generics);
-            } else if (!GROOVY_OBJECT.equals(interfaceType.getSimpleName())) {
-                // avoid groovy specific interface (all groovy objects implements it)
-                types.put(interfaceType, EMPTY_MAP);
-            }
-            analyzeType(types, interfaceType, ignoreClasses);
+    /**
+     * Clears cached descriptors (already parsed).
+     * Cache could be completely disabled using system property or environment variable
+     *
+     * @see #CACHE_PROPERTY
+     */
+    public static void clearCache() {
+        LOCK.lock();
+        try {
+            CACHE.clear();
+        } finally {
+            LOCK.unlock();
         }
     }
 
-    // LinkedHashMap used instead of usual map to avoid accidental simple map usage (order is important!)
-    @SuppressWarnings("PMD.LooseCoupling")
-    private static LinkedHashMap<String, Type> analyzeParent(final Class type,
-                                                             final Map<String, Type> rootGenerics) {
-        LinkedHashMap<String, Type> generics = null;
-        final Class parent = type.getSuperclass();
-        if (!type.isInterface() && parent != null && parent != Object.class
-                && type.getGenericSuperclass() instanceof ParameterizedType) {
-            generics = resolveGenerics((ParameterizedType) type.getGenericSuperclass(), rootGenerics);
-        }
-        return generics == null ? EMPTY_MAP : generics;
+    /**
+     * Disables descriptors cache.
+     */
+    public static void disableCache() {
+        System.setProperty(CACHE_PROPERTY, Boolean.FALSE.toString());
     }
 
-    @SuppressWarnings("PMD.LooseCoupling")
-    private static LinkedHashMap<String, Type> resolveGenerics(final ParameterizedType type,
-                                                               final Map<String, Type> rootGenerics) {
-        final LinkedHashMap<String, Type> generics = new LinkedHashMap<String, Type>();
-        final Type[] genericTypes = type.getActualTypeArguments();
-        final Class interfaceType = (Class) type.getRawType();
-        final TypeVariable[] genericNames = interfaceType.getTypeParameters();
-
-        final int cnt = genericNames.length;
-        for (int i = 0; i < cnt; i++) {
-            final Type genericType = genericTypes[i];
-            Type resolvedGenericType;
-            if (genericType instanceof TypeVariable) {
-                // simple named generics resolved to target types
-                resolvedGenericType = rootGenerics.get(((TypeVariable) genericType).getName());
-            } else {
-                // composite generics passed as is
-                resolvedGenericType = genericType;
-            }
-            generics.put(genericNames[i].getName(), resolvedGenericType);
-        }
-        return generics;
+    /**
+     * @return true is cache enabled, false otherwise
+     */
+    public static boolean isCacheEnabled() {
+        final String no = Boolean.FALSE.toString();
+        return !no.equals(System.getenv(CACHE_PROPERTY))
+                && !no.equals(System.getProperty(CACHE_PROPERTY));
     }
 }

src/main/java/ru/vyarus/java/generics/resolver/context/container/GenericArrayTypeImpl.java

@@ -0,0 +1,32 @@
+package ru.vyarus.java.generics.resolver.context.container;
+
+import ru.vyarus.java.generics.resolver.util.TypeToStringUtils;
+
+import java.lang.reflect.GenericArrayType;
+import java.lang.reflect.Type;
+import java.util.Collections;
+
+/**
+ * Wrapper to hold resolved array type.
+ *
+ * @author Vyacheslav Rusakov
+ * @since 15.12.2014
+ */
+public class GenericArrayTypeImpl implements GenericArrayType {
+
+    private final Type componentType;
+
+    public GenericArrayTypeImpl(final Type componentType) {
+        this.componentType = componentType;
+    }
+
+    @Override
+    public Type getGenericComponentType() {
+        return componentType;
+    }
+
+    @Override
+    public String toString() {
+        return TypeToStringUtils.toStringType(this, Collections.<String, Type>emptyMap());
+    }
+}

src/main/java/ru/vyarus/java/generics/resolver/context/container/ParameterizedTypeImpl.java

@@ -0,0 +1,47 @@
+package ru.vyarus.java.generics.resolver.context.container;
+
+import ru.vyarus.java.generics.resolver.util.TypeToStringUtils;
+
+import java.lang.reflect.ParameterizedType;
+import java.lang.reflect.Type;
+import java.util.Arrays;
+import java.util.Collections;
+
+/**
+ * Wrapper to hold resolved parametrization.
+ *
+ * @author Vyacheslav Rusakov
+ * @since 15.12.2014
+ */
+public class ParameterizedTypeImpl implements ParameterizedType {
+
+    private final Type rawType;
+    private final Type[] actualArguments;
+    private final Type ownerType;
+
+    public ParameterizedTypeImpl(final Type rawType, final Type[] actualArguments, final Type ownerType) {
+        this.rawType = rawType;
+        this.actualArguments = Arrays.copyOf(actualArguments, actualArguments.length);
+        this.ownerType = ownerType;
+    }
+
+    @Override
+    public Type[] getActualTypeArguments() {
+        return Arrays.copyOf(actualArguments, actualArguments.length);
+    }
+
+    @Override
+    public Type getRawType() {
+        return rawType;
+    }
+
+    @Override
+    public Type getOwnerType() {
+        return ownerType;
+    }
+
+    @Override
+    public String toString() {
+        return TypeToStringUtils.toStringType(this, Collections.<String, Type>emptyMap());
+    }
+}

src/main/java/ru/vyarus/java/generics/resolver/context/container/WildcardTypeImpl.java

@@ -0,0 +1,41 @@
+package ru.vyarus.java.generics.resolver.context.container;
+
+import ru.vyarus.java.generics.resolver.util.TypeToStringUtils;
+
+import java.lang.reflect.Type;
+import java.lang.reflect.WildcardType;
+import java.util.Arrays;
+import java.util.Collections;
+
+/**
+ * Wrapper to hold resolved bounds types.
+ *
+ * @author Vyacheslav Rusakov
+ * @since 15.12.2014
+ */
+public class WildcardTypeImpl implements WildcardType {
+
+    private final Type[] upperBounds;
+    private final Type[] lowerBounds;
+
+    @SuppressWarnings("PMD.UseVarargs")
+    public WildcardTypeImpl(final Type[] upperBounds, final Type[] lowerBounds) {
+        this.upperBounds = Arrays.copyOf(upperBounds, upperBounds.length);
+        this.lowerBounds = Arrays.copyOf(lowerBounds, lowerBounds.length);
+    }
+
+    @Override
+    public Type[] getLowerBounds() {
+        return Arrays.copyOf(lowerBounds, lowerBounds.length);
+    }
+
+    @Override
+    public Type[] getUpperBounds() {
+        return Arrays.copyOf(upperBounds, upperBounds.length);
+    }
+
+    @Override
+    public String toString() {
+        return TypeToStringUtils.toStringType(this, Collections.<String, Type>emptyMap());
+    }
+}