Details
-
Type:
Feature Request
-
Status: Resolved (View Workflow)
-
Priority:
Major
-
Resolution: Done
-
Affects Version/s: 1.0
-
Fix Version/s: 1.1.PFD
-
Component/s: None
-
Labels:None
Description
CDI 10.1 states:
An event object is an instance of a concrete Java class with no type variables. ... An event type may not contain a type variable.
Which seems silly considering the container fires events with a type variable at startup. I can't think of any reason why this should be prohibited.
Gliffy Diagrams
Issue Links
- is related to
-
CDI-493
Allow firing of parameterized event types from BeanManager
-
- Open
-
-
CDI-256
CDI spec is not consistent in treating types selected by Event
-
- Resolved
-
-
CDITCK-232
Fix org.jboss.jsr299.tck.tests.event.fires.FireEventTest.testTypeVariableEventTypeFails() to align with spec
-
- Resolved
-
-
WELD-978
Cannot fire event with parameterized type as a payload
-
- Resolved
-
Activity
- All
- Comments
- Work Log
- History
- Activity
- Links Hierarchy
Not a good example I think. In this situation it is possible. Event knows its InjectionPoint that knows its java.lang.reflect.Member (Field in this case). Following pseudocode will work.
|
Field field = (Field) injectionPoint.getMember();
|
Type eventType = field.getGenericType();
|
|
|
if(eventType instanceof ParameterizedType) {
|
|
|
for(Type eventTypeArgument : ((ParameterizedType) eventType).getActualTypeArguments()){
|
// Now at Event level
|
|
|
if(eventTypeArgument instanceof ParameterizedType) {
|
for (Type fooTypeArgument : ((ParameterizedType) eventTypeArgument).getActualTypeArguments())
|
{
|
// Now at Foo level
|
System.out.println("fooTypeArgument = " + fooTypeArgument);
|
}
|
}
|
}
|
}
|
See http://tutorials.jenkov.com/java-reflection/generics.html
However in this situation it is NOT possible...
class Bar {
|
|
|
@Inject
|
BeanManager beanManager;
|
|
|
public void fire() {
|
beanManager.fireEvent(new Foo<Baz>());
|
}
|
|
|
}
|
Martin Kouba
added a comment - Not a good example I think. In this situation it is possible. Event knows its InjectionPoint that knows its java.lang.reflect.Member (Field in this case). Following pseudocode will work.
Field field = (Field) injectionPoint.getMember();
Type eventType = field.getGenericType();
if(eventType instanceof ParameterizedType) {
for(Type eventTypeArgument : ((ParameterizedType) eventType).getActualTypeArguments()){
// Now at Event level
if(eventTypeArgument instanceof ParameterizedType) {
for (Type fooTypeArgument : ((ParameterizedType) eventTypeArgument).getActualTypeArguments())
{
// Now at Foo level
System.out.println("fooTypeArgument = " + fooTypeArgument);
}
}
}
}
See http://tutorials.jenkov.com/java-reflection/generics.html
However in this situation it is NOT possible...
class Bar {
@Inject
BeanManager beanManager;
public void fire() {
beanManager.fireEvent(new Foo<Baz>());
}
}
I should clarify that this is following the CDI 1.0 spec, which doesn't allow Weld to look at the type of the event injection, but only at the type of the event object.
And, to correct Petes example, in the following case the detection is not possible either:
class Foo<T> {}
|
|
|
class Bar<U> {
|
|
|
@Inject Event<Foo<U>> evt;
|
|
|
public void doIt(Foo<U> foo) {
|
evt.fire(foo);
|
}
|
Arne Limburg
added a comment - And, to correct Petes example, in the following case the detection is not possible either:
class Foo<T> {}
class Bar<U> {
@Inject Event<Foo<U>> evt;
public void doIt(Foo<U> foo) {
evt.fire(foo);
}
No, my example is correct. The spec does not allow you to look at the parameterized type of event, it just talks about the type of the event type, which is Foo<Baz> in my example, and undetectable.
This got fixed as part of CDI-256, when we changed it to disallow unresolvable type variables. We defined that an unresolvable type variable is one which can't be inferred from the Event injection point.
I don't think so. A type variable is an unqualified identifier (e.g. X in ProcessBean<X>; see http://java.sun.com/docs/books/jls/third_edition/html/typesValues.html#4.4) and is not the same as parameterized type with actual type arguments (e.g. ProcessBean<Foo> event; see http://java.sun.com/docs/books/jls/third_edition/html/typesValues.html#4.5). Some of container lifecycle events are generic types with type variables but the concrete event object fired/observed is parameterized type with actual type arguments.