/** * Tests an observer method to see if it is transactional. * * @param observer The observer method * @return true if the observer method is annotated as transactional */ public static TransactionPhase getTransactionalPhase(EnhancedAnnotatedMethod<?, ?> observer) { EnhancedAnnotatedParameter<?, ?> parameter = observer.getEnhancedParameters(Observes.class).iterator().next(); return parameter.getAnnotation(Observes.class).during(); }
protected void checkRequiredTypeAnnotations(EnhancedAnnotatedParameter<?, ?> eventParameter) { if (eventParameter.isAnnotationPresent(WithAnnotations.class)) { throw EventLogger.LOG .invalidWithAnnotations(this, Formats.formatAsStackTraceElement(eventParameter.getDeclaringEnhancedCallable().getJavaMember())); } }
protected InferringParameterInjectionPointAttributes(EnhancedAnnotatedParameter<T, X> parameter, Bean<?> bean, Class<?> declaringComponentClass, BeanManagerImpl manager) { super(parameter, manager.getContextId(), bean, SharedObjectCache.instance(manager).getSharedSet(parameter.getQualifiers()), declaringComponentClass); this.parameter = parameter.slim(); }
this.beanManager = manager; this.declaringBean = declaringBean; this.observerMethod = initMethodInjectionPoint(observer, declaringBean, manager); EnhancedAnnotatedParameter<?, ? super X> eventParameter = observer.getEnhancedParameters(Observes.class).get(0); this.eventType = new HierarchyDiscovery(declaringBean.getBeanClass()).resolveType(eventParameter.getBaseType()); this.id = createId(observer, declaringBean); this.bindings = manager.getServices().get(SharedObjectCache.class) .getSharedSet(observer.getEnhancedParameters(Observes.class).get(0).getMetaAnnotations(Qualifier.class)); Observes observesAnnotation = observer.getEnhancedParameters(Observes.class).get(0).getAnnotation(Observes.class); this.reception = observesAnnotation.notifyObserver(); transactionPhase = ObserverFactory.getTransactionalPhase(observer); for (ParameterInjectionPoint<?, ?> injectionPoint : observerMethod.getParameterInjectionPoints()) { if (injectionPoint instanceof SpecialParameterInjectionPoint) { continue; this.isStatic = observer.isStatic(); this.eventMetadataRequired = initMetadataRequired(this.injectionPoints); this.notificationStrategy = MethodInvocationStrategy.forObserver(observerMethod, beanManager);
List<EnhancedAnnotatedParameter<?, Y>> eventObjects = annotated.getEnhancedParameters(Observes.class); eventObjects.addAll(annotated.getEnhancedParameters(ObservesAsync.class)); if (this.reception.equals(Reception.IF_EXISTS) && declaringBean.getScope().equals(Dependent.class)) { throw EventLogger.LOG.invalidScopedConditionalObserver(this, Formats.formatAsStackTraceElement(annotated.getJavaMember())); throw EventLogger.LOG.multipleEventParameters(this, Formats.formatAsStackTraceElement(annotated.getJavaMember())); checkRequiredTypeAnnotations(eventParameter); List<?> disposeParams = annotated.getEnhancedParameters(Disposes.class); if (disposeParams.size() > 0) { throw EventLogger.LOG.invalidDisposesParameter(this, Formats.formatAsStackTraceElement(annotated.getJavaMember())); if (this.observerMethod.getAnnotated().isAnnotationPresent(Produces.class)) { throw EventLogger.LOG.invalidProducer(this, Formats.formatAsStackTraceElement(annotated.getJavaMember())); if (this.observerMethod.getAnnotated().isAnnotationPresent(Inject.class)) { throw EventLogger.LOG.invalidInitializer(this, Formats.formatAsStackTraceElement(annotated.getJavaMember())); for (EnhancedAnnotatedParameter<?, ?> parameter : annotated.getEnhancedParameters()) { if (containerLifecycleObserverMethod && !parameter.isAnnotationPresent(Observes.class) && !parameter.isAnnotationPresent(ObservesAsync.class) && !BeanManager.class.equals(parameter.getBaseType())) { throw EventLogger.LOG.invalidInjectionPoint(this, Formats.formatAsStackTraceElement(annotated.getJavaMember()));
/** * A disposer method is bound to a producer if the producer is assignable to the disposed parameter. * * @param enhancedDisposedParameter * @return the set of required qualifiers for the given disposed parameter */ private Set<QualifierInstance> getRequiredQualifiers(EnhancedAnnotatedParameter<?, ? super X> enhancedDisposedParameter) { Set<Annotation> disposedParameterQualifiers = enhancedDisposedParameter.getMetaAnnotations(Qualifier.class); if (disposedParameterQualifiers.isEmpty()) { disposedParameterQualifiers = Collections.<Annotation> singleton(Default.Literal.INSTANCE); } return beanManager.getServices().get(MetaAnnotationStore.class).getQualifierInstances(disposedParameterQualifiers); } }
@Override protected void checkRequiredTypeAnnotations(EnhancedAnnotatedParameter<?, ?> eventParameter) { Class<?> rawObserverType = Reflections.getRawType(getObservedType()); boolean isProcessAnnotatedType = rawObserverType.equals(ProcessAnnotatedType.class) || rawObserverType.equals(ProcessSyntheticAnnotatedType.class); if (!isProcessAnnotatedType && !requiredTypeAnnotations.isEmpty()) { throw EventLogger.LOG .invalidWithAnnotations(this, Formats.formatAsStackTraceElement(eventParameter.getDeclaringEnhancedCallable().getJavaMember())); } if (isProcessAnnotatedType && requiredTypeAnnotations.isEmpty()) { Type[] typeArguments = eventParameter.getActualTypeArguments(); if (typeArguments.length == 0 || Reflections.isUnboundedWildcard(typeArguments[0]) || Reflections.isUnboundedTypeVariable(typeArguments[0])) { EventLogger.LOG.unrestrictedProcessAnnotatedTypes(this); } } }
private boolean isSpecialParameter(EnhancedAnnotatedParameter<?, ?> parameter) { return parameter.isAnnotationPresent(Disposes.class) || parameter.isAnnotationPresent(Observes.class); } }
private static <X> int initSpecialInjectionPointIndex(EnhancedAnnotatedMethod<?, X> enhancedMethod, Class<? extends Annotation> specialParameterMarker) { if (specialParameterMarker == null) { return -1; } List<EnhancedAnnotatedParameter<?, X>> parameters = enhancedMethod.getEnhancedParameters(specialParameterMarker); if (parameters.isEmpty()) { throw new org.jboss.weld.exceptions.IllegalArgumentException("Not a disposer nor observer method: " + enhancedMethod); } return parameters.get(0).getPosition(); }
protected Set<Class<? extends Annotation>> initRequiredTypeAnnotations(EnhancedAnnotatedMethod<T, ? super X> observer) { EnhancedAnnotatedParameter<?, ? super X> eventParameter = observer.getEnhancedParameters(Observes.class).get(0); WithAnnotations annotation = eventParameter.getAnnotation(WithAnnotations.class); if (annotation != null) { return ImmutableSet.of(annotation.value()); } return Collections.emptySet(); }
@Override public AnnotatedParameter<X> slim() { return delegate().slim(); } }
public ConstructorSignatureImpl(EnhancedAnnotatedConstructor<?> method) { this.parameterTypes = new String[method.getEnhancedParameters().size()]; for (int i = 0; i < method.getEnhancedParameters().size(); i++) { parameterTypes[i] = method.getEnhancedParameters().get(i).getJavaClass().getName(); } }
protected Set<Class<? extends Annotation>> initRequiredTypeAnnotations(EnhancedAnnotatedMethod<T, ? super X> observer) { EnhancedAnnotatedParameter<?, ? super X> eventParameter = getEventParameter(observer); WithAnnotations annotation = eventParameter.getAnnotation(WithAnnotations.class); if (annotation != null) { return ImmutableSet.<Class<? extends Annotation>>of(annotation.value()); } return Collections.emptySet(); }
public EnhancedAnnotatedCallable<?, X, ?> getDeclaringEnhancedCallable() { return delegate().getDeclaringEnhancedCallable(); }
public int getPosition() { return delegate().getPosition(); }
final EnhancedAnnotatedParameter<?, ? super X> eventParameter = getEventParameter(observer); if (isAsync) { this.reception = eventParameter.getAnnotation(ObservesAsync.class).notifyObserver(); this.reception = eventParameter.getAnnotation(Observes.class).notifyObserver(); this.transactionPhase = ObserverFactory.getTransactionalPhase(observer); this.bindings = manager.getServices().get(SharedObjectCache.class) .getSharedSet(eventParameter.getMetaAnnotations(Qualifier.class)); this.eventType = new HierarchyDiscovery(declaringBean.getBeanClass()).resolveType(eventParameter.getBaseType()); for (ParameterInjectionPoint<?, ?> injectionPoint : observerMethod.getParameterInjectionPoints()) { if (injectionPoint instanceof SpecialParameterInjectionPoint) { continue; Priority priority = eventParameter.getAnnotation(Priority.class); if (priority == null) { this.priority = DEFAULT_PRIORITY; this.priority = priority.value(); this.isStatic = observer.isStatic(); this.eventMetadataRequired = initMetadataRequired(this.injectionPoints); this.notificationStrategy = MethodInvocationStrategy.forObserver(observerMethod, beanManager);
List<EnhancedAnnotatedParameter<?, Y>> eventObjects = annotated.getEnhancedParameters(Observes.class); eventObjects.addAll(annotated.getEnhancedParameters(ObservesAsync.class)); if (this.reception.equals(Reception.IF_EXISTS) && declaringBean.getScope().equals(Dependent.class)) { throw EventLogger.LOG.invalidScopedConditionalObserver(this, Formats.formatAsStackTraceElement(annotated.getJavaMember())); throw EventLogger.LOG.multipleEventParameters(this, Formats.formatAsStackTraceElement(annotated.getJavaMember())); checkRequiredTypeAnnotations(eventParameter); List<?> disposeParams = annotated.getEnhancedParameters(Disposes.class); if (disposeParams.size() > 0) { throw EventLogger.LOG.invalidDisposesParameter(this, Formats.formatAsStackTraceElement(annotated.getJavaMember())); if (this.observerMethod.getAnnotated().isAnnotationPresent(Produces.class)) { throw EventLogger.LOG.invalidProducer(this, Formats.formatAsStackTraceElement(annotated.getJavaMember())); if (this.observerMethod.getAnnotated().isAnnotationPresent(Inject.class)) { throw EventLogger.LOG.invalidInitializer(this, Formats.formatAsStackTraceElement(annotated.getJavaMember())); for (EnhancedAnnotatedParameter<?, ?> parameter : annotated.getEnhancedParameters()) { if (containerLifecycleObserverMethod && !parameter.isAnnotationPresent(Observes.class) && !parameter.isAnnotationPresent(ObservesAsync.class) && !BeanManager.class.equals(parameter.getBaseType())) { throw EventLogger.LOG.invalidInjectionPoint(this, Formats.formatAsStackTraceElement(annotated.getJavaMember()));
/** * A disposer method is bound to a producer if the producer is assignable to the disposed parameter. * * @param enhancedDisposedParameter * @return the set of required qualifiers for the given disposed parameter */ private Set<QualifierInstance> getRequiredQualifiers(EnhancedAnnotatedParameter<?, ? super X> enhancedDisposedParameter) { Set<Annotation> disposedParameterQualifiers = enhancedDisposedParameter.getMetaAnnotations(Qualifier.class); if (disposedParameterQualifiers.isEmpty()) { disposedParameterQualifiers = Collections.<Annotation> singleton(Default.Literal.INSTANCE); } return beanManager.getServices().get(MetaAnnotationStore.class).getQualifierInstances(disposedParameterQualifiers); } }
@Override protected void checkRequiredTypeAnnotations(EnhancedAnnotatedParameter<?, ?> eventParameter) { Class<?> rawObserverType = Reflections.getRawType(getObservedType()); boolean isProcessAnnotatedType = rawObserverType.equals(ProcessAnnotatedType.class) || rawObserverType.equals(ProcessSyntheticAnnotatedType.class); if (!isProcessAnnotatedType && !requiredTypeAnnotations.isEmpty()) { throw EventLogger.LOG .invalidWithAnnotations(this, Formats.formatAsStackTraceElement(eventParameter.getDeclaringEnhancedCallable().getJavaMember())); } if (isProcessAnnotatedType && requiredTypeAnnotations.isEmpty()) { Type[] typeArguments = eventParameter.getActualTypeArguments(); if (typeArguments.length == 0 || Reflections.isUnboundedWildcard(typeArguments[0]) || Reflections.isUnboundedTypeVariable(typeArguments[0])) { EventLogger.LOG.unrestrictedProcessAnnotatedTypes(this); } } }
private static boolean initHasTransientReference(List<? extends EnhancedAnnotatedParameter<?, ?>> parameters) { for (EnhancedAnnotatedParameter<?, ?> parameter : parameters) { if (parameter.isAnnotationPresent(TransientReference.class)) { return true; } } return false; }