-
Notifications
You must be signed in to change notification settings - Fork 78
/
SyntheticObserverBuilder.java
338 lines (307 loc) · 15.1 KB
/
SyntheticObserverBuilder.java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
package jakarta.enterprise.inject.build.compatible.spi;
import jakarta.enterprise.event.TransactionPhase;
import jakarta.enterprise.lang.model.AnnotationInfo;
import jakarta.enterprise.lang.model.declarations.ClassInfo;
import java.lang.annotation.Annotation;
/**
* Builder for synthetic observers.
* Instances are not reusable. For each synthetic observer, new instance
* must be created by {@link SyntheticComponents#addObserver(Class)}.
*
* @param <T> the observed event type of this synthetic observer
* @since 4.0
*/
public interface SyntheticObserverBuilder<T> {
/**
* Sets the bean class that "declares" this synthetic observer.
* <p>
* If not called, the class declaring the extension which creates this synthetic observer is used.
*
* @param declaringClass bean class that "declares" this synthetic observer, must not be {@code null}
* @return this {@code SyntheticObserverBuilder}
* @throws IllegalStateException if this method is called multiple times
*/
SyntheticObserverBuilder<T> declaringClass(Class<?> declaringClass);
/**
* Sets the bean class that "declares" this synthetic observer.
* <p>
* If not called, the class declaring the extension which creates this synthetic observer is used.
*
* @param declaringClass bean class that "declares" this synthetic observer, must not be {@code null}
* @return this {@code SyntheticObserverBuilder}
* @throws IllegalStateException if this method is called multiple times
*/
SyntheticObserverBuilder<T> declaringClass(ClassInfo declaringClass);
/**
* Adds a marker annotation of given type to the set of qualifiers of this synthetic observer.
* This method may be called multiple times to add multiple qualifiers.
* <p>
* If not called, this synthetic observer will have no qualifier.
*
* @param annotationType the type of the marker annotation, must not be {@code null}
* @return this {@code SyntheticObserverBuilder}
*/
SyntheticObserverBuilder<T> qualifier(Class<? extends Annotation> annotationType);
/**
* Adds given annotation to the set of qualifiers of this synthetic observer.
* This method may be called multiple times to add multiple qualifiers.
* <p>
* If not called, this synthetic observer will have no qualifier.
*
* @param qualifierAnnotation the annotation, must not be {@code null}
* @return this {@code SyntheticObserverBuilder}
*/
SyntheticObserverBuilder<T> qualifier(AnnotationInfo qualifierAnnotation);
/**
* Adds given annotation to the set of qualifiers of this synthetic observer.
* This method may be called multiple times to add multiple qualifiers.
* <p>
* If not called, this synthetic observer will have no qualifier.
*
* @param qualifierAnnotation the annotation, must not be {@code null}
* @return this {@code SyntheticObserverBuilder}
*/
SyntheticObserverBuilder<T> qualifier(Annotation qualifierAnnotation);
/**
* Sets a priority of this synthetic observer.
* <p>
* If not called, this synthetic observer will have a default priority
* of {@link jakarta.interceptor.Interceptor.Priority#APPLICATION Priority.APPLICATION} + 500.
*
* @param priority the priority of this synthetic observer
* @return this {@code SyntheticObserverBuilder}
* @throws IllegalStateException if this method is called multiple times
*/
SyntheticObserverBuilder<T> priority(int priority);
/**
* Marks this synthetic observer as asynchronous if desired.
* <p>
* If not called, this synthetic observer will not be asynchronous.
*
* @param isAsync whether this synthetic observer should be asynchronous
* @return this {@code SyntheticObserverBuilder}
* @throws IllegalStateException if this method is called multiple times
*/
SyntheticObserverBuilder<T> async(boolean isAsync);
/**
* Sets the {@link TransactionPhase} during which this synthetic observer should be notified.
* If anything else than {@link TransactionPhase#IN_PROGRESS} is passed, this synthetic observer
* will be a transactional observer.
* <p>
* If not called, this synthetic observer will not be a transactional observer.
* In other words, the default is {@link TransactionPhase#IN_PROGRESS}.
* <p>
* Note that transactional observers cannot be asynchronous. If this synthetic observer
* is configured to be both transactional and asynchronous, its registration will fail.
*
* @param transactionPhase the {@link TransactionPhase}, must not be {@code null}
* @return this {@code SyntheticObserverBuilder}
* @throws IllegalStateException if this method is called multiple times
*/
SyntheticObserverBuilder<T> transactionPhase(TransactionPhase transactionPhase);
/**
* Adds a {@code boolean}-valued parameter to the parameter map. The parameter map is passed
* to the {@linkplain SyntheticObserver event notification} function when the event is fired.
*
* @param key the parameter key, must not be {@code null}
* @param value the parameter value
* @return this {@code SyntheticObserverBuilder}
*/
SyntheticObserverBuilder<T> withParam(String key, boolean value);
/**
* Adds a {@code boolean} array-valued parameter to the parameter map. The parameter map is passed
* to the {@linkplain SyntheticObserver event notification} function when the event is fired.
*
* @param key the parameter key, must not be {@code null}
* @param value the parameter value
* @return this {@code SyntheticObserverBuilder}
*/
SyntheticObserverBuilder<T> withParam(String key, boolean[] value);
/**
* Adds an {@code int}-valued parameter to the parameter map. The parameter map is passed
* to the {@linkplain SyntheticObserver event notification} function when the event is fired.
*
* @param key the parameter key, must not be {@code null}
* @param value the parameter value
* @return this {@code SyntheticObserverBuilder}
*/
SyntheticObserverBuilder<T> withParam(String key, int value);
/**
* Adds an {@code int} array-valued parameter to the parameter map. The parameter map is passed
* to the {@linkplain SyntheticObserver event notification} function when the event is fired.
*
* @param key the parameter key, must not be {@code null}
* @param value the parameter value
* @return this {@code SyntheticObserverBuilder}
*/
SyntheticObserverBuilder<T> withParam(String key, int[] value);
/**
* Adds a {@code long}-valued parameter to the parameter map. The parameter map is passed
* to the {@linkplain SyntheticObserver event notification} function when the event is fired.
*
* @param key the parameter key, must not be {@code null}
* @param value the parameter value
* @return this {@code SyntheticObserverBuilder}
*/
SyntheticObserverBuilder<T> withParam(String key, long value);
/**
* Adds a {@code long} array-valued parameter to the parameter map. The parameter map is passed
* to the {@linkplain SyntheticObserver event notification} function when the event is fired.
*
* @param key the parameter key, must not be {@code null}
* @param value the parameter value
* @return this {@code SyntheticObserverBuilder}
*/
SyntheticObserverBuilder<T> withParam(String key, long[] value);
/**
* Adds a {@code double}-valued parameter to the parameter map. The parameter map is passed
* to the {@linkplain SyntheticObserver event notification} function when the event is fired.
*
* @param key the parameter key, must not be {@code null}
* @param value the parameter value
* @return this {@code SyntheticObserverBuilder}
*/
SyntheticObserverBuilder<T> withParam(String key, double value);
/**
* Adds a {@code double} array-valued parameter to the parameter map. The parameter map is passed
* to the {@linkplain SyntheticObserver event notification} function when the event is fired.
*
* @param key the parameter key, must not be {@code null}
* @param value the parameter value
* @return this {@code SyntheticObserverBuilder}
*/
SyntheticObserverBuilder<T> withParam(String key, double[] value);
/**
* Adds a {@code String}-valued parameter to the parameter map. The parameter map is passed
* to the {@linkplain SyntheticObserver event notification} function when the event is fired.
*
* @param key the parameter key, must not be {@code null}
* @param value the parameter value
* @return this {@code SyntheticObserverBuilder}
*/
SyntheticObserverBuilder<T> withParam(String key, String value);
/**
* Adds a {@code String} array-valued parameter to the parameter map. The parameter map is passed
* to the {@linkplain SyntheticObserver event notification} function when the event is fired.
*
* @param key the parameter key, must not be {@code null}
* @param value the parameter value
* @return this {@code SyntheticObserverBuilder}
*/
SyntheticObserverBuilder<T> withParam(String key, String[] value);
/**
* Adds an enum-valued parameter to the parameter map. The parameter map is passed
* to the {@linkplain SyntheticObserver event notification} function when the event is fired.
*
* @param key the parameter key, must not be {@code null}
* @param value the parameter value
* @return this {@code SyntheticObserverBuilder}
*/
SyntheticObserverBuilder<T> withParam(String key, Enum<?> value);
/**
* Adds an enum array-valued parameter to the parameter map. The parameter map is passed
* to the {@linkplain SyntheticObserver event notification} function when the event is fired.
*
* @param key the parameter key, must not be {@code null}
* @param value the parameter value
* @return this {@code SyntheticObserverBuilder}
*/
SyntheticObserverBuilder<T> withParam(String key, Enum<?>[] value);
/**
* Adds a {@code Class}-valued parameter to the parameter map. The parameter map is passed
* to the {@linkplain SyntheticObserver event notification} function when the event is fired.
*
* @param key the parameter key, must not be {@code null}
* @param value the parameter value
* @return this {@code SyntheticObserverBuilder}
*/
SyntheticObserverBuilder<T> withParam(String key, Class<?> value);
/**
* Adds a {@code Class}-valued parameter to the parameter map. The parameter map is passed
* to the {@linkplain SyntheticObserver event notification} function when the event is fired.
* <p>
* When looked up from the parameter map in the event notification function, the value will be
* an instance of {@link Class}, <em>not</em> a {@code ClassInfo}.
*
* @param key the parameter key, must not be {@code null}
* @param value the parameter value
* @return this {@code SyntheticObserverBuilder}
*/
SyntheticObserverBuilder<T> withParam(String key, ClassInfo value);
/**
* Adds a {@code Class} array-valued parameter to the parameter map. The parameter map is passed
* to the {@linkplain SyntheticObserver event notification} function when the event is fired.
*
* @param key the parameter key, must not be {@code null}
* @param value the parameter value
* @return this {@code SyntheticObserverBuilder}
*/
SyntheticObserverBuilder<T> withParam(String key, Class<?>[] value);
/**
* Adds a {@code Class} array-valued parameter to the parameter map. The parameter map is passed
* to the {@linkplain SyntheticObserver event notification} function when the event is fired.
* <p>
* When looked up from the parameter map in the event notification function, the values will be
* instances of {@link Class}, <em>not</em> {@code ClassInfo}.
*
* @param key the parameter key, must not be {@code null}
* @param value the parameter value
* @return this {@code SyntheticObserverBuilder}
*/
SyntheticObserverBuilder<T> withParam(String key, ClassInfo[] value);
/**
* Adds an annotation-valued parameter to the parameter map. The parameter map is passed
* to the {@linkplain SyntheticObserver event notification} function when the event is fired.
* <p>
* When looked up from the parameter map in the event notification function, the value will be
* an instance of the annotation type, <em>not</em> an {@code AnnotationInfo}.
*
* @param key the parameter key, must not be {@code null}
* @param value the parameter value
* @return this {@code SyntheticObserverBuilder}
*/
SyntheticObserverBuilder<T> withParam(String key, AnnotationInfo value);
/**
* Adds an annotation-valued parameter to the parameter map. The parameter map is passed
* to the {@linkplain SyntheticObserver event notification} function when the event is fired.
*
* @param key the parameter key, must not be {@code null}
* @param value the parameter value
* @return this {@code SyntheticObserverBuilder}
*/
SyntheticObserverBuilder<T> withParam(String key, Annotation value);
/**
* Adds an annotation array-valued parameter to the parameter map. The parameter map is passed
* to the {@linkplain SyntheticObserver event notification} function when the event is fired.
* <p>
* When looked up from the parameter map in the event notification function, the values will be
* instances of the corresponding annotation types, <em>not</em> {@code AnnotationInfo}.
*
* @param key the parameter key, must not be {@code null}
* @param value the parameter value
* @return this {@code SyntheticObserverBuilder}
*/
SyntheticObserverBuilder<T> withParam(String key, AnnotationInfo[] value);
/**
* Adds an annotation array-valued parameter to the parameter map. The parameter map is passed
* to the {@linkplain SyntheticObserver event notification} function when the event is fired.
*
* @param key the parameter key, must not be {@code null}
* @param value the parameter value
* @return this {@code SyntheticObserverBuilder}
*/
SyntheticObserverBuilder<T> withParam(String key, Annotation[] value);
/**
* Sets the class of the synthetic observer {@linkplain SyntheticObserver event notification} function.
* CDI container will create an instance of the event notification function every time when it needs
* to notify the synthetic observer. The class must be {@code public} and have a {@code public}
* zero-parameter constructor; it must not be a bean.
* <p>
* If not called, the synthetic observer registration will fail.
*
* @param observerClass the {@linkplain SyntheticObserver event notification} function class, must not be {@code null}
* @return this {@code SyntheticObserverBuilder}
* @throws IllegalStateException if this method is called multiple times
*/
SyntheticObserverBuilder<T> observeWith(Class<? extends SyntheticObserver<T>> observerClass);
}