"Generics" discover function

Description

A really useful function, this project should offer, is the possibility to figure out the “Generic” type of a Collection or a Map. This function is also required to complete the implementation of a new Map Transformer (for more details please refer to issue: #88)

Desired solution The ideal solution would be the implementation of a new method: getGenericType that takes in input any kind of Java Collection or Map and returns its Generic type(s).

e.g.

List<String> v = new ArrayList<String>();
Class<?> genericClazz = getGenericType(v.getClass()); // will return: String

and

Map<String, Integer> v = new HashMap<String, Integer>();
Pair<Class<?>, Class<?>> typeMap = getGenericType(v.getClass()); // will return a Pair Class<?> keyClass = typeMap.getLeft(); // will return: String
Class<?> elemClass = typeMap.getRight(); // will return: Integer

Additional context

The method should be added into the utility class: ReflectionUtil

[fborriello]

I do agree with you all. This function is actually required for the Map Transformation module to figure out the key and the element type to understand how to get them transformed. The solution, you proposed, to discover the type from the first element of a collection/map could work. In case the collection/map would be empty we will return an empty List/Map. I’ll try with that solution and then get back to you. Thanks

[polarene]

Hi guys, after some tries, also involving @antimoroma in the end, I realized that this particular use case is unsolvable just using reflection. The trick I knew was described in this post: https://xebia.com/blog/acessing-generic-types-at-runtime-in-java/ but it works only for subtypes closing on actual type parameters. For example, if we had:

class Names implements List<String> {...}

Names n = new Names();
Class<?> cls = getGenericType(n.getClass());

then we could recover the actual type parameter String. But when the function is handled a List<String>, even if the instance has a generic superclass, the type parameter is not closed over at compile time (eg: new ArrayList<String>()) so the type information is unknown and the method will return a type E, as declared in the source of AbstractList.

In conclusion, the only possible way seems that of looking up the element’s type as you suggested above.