@Override public <T extends Annotation> T getAnnotation(final Class<T> clazz) { if (BusManaged.class.isAssignableFrom(clazz)) { return (T) qualifier; } return param.getAnnotation(clazz); }
public OSGiServiceAnnotatedParameter(AnnotatedParameter parameter) { logger.trace("Entering OSGiServiceAnnotatedParameter : " + "OSGiServiceAnnotatedParameter() with parameter {}", new Object[] {parameter}); this.parameter = parameter; filter = FilterGenerator.makeFilter(parameter.getAnnotations()); annotations.add(filter); //annotations.add(new AnnotationLiteral<OSGiService>() {}); annotations.add(new OSGiServiceAnnotation( parameter.getAnnotation(OSGiService.class).value())); if (parameter.getAnnotation(Required.class) != null) { annotations.add(new AnnotationLiteral<Required>() { }); } for (Annotation annotation : parameter.getAnnotations()) { if (!annotation.annotationType().isAnnotationPresent(Qualifier.class)) { annotations.add(annotation); } } logger.debug("New OSGiServiceAnnotatedParameter constructed {}", this); }
/** * Sole Constructor. * * @param method found handler * @param bm active BeanManager * @throws IllegalArgumentException if method is null, has no params or first param is not annotated with {@link * Handles} */ public HandlerMethodImpl(final AnnotatedMethod<?> method, final BeanManager bm) { if (!HandlerMethodImpl.isHandler(method)) { throw new IllegalArgumentException(MessageFormat.format("{0} is not a valid handler", method)); } final Set<Annotation> tmpQualifiers = new HashSet<Annotation>(); this.handler = method; this.javaMethod = method.getJavaMember(); this.handlerParameter = findHandlerParameter(method); if (!this.handlerParameter.isAnnotationPresent(Handles.class)) { throw new IllegalArgumentException("Method is not annotated with @Handles"); } this.traversalMode = this.handlerParameter.getAnnotation(Handles.class).during(); this.precedence = this.handlerParameter.getAnnotation(Handles.class).precedence(); tmpQualifiers.addAll(Beans.getQualifiers(bm, this.handlerParameter.getAnnotations())); if (tmpQualifiers.isEmpty()) { tmpQualifiers.add(AnyLiteral.INSTANCE); } this.qualifiers = tmpQualifiers; this.beanClass = method.getJavaMember().getDeclaringClass(); this.exceptionType = ((ParameterizedType) this.handlerParameter.getBaseType()).getActualTypeArguments()[0]; }
private <X> void buildInjectionPoints(Bean<?> owner, AnnotatedCallable<X> callable, Collection<InjectionPoint> lists) { List<AnnotatedParameter<X>> parameters = callable.getParameters(); for (AnnotatedParameter<?> parameter : parameters) { // @Observes and @ObservesAsync are not injection point type for method parameters if (parameter.getAnnotation(Observes.class) == null && parameter.getAnnotation(ObservesAsync.class) == null) { lists.add(buildInjectionPoint(owner, parameter, true)); } } }
DefaultValue defaultValue = parameter.getAnnotation(DefaultValue.class); if (defaultValue != null) { mustPatch = true;
protected void checkObserverCondition(AnnotatedParameter<T> annotatedObservesParameter) { if (annotatedObservesParameter.getAnnotation(WithAnnotations.class) != null) { throw new WebBeansConfigurationException("@WithAnnotations must only be used for ProcessAnnotatedType events"); } }
before = handlerParameter.getAnnotation(BeforeHandles.class) != null; ordinal = handlerParameter.getAnnotation(BeforeHandles.class).ordinal(); ordinal = handlerParameter.getAnnotation(Handles.class).ordinal();
private boolean isAnnotated(AnnotatedType<?> type, Class<? extends Annotation> annotation) { for (AnnotatedMethod<?> m : type.getMethods()) { for (AnnotatedParameter<?> p : m.getParameters()) { if (p.getAnnotation(annotation) != null) return true; } } return false; }
DefaultValue defaultValue = parameter.getAnnotation(DefaultValue.class); if (defaultValue != null) { mustPatch = true;
public ContainerEventObserverMethodImpl(AbstractOwbBean<?> bean, AnnotatedMethod<T> annotatedObserverMethod, AnnotatedParameter<T> annotatedObservesParameter) { // we do NOT fire any further events while building this ObserverMethod, e.g for ProcessInjectionPoint... super(bean, annotatedObserverMethod, annotatedObservesParameter, false); WithAnnotations withAnnotationsAnn = annotatedObservesParameter.getAnnotation(WithAnnotations.class); if (withAnnotationsAnn != null) { Type baseType = annotatedObservesParameter.getBaseType(); if (ParameterizedType.class.isInstance(baseType)) { baseType = ParameterizedType.class.cast(baseType).getRawType(); } if (baseType.equals(ProcessAnnotatedType.class)) { withAnnotations = withAnnotationsAnn.value(); } else { throw new WebBeansConfigurationException("WithAnnotations must only be used for ProcessAnnotatedType"); } } else { withAnnotations = null; } }
DefaultValue defaultValue = parameter.getAnnotation(DefaultValue.class); if (defaultValue != null) { mustPatch = true;
private String of(AnnotatedParameter<?> parameter) { if (parameter.isAnnotationPresent(Metric.class)) { Metric metric = parameter.getAnnotation(Metric.class); String name = metric.name().isEmpty() ? getParameterName(parameter) : of(metric.name()); return metric.absolute() | extension.<Boolean>getParameter(UseAbsoluteName).orElse(false) ? name : MetricRegistry.name(parameter.getDeclaringCallable().getJavaMember().getDeclaringClass(), name); } else { return extension.<Boolean>getParameter(UseAbsoluteName).orElse(false) ? getParameterName(parameter) : MetricRegistry.name(parameter.getDeclaringCallable().getJavaMember().getDeclaringClass(), getParameterName(parameter)); } }
AnnotatedParameter<?> param = parameters.get(i); Observes observes = param.getAnnotation(Observes.class);
private String of(AnnotatedParameter<?> parameter) { if (parameter.isAnnotationPresent(Metric.class)) { Metric metric = parameter.getAnnotation(Metric.class); String name = metric.name().isEmpty() ? getParameterName(parameter) : of(metric.name()); return metric.absolute() | extension.<Boolean>getParameter(UseAbsoluteName).orElse(false) ? name : MetricRegistry.name(parameter.getDeclaringCallable().getJavaMember().getDeclaringClass(), name); } else { return extension.<Boolean>getParameter(UseAbsoluteName).orElse(false) ? getParameterName(parameter) : MetricRegistry.name(parameter.getDeclaringCallable().getJavaMember().getDeclaringClass(), getParameterName(parameter)); } }
for (AnnotatedParameter parameter : parameters) Observes observes = parameter.getAnnotation(Observes.class); ObservesAsync observesAsync = parameter.getAnnotation(ObservesAsync.class); if (observes != null || observesAsync != null) Priority prio = parameter.getAnnotation(Priority.class); if (prio != null)
@Override public ObserverMethodConfigurator<T> read(AnnotatedMethod<?> method) { checkArgumentNotNull(method); Set<AnnotatedParameter<?>> eventParameters = method.getParameters().stream() .filter((p) -> p.isAnnotationPresent(Observes.class) || p.isAnnotationPresent(ObservesAsync.class)).collect(Collectors.toSet()); checkEventParams(eventParameters, method.getJavaMember()); AnnotatedParameter<?> eventParameter = eventParameters.iterator().next(); Observes observesAnnotation = eventParameter.getAnnotation(Observes.class); if (observesAnnotation != null) { reception(observesAnnotation.notifyObserver()); transactionPhase(observesAnnotation.during()); } else { reception(eventParameter.getAnnotation(ObservesAsync.class).notifyObserver()); } Priority priority = method.getAnnotation(Priority.class); if (priority != null) { priority(priority.value()); } beanClass(eventParameter.getDeclaringCallable().getDeclaringType().getJavaClass()); observedType(eventParameter.getBaseType()); qualifiers(Configurators.getQualifiers(eventParameter)); return this; }
@Override public ObserverMethodConfigurator<T> read(AnnotatedMethod<?> method) { checkArgumentNotNull(method); Set<AnnotatedParameter<?>> eventParameters = method.getParameters().stream() .filter((p) -> p.isAnnotationPresent(Observes.class) || p.isAnnotationPresent(ObservesAsync.class)).collect(Collectors.toSet()); checkEventParams(eventParameters, method.getJavaMember()); AnnotatedParameter<?> eventParameter = eventParameters.iterator().next(); Observes observesAnnotation = eventParameter.getAnnotation(Observes.class); if (observesAnnotation != null) { reception(observesAnnotation.notifyObserver()); transactionPhase(observesAnnotation.during()); } else { reception(eventParameter.getAnnotation(ObservesAsync.class).notifyObserver()); } Priority priority = method.getAnnotation(Priority.class); if (priority != null) { priority(priority.value()); } beanClass(eventParameter.getDeclaringCallable().getDeclaringType().getJavaClass()); observedType(eventParameter.getBaseType()); qualifiers(Configurators.getQualifiers(eventParameter)); return this; }
@Override public ObserverMethodConfigurator<T> read(AnnotatedMethod<?> method) { checkArgumentNotNull(method); Set<AnnotatedParameter<?>> eventParameters = method.getParameters().stream() .filter((p) -> p.isAnnotationPresent(Observes.class) || p.isAnnotationPresent(ObservesAsync.class)).collect(Collectors.toSet()); checkEventParams(eventParameters, method.getJavaMember()); AnnotatedParameter<?> eventParameter = eventParameters.iterator().next(); Observes observesAnnotation = eventParameter.getAnnotation(Observes.class); if (observesAnnotation != null) { reception(observesAnnotation.notifyObserver()); transactionPhase(observesAnnotation.during()); } else { reception(eventParameter.getAnnotation(ObservesAsync.class).notifyObserver()); } Priority priority = method.getAnnotation(Priority.class); if (priority != null) { priority(priority.value()); } beanClass(eventParameter.getDeclaringCallable().getDeclaringType().getJavaClass()); observedType(eventParameter.getBaseType()); qualifiers(Configurators.getQualifiers(eventParameter)); return this; }
@Override public ObserverMethodConfigurator<T> read(AnnotatedMethod<?> method) { checkArgumentNotNull(method); Set<AnnotatedParameter<?>> eventParameters = method.getParameters().stream() .filter((p) -> p.isAnnotationPresent(Observes.class) || p.isAnnotationPresent(ObservesAsync.class)).collect(Collectors.toSet()); checkEventParams(eventParameters, method.getJavaMember()); AnnotatedParameter<?> eventParameter = eventParameters.iterator().next(); Observes observesAnnotation = eventParameter.getAnnotation(Observes.class); if (observesAnnotation != null) { reception(observesAnnotation.notifyObserver()); transactionPhase(observesAnnotation.during()); } else { reception(eventParameter.getAnnotation(ObservesAsync.class).notifyObserver()); } Priority priority = method.getAnnotation(Priority.class); if (priority != null) { priority(priority.value()); } beanClass(eventParameter.getDeclaringCallable().getDeclaringType().getJavaClass()); observedType(eventParameter.getBaseType()); qualifiers(Configurators.getQualifiers(eventParameter)); return this; }
@Override public ObserverMethodConfigurator<T> read(AnnotatedMethod<?> method) { checkArgumentNotNull(method); Set<AnnotatedParameter<?>> eventParameters = method.getParameters().stream() .filter((p) -> p.isAnnotationPresent(Observes.class) || p.isAnnotationPresent(ObservesAsync.class)).collect(Collectors.toSet()); checkEventParams(eventParameters, method.getJavaMember()); AnnotatedParameter<?> eventParameter = eventParameters.iterator().next(); Observes observesAnnotation = eventParameter.getAnnotation(Observes.class); if (observesAnnotation != null) { reception(observesAnnotation.notifyObserver()); transactionPhase(observesAnnotation.during()); } else { reception(eventParameter.getAnnotation(ObservesAsync.class).notifyObserver()); } Priority priority = method.getAnnotation(Priority.class); if (priority != null) { priority(priority.value()); } beanClass(eventParameter.getDeclaringCallable().getDeclaringType().getJavaClass()); observedType(eventParameter.getBaseType()); qualifiers(Configurators.getQualifiers(eventParameter)); return this; }