3:49 p.m.
Arne Limburg created CDI-271:
--------------------------------
Summary: Provide a way to inject Event metadata into an observer method
Key: CDI-271
URL: https://issues.jboss.org/browse/CDI-271
Project: CDI Specification Issues
Issue Type: Feature Request
Components: Events
Reporter: Arne Limburg
Currently there is no way for observer methods to access the qualifiers of the fired event
(i.e. to access @Nonbinding members).
Consider the following example:
{code}
@Inject @MyQualifier
Event<MyObject> event;
public void fireEvent(MyObject object, MyTypeValue type) {
event.select(new MyTypeAnnotationLiteral(type)).fire(object);
}
{code}
Currently no observer can receive the value of MyTypeValue. I suggest to introduce an
interface AnnotatedEvent that extends Annotated and contains this information. It then
could be injected via the InjectionPoint like this:
{code}
public void observeEvent(@Observes @MyType MyObject object, InjectionPoint ip) {
MyType annotation = ip.getAnnotated().getAnnotation(MyType.class);
MyTypeValue value = annotation.value();
...
}
{code}
--
This message is automatically generated by JIRA.
If you think it was sent incorrectly, please contact your JIRA administrators
For more information on JIRA, see: http://www.atlassian.com/software/jira
3:57 p.m.
[
https://issues.jboss.org/browse/CDI-271?page=com.atlassian.jira.plugin.sy...
]
Jens Schumann commented on CDI-271:
-----------------------------------
Arne: What do you think about my proposal for CDI-20? Maybe this can be used here too.
Provide a way to inject Event metadata into an observer method
--------------------------------------------------------------
Key: CDI-271
URL: https://issues.jboss.org/browse/CDI-271
Project: CDI Specification Issues
Issue Type: Feature Request
Components: Events
Reporter: Arne Limburg
Currently there is no way for observer methods to access the qualifiers of the fired
event (i.e. to access @Nonbinding members).
Consider the following example:
{code}
@Inject @MyQualifier
Event<MyObject> event;
public void fireEvent(MyObject object, MyTypeValue type) {
event.select(new MyTypeAnnotationLiteral(type)).fire(object);
}
{code}
Currently no observer can receive the value of MyTypeValue. I suggest to introduce an
interface AnnotatedEvent that extends Annotated and contains this information. It then
could be injected via the InjectionPoint like this:
{code}
public void observeEvent(@Observes @MyType MyObject object, InjectionPoint ip) {
MyType annotation = ip.getAnnotated().getAnnotation(MyType.class);
MyTypeValue value = annotation.value();
...
}
{code}
--
This message is automatically generated by JIRA.
If you think it was sent incorrectly, please contact your JIRA administrators
For more information on JIRA, see: http://www.atlassian.com/software/jira
4:01 p.m.
[
https://issues.jboss.org/browse/CDI-271?page=com.atlassian.jira.plugin.sy...
]
Arne Limburg commented on CDI-271:
----------------------------------
Yes this certainly should be discussed together.
Provide a way to inject Event metadata into an observer method
--------------------------------------------------------------
Key: CDI-271
URL: https://issues.jboss.org/browse/CDI-271
Project: CDI Specification Issues
Issue Type: Feature Request
Components: Events
Reporter: Arne Limburg
Currently there is no way for observer methods to access the qualifiers of the fired
event (i.e. to access @Nonbinding members).
Consider the following example:
{code}
@Inject @MyQualifier
Event<MyObject> event;
public void fireEvent(MyObject object, MyTypeValue type) {
event.select(new MyTypeAnnotationLiteral(type)).fire(object);
}
{code}
Currently no observer can receive the value of MyTypeValue. I suggest to introduce an
interface AnnotatedEvent that extends Annotated and contains this information. It then
could be injected via the InjectionPoint like this:
{code}
public void observeEvent(@Observes @MyType MyObject object, InjectionPoint ip) {
MyType annotation = ip.getAnnotated().getAnnotation(MyType.class);
MyTypeValue value = annotation.value();
...
}
{code}
--
This message is automatically generated by JIRA.
If you think it was sent incorrectly, please contact your JIRA administrators
For more information on JIRA, see: http://www.atlassian.com/software/jira
6:50 p.m.
[
https://issues.jboss.org/browse/CDI-271?page=com.atlassian.jira.plugin.sy...
]
Mark Struberg commented on CDI-271:
-----------------------------------
look like good additions. Could you make it to the next weekly EG meeting on monday 18:00
CEST ?
Provide a way to inject Event metadata into an observer method
--------------------------------------------------------------
Key: CDI-271
URL: https://issues.jboss.org/browse/CDI-271
Project: CDI Specification Issues
Issue Type: Feature Request
Components: Events
Reporter: Arne Limburg
Currently there is no way for observer methods to access the qualifiers of the fired
event (i.e. to access @Nonbinding members).
Consider the following example:
{code}
@Inject @MyQualifier
Event<MyObject> event;
public void fireEvent(MyObject object, MyTypeValue type) {
event.select(new MyTypeAnnotationLiteral(type)).fire(object);
}
{code}
Currently no observer can receive the value of MyTypeValue. I suggest to introduce an
interface AnnotatedEvent that extends Annotated and contains this information. It then
could be injected via the InjectionPoint like this:
{code}
public void observeEvent(@Observes @MyType MyObject object, InjectionPoint ip) {
MyType annotation = ip.getAnnotated().getAnnotation(MyType.class);
MyTypeValue value = annotation.value();
...
}
{code}
--
This message is automatically generated by JIRA.
If you think it was sent incorrectly, please contact your JIRA administrators
For more information on JIRA, see: http://www.atlassian.com/software/jira
9:12 a.m.
[
https://issues.jboss.org/browse/CDI-271?page=com.atlassian.jira.plugin.sy...
]
Arne Limburg commented on CDI-271:
----------------------------------
Thinking about it, this needs to be applied to Producer-Methods of Instances, too:
{code}
@Inject @MyQualifier
Instance<MyObject> event;
public MyObject getInstance(MyTypeValue type) {
return instance.select(new MyTypeAnnotationLiteral(type)).get();
}
{code}
{code}
@Produces
@MyQualifier
@MyType
public MyObject getMyObject(InjectionPoint ip) {
MyType annotation = ip.getAnnotated().getAnnotation(MyType.class);
MyTypeValue value = annotation.value();
...
}
{code}
I see, if I can make it to the meeting next monday. Then we can discuss this further.
Provide a way to inject Event metadata into an observer method
--------------------------------------------------------------
Key: CDI-271
URL: https://issues.jboss.org/browse/CDI-271
Project: CDI Specification Issues
Issue Type: Feature Request
Components: Events
Reporter: Arne Limburg
Currently there is no way for observer methods to access the qualifiers of the fired
event (i.e. to access @Nonbinding members).
Consider the following example:
{code}
@Inject @MyQualifier
Event<MyObject> event;
public void fireEvent(MyObject object, MyTypeValue type) {
event.select(new MyTypeAnnotationLiteral(type)).fire(object);
}
{code}
Currently no observer can receive the value of MyTypeValue. I suggest to introduce an
interface AnnotatedEvent that extends Annotated and contains this information. It then
could be injected via the InjectionPoint like this:
{code}
public void observeEvent(@Observes @MyType MyObject object, InjectionPoint ip) {
MyType annotation = ip.getAnnotated().getAnnotation(MyType.class);
MyTypeValue value = annotation.value();
...
}
{code}
--
This message is automatically generated by JIRA.
If you think it was sent incorrectly, please contact your JIRA administrators
For more information on JIRA, see: http://www.atlassian.com/software/jira
12:14 p.m.
[
https://issues.jboss.org/browse/CDI-271?page=com.atlassian.jira.plugin.sy...
]
Arne Limburg commented on CDI-271:
----------------------------------
Since this does not only apply to Events, but also to Instances, the interface probably
should be named AnnotatedSelection
Provide a way to inject Event metadata into an observer method
--------------------------------------------------------------
Key: CDI-271
URL: https://issues.jboss.org/browse/CDI-271
Project: CDI Specification Issues
Issue Type: Feature Request
Components: Events
Reporter: Arne Limburg
Currently there is no way for observer methods to access the qualifiers of the fired
event (i.e. to access @Nonbinding members).
Consider the following example:
{code}
@Inject @MyQualifier
Event<MyObject> event;
public void fireEvent(MyObject object, MyTypeValue type) {
event.select(new MyTypeAnnotationLiteral(type)).fire(object);
}
{code}
Currently no observer can receive the value of MyTypeValue. I suggest to introduce an
interface AnnotatedEvent that extends Annotated and contains this information. It then
could be injected via the InjectionPoint like this:
{code}
public void observeEvent(@Observes @MyType MyObject object, InjectionPoint ip) {
MyType annotation = ip.getAnnotated().getAnnotation(MyType.class);
MyTypeValue value = annotation.value();
...
}
{code}
--
This message is automatically generated by JIRA.
If you think it was sent incorrectly, please contact your JIRA administrators
For more information on JIRA, see: http://www.atlassian.com/software/jira
9:59 a.m.
[
https://issues.jboss.org/browse/CDI-271?page=com.atlassian.jira.plugin.sy...
]
Jozef Hartinger commented on CDI-271:
-------------------------------------
I don't think Annotated is the appropriate level of abstraction for this. Annotated*
serves as a low-level abstraction over information obtained from the reflection API
whereas InjectionPoint is the abstraction level that recognized qualifiers, etc.
Furthermore, you would probably want to obtain all the qualifiers of an event (including
those set using Event.select()) which are not reflected within InjectionPoint nor
Annotated.
Note that you could implement the ObserverMethod interface yourself that allows you to
obtain qualifiers of a received event (see CDI-36).
Provide a way to inject Event metadata into an observer method
--------------------------------------------------------------
Key: CDI-271
URL: https://issues.jboss.org/browse/CDI-271
Project: CDI Specification Issues
Issue Type: Feature Request
Components: Events
Reporter: Arne Limburg
Currently there is no way for observer methods to access the qualifiers of the fired
event (i.e. to access @Nonbinding members).
Consider the following example:
{code}
@Inject @MyQualifier
Event<MyObject> event;
public void fireEvent(MyObject object, MyTypeValue type) {
event.select(new MyTypeAnnotationLiteral(type)).fire(object);
}
{code}
Currently no observer can receive the value of MyTypeValue. I suggest to introduce an
interface AnnotatedEvent that extends Annotated and contains this information. It then
could be injected via the InjectionPoint like this:
{code}
public void observeEvent(@Observes @MyType MyObject object, InjectionPoint ip) {
MyType annotation = ip.getAnnotated().getAnnotation(MyType.class);
MyTypeValue value = annotation.value();
...
}
{code}
--
This message is automatically generated by JIRA.
If you think it was sent incorrectly, please contact your JIRA administrators
For more information on JIRA, see: http://www.atlassian.com/software/jira
5:09 p.m.
[
https://issues.jboss.org/browse/CDI-271?page=com.atlassian.jira.plugin.sy...
]
Pete Muir updated CDI-271:
--------------------------
Fix Version/s: 1.1 (Proposed)
Provide a way to inject Event metadata into an observer method
--------------------------------------------------------------
Key: CDI-271
URL: https://issues.jboss.org/browse/CDI-271
Project: CDI Specification Issues
Issue Type: Feature Request
Components: Events
Reporter: Arne Limburg
Fix For: 1.1 (Proposed)
Currently there is no way for observer methods to access the qualifiers of the fired
event (i.e. to access @Nonbinding members).
Consider the following example:
{code}
@Inject @MyQualifier
Event<MyObject> event;
public void fireEvent(MyObject object, MyTypeValue type) {
event.select(new MyTypeAnnotationLiteral(type)).fire(object);
}
{code}
Currently no observer can receive the value of MyTypeValue. I suggest to introduce an
interface AnnotatedEvent that extends Annotated and contains this information. It then
could be injected via the InjectionPoint like this:
{code}
public void observeEvent(@Observes @MyType MyObject object, InjectionPoint ip) {
MyType annotation = ip.getAnnotated().getAnnotation(MyType.class);
MyTypeValue value = annotation.value();
...
}
{code}
--
This message is automatically generated by JIRA.
If you think it was sent incorrectly, please contact your JIRA administrators
For more information on JIRA, see: http://www.atlassian.com/software/jira
4:12 p.m.
[
https://issues.jboss.org/browse/CDI-271?page=com.atlassian.jira.plugin.sy...
]
Pete Muir commented on CDI-271:
-------------------------------
Arne do you have time to work up and present a proposal for this?
Provide a way to inject Event metadata into an observer method
--------------------------------------------------------------
Key: CDI-271
URL: https://issues.jboss.org/browse/CDI-271
Project: CDI Specification Issues
Issue Type: Feature Request
Components: Events
Reporter: Arne Limburg
Fix For: 1.1 (Proposed)
Currently there is no way for observer methods to access the qualifiers of the fired
event (i.e. to access @Nonbinding members).
Consider the following example:
{code}
@Inject @MyQualifier
Event<MyObject> event;
public void fireEvent(MyObject object, MyTypeValue type) {
event.select(new MyTypeAnnotationLiteral(type)).fire(object);
}
{code}
Currently no observer can receive the value of MyTypeValue. I suggest to introduce an
interface AnnotatedEvent that extends Annotated and contains this information. It then
could be injected via the InjectionPoint like this:
{code}
public void observeEvent(@Observes @MyType MyObject object, InjectionPoint ip) {
MyType annotation = ip.getAnnotated().getAnnotation(MyType.class);
MyTypeValue value = annotation.value();
...
}
{code}
--
This message is automatically generated by JIRA.
If you think it was sent incorrectly, please contact your JIRA administrators
For more information on JIRA, see: http://www.atlassian.com/software/jira
7:29 p.m.
[
https://issues.jboss.org/browse/CDI-271?page=com.atlassian.jira.plugin.sy...
]
Pete Muir commented on CDI-271:
-------------------------------
I'm not sure that it's right to reuse InjectionPoint, as it has other stuff on it
that perhaps doesn't make sense (e.g. what do getMember() return, getAnnotated() ,
isDelegate() and isTransient() return)? And also, the case of doing the fire via
BeanManager would not fit well.
How about introducing
{code}
public interface EventCaller {
public Set<Annotation> getEventQualifiers();
public Type getEventType();
}
Which could be injected into an event observer?
Provide a way to inject Event metadata into an observer method
--------------------------------------------------------------
Key: CDI-271
URL: https://issues.jboss.org/browse/CDI-271
Project: CDI Specification Issues
Issue Type: Feature Request
Components: Events
Reporter: Arne Limburg
Fix For: 1.1 (Proposed)
Currently there is no way for observer methods to access the qualifiers of the fired
event (i.e. to access @Nonbinding members).
Consider the following example:
{code}
@Inject @MyQualifier
Event<MyObject> event;
public void fireEvent(MyObject object, MyTypeValue type) {
event.select(new MyTypeAnnotationLiteral(type)).fire(object);
}
{code}
Currently no observer can receive the value of MyTypeValue. I suggest to introduce an
interface AnnotatedEvent that extends Annotated and contains this information. It then
could be injected via the InjectionPoint like this:
{code}
public void observeEvent(@Observes @MyType MyObject object, InjectionPoint ip) {
MyType annotation = ip.getAnnotated().getAnnotation(MyType.class);
MyTypeValue value = annotation.value();
...
}
{code}
--
This message is automatically generated by JIRA.
If you think it was sent incorrectly, please contact your JIRA administrators
For more information on JIRA, see: http://www.atlassian.com/software/jira
2:02 p.m.
[
https://issues.jboss.org/browse/CDI-271?page=com.atlassian.jira.plugin.sy...
]
Arne Limburg commented on CDI-271:
----------------------------------
EventCaller would be to narrow, since the same is needed for Instance
Maybe we should extract a superinterface from InjectionPoint.
getAnnotated() by the way makes sense, if it would return an AnnotatedSelection or
something like that.
If we didn't have the interface already with a slightly different semantic, I would
propose InjectionTarget.
Maybe InjectionReceiver?
Provide a way to inject Event metadata into an observer method
--------------------------------------------------------------
Key: CDI-271
URL: https://issues.jboss.org/browse/CDI-271
Project: CDI Specification Issues
Issue Type: Feature Request
Components: Events
Reporter: Arne Limburg
Fix For: 1.1 (Proposed)
Currently there is no way for observer methods to access the qualifiers of the fired
event (i.e. to access @Nonbinding members).
Consider the following example:
{code}
@Inject @MyQualifier
Event<MyObject> event;
public void fireEvent(MyObject object, MyTypeValue type) {
event.select(new MyTypeAnnotationLiteral(type)).fire(object);
}
{code}
Currently no observer can receive the value of MyTypeValue. I suggest to introduce an
interface AnnotatedEvent that extends Annotated and contains this information. It then
could be injected via the InjectionPoint like this:
{code}
public void observeEvent(@Observes @MyType MyObject object, InjectionPoint ip) {
MyType annotation = ip.getAnnotated().getAnnotation(MyType.class);
MyTypeValue value = annotation.value();
...
}
{code}
--
This message is automatically generated by JIRA.
If you think it was sent incorrectly, please contact your JIRA administrators
For more information on JIRA, see: http://www.atlassian.com/software/jira
2:12 p.m.
[
https://issues.jboss.org/browse/CDI-271?page=com.atlassian.jira.plugin.sy...
]
Pete Muir commented on CDI-271:
-------------------------------
Well except that name doesn't make sense for Events...
Provide a way to inject Event metadata into an observer method
--------------------------------------------------------------
Key: CDI-271
URL: https://issues.jboss.org/browse/CDI-271
Project: CDI Specification Issues
Issue Type: Feature Request
Components: Events
Reporter: Arne Limburg
Fix For: 1.1 (Proposed)
Currently there is no way for observer methods to access the qualifiers of the fired
event (i.e. to access @Nonbinding members).
Consider the following example:
{code}
@Inject @MyQualifier
Event<MyObject> event;
public void fireEvent(MyObject object, MyTypeValue type) {
event.select(new MyTypeAnnotationLiteral(type)).fire(object);
}
{code}
Currently no observer can receive the value of MyTypeValue. I suggest to introduce an
interface AnnotatedEvent that extends Annotated and contains this information. It then
could be injected via the InjectionPoint like this:
{code}
public void observeEvent(@Observes @MyType MyObject object, InjectionPoint ip) {
MyType annotation = ip.getAnnotated().getAnnotation(MyType.class);
MyTypeValue value = annotation.value();
...
}
{code}
--
This message is automatically generated by JIRA.
If you think it was sent incorrectly, please contact your JIRA administrators
For more information on JIRA, see: http://www.atlassian.com/software/jira
8:25 a.m.
[
https://issues.jboss.org/browse/CDI-271?page=com.atlassian.jira.plugin.sy...
]
Arne Limburg commented on CDI-271:
----------------------------------
What about QualifiedPoint as a superinterface for InjectionPoint?
Provide a way to inject Event metadata into an observer method
--------------------------------------------------------------
Key: CDI-271
URL: https://issues.jboss.org/browse/CDI-271
Project: CDI Specification Issues
Issue Type: Feature Request
Components: Events
Reporter: Arne Limburg
Fix For: 1.1 (Proposed)
Currently there is no way for observer methods to access the qualifiers of the fired
event (i.e. to access @Nonbinding members).
Consider the following example:
{code}
@Inject @MyQualifier
Event<MyObject> event;
public void fireEvent(MyObject object, MyTypeValue type) {
event.select(new MyTypeAnnotationLiteral(type)).fire(object);
}
{code}
Currently no observer can receive the value of MyTypeValue. I suggest to introduce an
interface AnnotatedEvent that extends Annotated and contains this information. It then
could be injected via the InjectionPoint like this:
{code}
public void observeEvent(@Observes @MyType MyObject object, InjectionPoint ip) {
MyType annotation = ip.getAnnotated().getAnnotation(MyType.class);
MyTypeValue value = annotation.value();
...
}
{code}
--
This message is automatically generated by JIRA.
If you think it was sent incorrectly, please contact your JIRA administrators
For more information on JIRA, see: http://www.atlassian.com/software/jira
4166
days inactive
4229
days old
12 comments
5 participants
participants (5)
-
Arne Limburg (JIRA) -
Jens Schumann (JIRA)
-
Jozef Hartinger (JIRA)
-
Mark Struberg (JIRA)
-
Pete Muir (JIRA)