@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); } } }
public Package getPackage() { return declaringMember.getPackage(); }
protected void checkRequiredTypeAnnotations(EnhancedAnnotatedParameter<?, ?> eventParameter) { if (eventParameter.isAnnotationPresent(WithAnnotations.class)) { throw EventLogger.LOG .invalidWithAnnotations(this, Formats.formatAsStackTraceElement(eventParameter.getDeclaringEnhancedCallable().getJavaMember())); } }
public <X> EnhancedAnnotatedParameter<?, X> loadEnhancedParameter(AnnotatedParameter<X> parameter, String bdaId) { if (parameter instanceof EnhancedAnnotatedParameter<?, ?>) { return Reflections.cast(parameter); } EnhancedAnnotatedCallable<?, X, Member> callable = loadEnhancedMember(parameter.getDeclaringCallable(), bdaId); return callable.getEnhancedParameters().get(parameter.getPosition()); }
protected AbstractCallableInjectionPoint(EnhancedAnnotatedCallable<T, X, S> callable, Bean<?> declaringBean, Class<?> declaringComponentClass, boolean observerOrDisposer, InjectionPointFactory factory, BeanManagerImpl manager) { this.declaringBean = declaringBean; this.parameters = factory.getParameterInjectionPoints(callable, declaringBean, declaringComponentClass, manager, observerOrDisposer); if (observerOrDisposer) { this.injectionPoints = cast(InjectionPoints.filterOutSpecialParameterInjectionPoints(parameters)); } else { this.injectionPoints = new ListToSet<InjectionPoint>() { @Override protected List<InjectionPoint> delegate() { return cast(getParameterInjectionPoints()); } }; } this.hasTransientReferenceParameter = initHasTransientReference(callable.getEnhancedParameters()); }
public <X> List<ParameterInjectionPoint<?, X>> getParameterInjectionPoints(EnhancedAnnotatedCallable<?, X, ?> callable, Bean<?> declaringBean, Class<?> declaringComponentClass, BeanManagerImpl manager, boolean observerOrDisposer) { List<ParameterInjectionPoint<?, X>> parameters = new ArrayList<ParameterInjectionPoint<?, X>>(); /* * bean that the injection point belongs to this is null for observer and disposer methods */ Bean<?> bean = null; if (!observerOrDisposer) { bean = declaringBean; } for (EnhancedAnnotatedParameter<?, X> parameter : callable.getEnhancedParameters()) { if (isSpecialParameter(parameter)) { parameters.add(SpecialParameterInjectionPoint.of(parameter, bean, declaringBean.getBeanClass(), manager)); } else { parameters.add(createParameterInjectionPoint(parameter, bean, declaringComponentClass, manager)); } } return immutableListView(parameters); }
protected AbstractCallableInjectionPoint(EnhancedAnnotatedCallable<T, X, S> callable, Bean<?> declaringBean, Class<?> declaringComponentClass, boolean observerOrDisposer, InjectionPointFactory factory, BeanManagerImpl manager) { this.declaringBean = declaringBean; this.parameters = factory.getParameterInjectionPoints(callable, declaringBean, declaringComponentClass, manager, observerOrDisposer); if (observerOrDisposer) { this.injectionPoints = InjectionPoints.filterOutSpecialParameterInjectionPoints(parameters); } else { this.injectionPoints = new ListToSet<InjectionPoint>() { @Override protected List<InjectionPoint> delegate() { return cast(getParameterInjectionPoints()); } }; } this.hasTransientReferenceParameter = initHasTransientReference(callable.getEnhancedParameters()); }
public EnhancedAnnotatedType<X> getDeclaringType() { return getDeclaringEnhancedCallable().getDeclaringType(); }
protected void checkRequiredTypeAnnotations(EnhancedAnnotatedParameter<?, ?> eventParameter) { if (eventParameter.isAnnotationPresent(WithAnnotations.class)) { throw EventLogger.LOG .invalidWithAnnotations(this, Formats.formatAsStackTraceElement(eventParameter.getDeclaringEnhancedCallable().getJavaMember())); } }
public <X> EnhancedAnnotatedParameter<?, X> loadEnhancedParameter(AnnotatedParameter<X> parameter, String bdaId) { if (parameter instanceof EnhancedAnnotatedParameter<?, ?>) { return Reflections.cast(parameter); } EnhancedAnnotatedCallable<?, X, Member> callable = loadEnhancedMember(parameter.getDeclaringCallable(), bdaId); return callable.getEnhancedParameters().get(parameter.getPosition()); }
public <X> List<ParameterInjectionPoint<?, X>> getParameterInjectionPoints(EnhancedAnnotatedCallable<?, X, ?> callable, Bean<?> declaringBean, Class<?> declaringComponentClass, BeanManagerImpl manager, boolean observerOrDisposer) { List<ParameterInjectionPoint<?, X>> parameters = new ArrayList<ParameterInjectionPoint<?, X>>(); /* * bean that the injection point belongs to this is null for observer and disposer methods */ Bean<?> bean = null; if (!observerOrDisposer) { bean = declaringBean; } for (EnhancedAnnotatedParameter<?, X> parameter : callable.getEnhancedParameters()) { if (isSpecialParameter(parameter)) { parameters.add(SpecialParameterInjectionPoint.of(parameter, bean, declaringBean.getBeanClass(), manager)); } else { parameters.add(createParameterInjectionPoint(parameter, bean, declaringComponentClass, manager)); } } return ImmutableList.copyOf(parameters); }
protected AbstractCallableInjectionPoint(EnhancedAnnotatedCallable<T, X, S> callable, Bean<?> declaringBean, Class<?> declaringComponentClass, boolean observerOrDisposer, InjectionPointFactory factory, BeanManagerImpl manager) { this.declaringBean = declaringBean; this.parameters = factory.getParameterInjectionPoints(callable, declaringBean, declaringComponentClass, manager, observerOrDisposer); if (observerOrDisposer) { this.injectionPoints = InjectionPoints.filterOutSpecialParameterInjectionPoints(parameters); } else { this.injectionPoints = new ListToSet<InjectionPoint>() { @Override protected List<InjectionPoint> delegate() { return cast(getParameterInjectionPoints()); } }; } this.hasTransientReferenceParameter = initHasTransientReference(callable.getEnhancedParameters()); }
public EnhancedAnnotatedType<X> getDeclaringType() { return getDeclaringEnhancedCallable().getDeclaringType(); }
@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); } } }
protected void checkRequiredTypeAnnotations(EnhancedAnnotatedParameter<?, ?> eventParameter) { if (eventParameter.isAnnotationPresent(WithAnnotations.class)) { throw EventLogger.LOG .invalidWithAnnotations(this, Formats.formatAsStackTraceElement(eventParameter.getDeclaringEnhancedCallable().getJavaMember())); } }
public <X> EnhancedAnnotatedParameter<?, X> loadEnhancedParameter(AnnotatedParameter<X> parameter, String bdaId) { if (parameter instanceof EnhancedAnnotatedParameter<?, ?>) { return Reflections.cast(parameter); } EnhancedAnnotatedCallable<?, X, Member> callable = loadEnhancedMember(parameter.getDeclaringCallable(), bdaId); return callable.getEnhancedParameters().get(parameter.getPosition()); }
public <X> List<ParameterInjectionPoint<?, X>> getParameterInjectionPoints(EnhancedAnnotatedCallable<?, X, ?> callable, Bean<?> declaringBean, Class<?> declaringComponentClass, BeanManagerImpl manager, boolean observerOrDisposer) { List<ParameterInjectionPoint<?, X>> parameters = new ArrayList<ParameterInjectionPoint<?, X>>(); /* * bean that the injection point belongs to this is null for observer and disposer methods */ Bean<?> bean = null; if (!observerOrDisposer) { bean = declaringBean; } for (EnhancedAnnotatedParameter<?, X> parameter : callable.getEnhancedParameters()) { if (isSpecialParameter(parameter)) { parameters.add(SpecialParameterInjectionPoint.of(parameter, bean, declaringBean.getBeanClass(), manager)); } else { parameters.add(createParameterInjectionPoint(parameter, bean, declaringComponentClass, manager)); } } return ImmutableList.copyOf(parameters); }
protected AbstractCallableInjectionPoint(EnhancedAnnotatedCallable<T, X, S> callable, Bean<?> declaringBean, Class<?> declaringComponentClass, boolean observerOrDisposer, InjectionPointFactory factory, BeanManagerImpl manager) { this.declaringBean = declaringBean; this.parameters = factory.getParameterInjectionPoints(callable, declaringBean, declaringComponentClass, manager, observerOrDisposer); if (observerOrDisposer) { this.injectionPoints = InjectionPoints.filterOutSpecialParameterInjectionPoints(parameters); } else { this.injectionPoints = new ListToSet<InjectionPoint>() { @Override protected List<InjectionPoint> delegate() { return cast(getParameterInjectionPoints()); } }; } this.hasTransientReferenceParameter = initHasTransientReference(callable.getEnhancedParameters()); }
public EnhancedAnnotatedType<X> getDeclaringType() { return getDeclaringEnhancedCallable().getDeclaringType(); }
public Package getPackage() { return declaringMember.getPackage(); }