5:52 a.m.
Is there a way to find out the item type of a generic collection at
runtime using introspection or org.jboss.reflect?
Thanks,
Alexey
9:49 a.m.
Yes. Ales asked the same question a couple of months ago,
but this example wasn't committed then.
See generateCollection() here:
http://anonsvn.jboss.org/repos/jbossas/projects/microcontainer/trunk/meta...
which defaults to java.lang.Object if it is not generic.
On Fri, 2007-07-27 at 12:52 +0200, Alexey Loubyansky wrote:
Is there a way to find out the item type of a generic collection at
runtime using introspection or org.jboss.reflect?
Thanks,
Alexey
_______________________________________________
jboss-development mailing list
jboss-development(a)lists.jboss.org
https://lists.jboss.org/mailman/listinfo/jboss-development
--
xxxxxxxxxxxxxxxxxxxxxxxxxxxx
Adrian Brock
Chief Scientist
JBoss, a division of Red Hat
xxxxxxxxxxxxxxxxxxxxxxxxxxxx
3:35 a.m.
This approach assumes that the component type can be determined with
TypeInfo[] types = typeInfo.getActualTypeArguments();
if (types != null)
elementType = types[0];
This won't work for this class
https://svn.jboss.org/repos/common/jbossxb-builder/trunk/src/test/java/or...
for which its super class should be checked for type arguments and the
component type is the second argument.
I guess I'll need to specify the component type with an annotation. But
it would be nice to have something like Class.getComponentType() to work
for generic collections too.
Alexey
Adrian wrote:
Yes. Ales asked the same question a couple of months ago,
but this example wasn't committed then.
See generateCollection() here:
http://anonsvn.jboss.org/repos/jbossas/projects/microcontainer/trunk/meta...
which defaults to java.lang.Object if it is not generic.
On Fri, 2007-07-27 at 12:52 +0200, Alexey Loubyansky wrote:
> Is there a way to find out the item type of a generic collection at
> runtime using introspection or org.jboss.reflect?
>
> Thanks,
> Alexey
> _______________________________________________
> jboss-development mailing list
> jboss-development(a)lists.jboss.org
> https://lists.jboss.org/mailman/listinfo/jboss-development
3:39 a.m.
Non-restricted SVN link is
http://anonsvn.jboss.org/repos/common/jbossxb-builder/trunk/src/test/java...
Alexey Loubyansky wrote:
This approach assumes that the component type can be determined with
TypeInfo[] types = typeInfo.getActualTypeArguments();
if (types != null)
elementType = types[0];
This won't work for this class
https://svn.jboss.org/repos/common/jbossxb-builder/trunk/src/test/java/or...
for which its super class should be checked for type arguments and the
component type is the second argument.
I guess I'll need to specify the component type with an annotation. But
it would be nice to have something like Class.getComponentType() to work
for generic collections too.
Alexey
Adrian wrote:
> Yes. Ales asked the same question a couple of months ago,
> but this example wasn't committed then.
>
> See generateCollection() here:
>
http://anonsvn.jboss.org/repos/jbossas/projects/microcontainer/trunk/meta...
>
> which defaults to java.lang.Object if it is not generic.
>
> On Fri, 2007-07-27 at 12:52 +0200, Alexey Loubyansky wrote:
>> Is there a way to find out the item type of a generic collection at
>> runtime using introspection or org.jboss.reflect?
>>
>> Thanks,
>> Alexey
>> _______________________________________________
>> jboss-development mailing list
>> jboss-development(a)lists.jboss.org
>> https://lists.jboss.org/mailman/listinfo/jboss-development
_______________________________________________
jboss-development mailing list
jboss-development(a)lists.jboss.org
https://lists.jboss.org/mailman/listinfo/jboss-development
5:57 a.m.
On Mon, 2007-07-30 at 10:35 +0200, Alexey Loubyansky wrote:
This approach assumes that the component type can be determined with
TypeInfo[] types = typeInfo.getActualTypeArguments();
if (types != null)
elementType = types[0];
This won't work for this class
https://svn.jboss.org/repos/common/jbossxb-builder/trunk/src/test/java/or...
for which its super class should be checked for type arguments and the
component type is the second argument.
Well that's a more complicated use case.
I don't see why you can't make it work.
You've just got to locate where it the type hierarchy
and what paremeter the collection is.
I guess I'll need to specify the component type with an
annotation. But
it would be nice to have something like Class.getComponentType() to work
for generic collections too.
Perhaps we can add that to the ClassInfo model?
if (classInfo.isCollection())
typeInfo = classInfo.getComponentType();
and it would do all the hard work of locating the collection
definition and retrieving the type.
We could also do something similar for maps, i.e.
if (classInfo.isMap())
{
keyType = classInfo.getKeyType();
valueType = classInfo.getValueType();
}
--
xxxxxxxxxxxxxxxxxxxxxxxxxxxx
Adrian Brock
Chief Scientist
JBoss, a division of Red Hat
xxxxxxxxxxxxxxxxxxxxxxxxxxxx
7:39 a.m.
Adrian wrote:
On Mon, 2007-07-30 at 10:35 +0200, Alexey Loubyansky wrote:
> This approach assumes that the component type can be determined with
>
> TypeInfo[] types = typeInfo.getActualTypeArguments();
> if (types != null)
> elementType = types[0];
>
> This won't work for this class
>
https://svn.jboss.org/repos/common/jbossxb-builder/trunk/src/test/java/or...
>
> for which its super class should be checked for type arguments and the
> component type is the second argument.
>
Well that's a more complicated use case.
I don't see why you can't make it work.
You've just got to locate where it the type hierarchy
and what paremeter the collection is.
That's my problem. How can I find out using the API which parameter is
passed to the Collection
public abstract class CollectionClass<T1 extends Object, T2 extends
Object, T3 extends Object>
implements Comparable<T2>, Collection<T1>,
java.util.Comparator<T3>
{
}
Besides that I have to keep track of arguments from sub- to super
classes. And Collection interface can be extended implemented on
different levels with different type parameters (but those should belong
to the same type hierarchy).
But the main problem I think is the first one above.
> I guess I'll need to specify the component type with an
annotation. But
> it would be nice to have something like Class.getComponentType() to work
> for generic collections too.
Perhaps we can add that to the ClassInfo model?
That would be excellent.
if (classInfo.isCollection())
typeInfo = classInfo.getComponentType();
and it would do all the hard work of locating the collection
definition and retrieving the type.
We could also do something similar for maps, i.e.
if (classInfo.isMap())
{
keyType = classInfo.getKeyType();
valueType = classInfo.getValueType();
}
This one too!
Thanks,
Alexey
8:37 a.m.
On Mon, 2007-07-30 at 14:39 +0200, Alexey Loubyansky wrote:
That's my problem. How can I find out using the API which
parameter is
passed to the Collection
public abstract class CollectionClass<T1 extends Object, T2 extends
Object, T3 extends Object>
implements Comparable<T2>, Collection<T1>,
java.util.Comparator<T3>
{
}
Besides that I have to keep track of arguments from sub- to super
classes. And Collection interface can be extended implemented on
different levels with different type parameters (but those should belong
to the same type hierarchy).
But the main problem I think is the first one above.
That's a very good question. If the class implements
Collection<Whatever> directly, you can get at this
information.
It's just:
for (ClassInfo intf : myClass.getInterfaces())
{
if (intf.getName().equals(Collection.class.getName())
return intf.getActualTypeArguments()[0];
}
But if it is on a superclass, there is no way to get
at this information.
In the main java reflection api:
Class.getGenericSuperClass() returns a ParameterizedType
but from that ParameterizedType there is no route
to get the generic interfaces.
e.g.
public class MyClass extends AbstractCollection<Whatever>
then there's no way to get at the ParameterizedType
Collection<Whatever> that AbstractCollection<Whataver> implements.
What would really be useful would be if there was a
Class.getAllGenericInterfaces();
but that doesn't exist.
--
xxxxxxxxxxxxxxxxxxxxxxxxxxxx
Adrian Brock
Chief Scientist
JBoss, a division of Red Hat
xxxxxxxxxxxxxxxxxxxxxxxxxxxx
9:04 a.m.
On Mon, 2007-07-30 at 15:37 +0200, Adrian wrote:
But if it is on a superclass, there is no way to get
at this information.
In the main java reflection api:
Class.getGenericSuperClass() returns a ParameterizedType
but from that ParameterizedType there is no route
to get the generic interfaces.
The only way I can see to do it is hack around
with matching parameter type names on the raw
types and their "generic" interfaces.
Then you can work your back and get the real type
passed to that parameter.
e.g.
public static void main(String args[]) throws Exception
{
System.out.println("Type of collection: " +
Collection.class.getTypeParameters()[0]);
Class myClass1 = MyClass2.class.getSuperclass();
System.out.println("Type of MyClass1: " +
myClass1.getTypeParameters()[0]);
ParameterizedType collection = (ParameterizedType)
myClass1.getGenericInterfaces()[0];
System.out.println("Type on interface: " +
collection.getActualTypeArguments()[0]);
}
public class MyClass1<T> extends AbstractCollection<T> implements
Collection<T>
{
public Iterator<T> iterator()
{
return null;
}
public int size()
{
return 0;
}
}
public class MyClass2 extends MyClass1<String> {}
produces the output:
Type of collection: E
Type of MyClass1: T
Type on interface: T
So you can match the type name T of the "raw" MyClass1
with the parameter name passed to its the collection interface, also T.
The first line of output just shows that the Collection class
actually declared this parameter as E.
--
xxxxxxxxxxxxxxxxxxxxxxxxxxxx
Adrian Brock
Chief Scientist
JBoss, a division of Red Hat
xxxxxxxxxxxxxxxxxxxxxxxxxxxx
9:15 a.m.
The required information seems to be there.
// field
private CollectionClass<Integer, Long, Double> cc;
public void testMain() throws Exception
{
ClassInfo info = (ClassInfo)
configuration.getTypeInfo(getClass().getDeclaredField("cc").getGenericType());
while(info.isCollection())
{
printInfo(info);
if(info.getGenericInterfaces() != null)
{
ClassInfo colInfo = info;
while (!colInfo.getName().equals(Collection.class.getName()))
{
InterfaceInfo[] gi = colInfo.getGenericInterfaces();
for (InterfaceInfo ii : gi)
{
if (ii.isCollection())
{
printInfo(ii);
colInfo = ii;
break;
}
}
}
}
if (info.getGenericSuperclass().isCollection())
{
info = info.getGenericSuperclass();
}
else
{
break;
}
}
}
private void printInfo(ClassInfo info)
{
System.out.println((info.isInterface() ? "interface" : "class")
+
": " + info + ", isCol=" + info.isCollection());
TypeInfo[] typeArgs = info.getActualTypeArguments();
if(typeArgs == null)
{
System.out.println("no args");
}
else
{
System.out.println("type args:");
TypeVariable[] typeVars = info.getType().getTypeParameters();
for(int i = 0; i < typeArgs.length; ++i)
{
System.out.println(" " + typeVars[i].getName() + "=" +
typeArgs[i].getName());
}
}
System.out.println("---");
}
public abstract class CollectionClass<T1 extends Object, T2 extends
Object, T3 extends Object>
implements Comparable<T2>, Collection<T1>,
java.util.Comparator<T3>
{
}
The output is
class:
ParameterizedClassInfo(a)7b7072{org.jboss.xml.binding.test.MainTestCase.org.jboss.xml.binding.test.MainTestCase$CollectionClass<java.lang.Integer,
java.lang.Long, java.lang.Double>}, isCol=true
type args:
T1=java.lang.Integer
T2=java.lang.Long
T3=java.lang.Double
---
interface: ParameterizedClassInfo(a)913750{java.util.Collection<T1>},
isCol=true
type args:
E=java.lang.Object
---
Note, that the interface is printed with the T1 variable. And I can get
the value of T1 from the super class. But I can't find out using the API
that T1 is passed to the Collection.
Alexey
Adrian wrote:
On Mon, 2007-07-30 at 14:39 +0200, Alexey Loubyansky wrote:
> That's my problem. How can I find out using the API which parameter is
> passed to the Collection
>
> public abstract class CollectionClass<T1 extends Object, T2 extends
> Object, T3 extends Object>
> implements Comparable<T2>, Collection<T1>,
java.util.Comparator<T3>
> {
> }
>
> Besides that I have to keep track of arguments from sub- to super
> classes. And Collection interface can be extended implemented on
> different levels with different type parameters (but those should belong
> to the same type hierarchy).
> But the main problem I think is the first one above.
That's a very good question. If the class implements
Collection<Whatever> directly, you can get at this
information.
It's just:
for (ClassInfo intf : myClass.getInterfaces())
{
if (intf.getName().equals(Collection.class.getName())
return intf.getActualTypeArguments()[0];
}
But if it is on a superclass, there is no way to get
at this information.
In the main java reflection api:
Class.getGenericSuperClass() returns a ParameterizedType
but from that ParameterizedType there is no route
to get the generic interfaces.
e.g.
public class MyClass extends AbstractCollection<Whatever>
then there's no way to get at the ParameterizedType
Collection<Whatever> that AbstractCollection<Whataver> implements.
What would really be useful would be if there was a
Class.getAllGenericInterfaces();
but that doesn't exist.
4:17 p.m.
On Mon, 2007-07-30 at 14:39 +0200, Alexey Loubyansky wrote:
Adrian wrote:
> Perhaps we can add that to the ClassInfo model?
That would be excellent.
> if (classInfo.isCollection())
> typeInfo = classInfo.getComponentType();
>
> and it would do all the hard work of locating the collection
> definition and retrieving the type.
>
> We could also do something similar for maps, i.e.
>
> if (classInfo.isMap())
> {
> keyType = classInfo.getKeyType();
> valueType = classInfo.getValueType();
> }
This one too!
I've implemented this. It was actually easier
than I thought once I got my head around it. :-)
See the bottom of IntrospectionTypeInfoFactoryImpl
The basic idea is to locate the Collection interface
in the type hierarchy
then work your way back mapping TypeVariables
until you reach where the real type is specified.
Or failing that use the upper bounds of the
last TypeVariable found.
Thanks,
Alexey
_______________________________________________
jboss-development mailing list
jboss-development(a)lists.jboss.org
https://lists.jboss.org/mailman/listinfo/jboss-development
--
xxxxxxxxxxxxxxxxxxxxxxxxxxxx
Adrian Brock
Chief Scientist
JBoss, a division of Red Hat
xxxxxxxxxxxxxxxxxxxxxxxxxxxx
4:03 a.m.
Yes, it does work! Thanks!
I had to add a check that the interface implements the reference before
calling locateActualType because in case of Comparable<T> and so on I
would get NPE later. I checked out the trunk but it didn't build. So,
here is the diff.
Type[] interfaces = clazz.getGenericInterfaces();
for (Type intf : interfaces)
- {
- Type result;
+ {
+ Class interfaceClass;
if (intf instanceof Class)
{
- Class interfaceClass = (Class) intf;
- result = locateActualType(reference, parameter,
interfaceClass, intf);
- if (result instanceof TypeVariable)
- result = getParameter(clazz, type, (TypeVariable) result);
+ interfaceClass = (Class) intf;
}
else if (intf instanceof ParameterizedType)
{
ParameterizedType interfaceType = (ParameterizedType) intf;
- Class interfaceClass = (Class) interfaceType.getRawType();
+ interfaceClass = (Class) interfaceType.getRawType();
+ }
+ else
+ throw new IllegalStateException("Unexpected type " +
intf.getClass());
+
+ Type result = null;
+ if (reference.isAssignableFrom(interfaceClass))
+ {
result = locateActualType(reference, parameter,
interfaceClass, intf);
if (result instanceof TypeVariable)
result = getParameter(clazz, type, (TypeVariable) result);
}
- else
- throw new IllegalStateException("Unexpected type " +
intf.getClass());
+
if (result != null)
return result;
Adrian wrote:
On Mon, 2007-07-30 at 14:39 +0200, Alexey Loubyansky wrote:
> Adrian wrote:
>> Perhaps we can add that to the ClassInfo model?
> That would be excellent.
>
>> if (classInfo.isCollection())
>> typeInfo = classInfo.getComponentType();
>>
>> and it would do all the hard work of locating the collection
>> definition and retrieving the type.
>>
>> We could also do something similar for maps, i.e.
>>
>> if (classInfo.isMap())
>> {
>> keyType = classInfo.getKeyType();
>> valueType = classInfo.getValueType();
>> }
> This one too!
>
I've implemented this. It was actually easier
than I thought once I got my head around it. :-)
See the bottom of IntrospectionTypeInfoFactoryImpl
The basic idea is to locate the Collection interface
in the type hierarchy
then work your way back mapping TypeVariables
until you reach where the real type is specified.
Or failing that use the upper bounds of the
last TypeVariable found.
> Thanks,
> Alexey
> _______________________________________________
> jboss-development mailing list
> jboss-development(a)lists.jboss.org
> https://lists.jboss.org/mailman/listinfo/jboss-development
9:26 a.m.
I've applied your patch, but I don't understand why the NPE happens?
Why wouldn't a class implement its interface?
Basically I want to write a test for what you were seeing.
ClassInfo info = ...;
info.getComponentType(); // Should not throw NPE! :-)
On Wed, 2007-08-01 at 11:03 +0200, Alexey Loubyansky wrote:
Yes, it does work! Thanks!
I had to add a check that the interface implements the reference before
calling locateActualType because in case of Comparable<T> and so on I
would get NPE later. I checked out the trunk but it didn't build. So,
here is the diff.
Type[] interfaces = clazz.getGenericInterfaces();
for (Type intf : interfaces)
- {
- Type result;
+ {
+ Class interfaceClass;
if (intf instanceof Class)
{
- Class interfaceClass = (Class) intf;
- result = locateActualType(reference, parameter,
interfaceClass, intf);
- if (result instanceof TypeVariable)
- result = getParameter(clazz, type, (TypeVariable) result);
+ interfaceClass = (Class) intf;
}
else if (intf instanceof ParameterizedType)
{
ParameterizedType interfaceType = (ParameterizedType) intf;
- Class interfaceClass = (Class) interfaceType.getRawType();
+ interfaceClass = (Class) interfaceType.getRawType();
+ }
+ else
+ throw new IllegalStateException("Unexpected type " +
intf.getClass());
+
+ Type result = null;
+ if (reference.isAssignableFrom(interfaceClass))
+ {
result = locateActualType(reference, parameter,
interfaceClass, intf);
if (result instanceof TypeVariable)
result = getParameter(clazz, type, (TypeVariable) result);
}
- else
- throw new IllegalStateException("Unexpected type " +
intf.getClass());
+
if (result != null)
return result;
--
xxxxxxxxxxxxxxxxxxxxxxxxxxxx
Adrian Brock
Chief Scientist
JBoss, a division of Red Hat
xxxxxxxxxxxxxxxxxxxxxxxxxxxx
2:46 a.m.
The problem is when clazz argument is an interface and we call
clazz.getSuperclass() which is null and which is passed as clazz
argument to the next call.
So, either that or we shouldn't call getSuperclass() on an interface.
You could comment out the check for
reference.isAssignableFrom(interfaceClass) and try this class
public abstract class CollectionClass<T1 extends Object, T2 extends
Object, T3 extends Object>
implements Comparable<T1>, Collection<T2>,
java.util.Comparator<T3>
{
}
Alexey
Adrian wrote:
I've applied your patch, but I don't understand why the NPE
happens?
Why wouldn't a class implement its interface?
Basically I want to write a test for what you were seeing.
ClassInfo info = ...;
info.getComponentType(); // Should not throw NPE! :-)
On Wed, 2007-08-01 at 11:03 +0200, Alexey Loubyansky wrote:
> Yes, it does work! Thanks!
>
> I had to add a check that the interface implements the reference before
> calling locateActualType because in case of Comparable<T> and so on I
> would get NPE later. I checked out the trunk but it didn't build. So,
> here is the diff.
>
> Type[] interfaces = clazz.getGenericInterfaces();
> for (Type intf : interfaces)
> - {
> - Type result;
> + {
> + Class interfaceClass;
> if (intf instanceof Class)
> {
> - Class interfaceClass = (Class) intf;
> - result = locateActualType(reference, parameter,
> interfaceClass, intf);
> - if (result instanceof TypeVariable)
> - result = getParameter(clazz, type, (TypeVariable) result);
> + interfaceClass = (Class) intf;
> }
> else if (intf instanceof ParameterizedType)
> {
> ParameterizedType interfaceType = (ParameterizedType) intf;
> - Class interfaceClass = (Class) interfaceType.getRawType();
> + interfaceClass = (Class) interfaceType.getRawType();
> + }
> + else
> + throw new IllegalStateException("Unexpected type " +
> intf.getClass());
> +
> + Type result = null;
> + if (reference.isAssignableFrom(interfaceClass))
> + {
> result = locateActualType(reference, parameter,
> interfaceClass, intf);
> if (result instanceof TypeVariable)
> result = getParameter(clazz, type, (TypeVariable) result);
> }
> - else
> - throw new IllegalStateException("Unexpected type " +
> intf.getClass());
> +
> if (result != null)
> return result;
3:32 a.m.
In addition, it would avoid traversing interface hierarchies that do not
extend reference.
Alexey
Alexey Loubyansky wrote:
The problem is when clazz argument is an interface and we call
clazz.getSuperclass() which is null and which is passed as clazz
argument to the next call.
So, either that or we shouldn't call getSuperclass() on an interface.
You could comment out the check for
reference.isAssignableFrom(interfaceClass) and try this class
public abstract class CollectionClass<T1 extends Object, T2 extends
Object, T3 extends Object>
implements Comparable<T1>, Collection<T2>,
java.util.Comparator<T3>
{
}
Alexey
Adrian wrote:
> I've applied your patch, but I don't understand why the NPE happens?
> Why wouldn't a class implement its interface?
>
> Basically I want to write a test for what you were seeing.
>
> ClassInfo info = ...;
> info.getComponentType(); // Should not throw NPE! :-)
>
> On Wed, 2007-08-01 at 11:03 +0200, Alexey Loubyansky wrote:
>> Yes, it does work! Thanks!
>>
>> I had to add a check that the interface implements the reference
>> before calling locateActualType because in case of Comparable<T> and
>> so on I would get NPE later. I checked out the trunk but it didn't
>> build. So, here is the diff.
>>
>> Type[] interfaces = clazz.getGenericInterfaces();
>> for (Type intf : interfaces)
>> - {
>> - Type result;
>> + {
>> + Class interfaceClass;
>> if (intf instanceof Class)
>> {
>> - Class interfaceClass = (Class) intf;
>> - result = locateActualType(reference, parameter,
>> interfaceClass, intf);
>> - if (result instanceof TypeVariable)
>> - result = getParameter(clazz, type, (TypeVariable)
>> result);
>> + interfaceClass = (Class) intf;
>> }
>> else if (intf instanceof ParameterizedType)
>> {
>> ParameterizedType interfaceType = (ParameterizedType)
>> intf;
>> - Class interfaceClass = (Class) interfaceType.getRawType();
>> + interfaceClass = (Class) interfaceType.getRawType();
>> + }
>> + else
>> + throw new IllegalStateException("Unexpected type " +
>> intf.getClass());
>> +
>> + Type result = null;
>> + if (reference.isAssignableFrom(interfaceClass))
>> + {
>> result = locateActualType(reference, parameter,
>> interfaceClass, intf);
>> if (result instanceof TypeVariable)
>> result = getParameter(clazz, type, (TypeVariable)
>> result);
>> }
>> - else
>> - throw new IllegalStateException("Unexpected type " +
>> intf.getClass());
>> +
>> if (result != null)
>> return result;
>
_______________________________________________
jboss-development mailing list
jboss-development(a)lists.jboss.org
https://lists.jboss.org/mailman/listinfo/jboss-development
6348
days inactive
6355
days old
jboss-development@lists.jboss.org
13 comments
2 participants
participants (2)
-
Adrian -
Alexey Loubyansky