private boolean isCacheKeyParam(List<AnnotatedParameter<?>> params) { for (AnnotatedParameter<?> param : params) { if (param.isAnnotationPresent(CacheKeyParam.class)) { return true; } } return false; }
@Override public boolean isAnnotationPresent(final Class<? extends Annotation> clazz) { if (BusManaged.class.isAssignableFrom(clazz)) { return true; } return param.isAnnotationPresent(clazz); }
private boolean isDisposes(AnnotatedMethod<? super X> method) { for (AnnotatedParameter<? super X> param : method.getParameters()) { if (param.isAnnotationPresent(Disposes.class)) return true; } return false; }
private AnnotatedParameter<?> getCacheValueParam() { for (AnnotatedParameter<?> param : getParameters()) { if (param.isAnnotationPresent(CacheValue.class)) { return param; } } return null; }
private boolean hasEventParameter(AnnotatedMethod<?> annotatedMethod) { for (AnnotatedParameter<?> param : annotatedMethod.getParameters()) { if (param.isAnnotationPresent(Observes.class)) { return true; } } return false; }
public static <X> AnnotatedParameter<X> getFirstAnnotatedParameter(AnnotatedMethod<X> annotatedMethod, Class<? extends Annotation> annotation) { for (AnnotatedParameter<X> annotatedParameter: annotatedMethod.getParameters()) { if (annotatedParameter.isAnnotationPresent(annotation)) { return annotatedParameter; } } throw new IllegalArgumentException("annotation @" + annotation.getName() + " not found on any parameter"); }
protected boolean isDisposes(AnnotatedMethod<?> method) { List<AnnotatedParameter<?>> params = (List) method.getParameters(); for (int i = 0; i < params.size(); i++) { AnnotatedParameter<?> param = params.get(i); if (param.isAnnotationPresent(Disposes.class)) return true; } return false; }
public static MethodInvocationStrategy forDisposer(MethodInjectionPoint<?, ?> method, BeanManagerImpl manager) { List<? extends ParameterInjectionPoint<?, ?>> parameters = method.getParameterInjectionPoints(); if (parameters.size() == 1 && parameters.get(0).getAnnotated().isAnnotationPresent(Observes.class)) { return DISPOSER_SIMPLE_STRATEGY; } else { return DISPOSER_DEFAULT_STRATEGY; } }
public static MethodInvocationStrategy forDisposer(MethodInjectionPoint<?, ?> method, BeanManagerImpl manager) { List<? extends ParameterInjectionPoint<?, ?>> parameters = method.getParameterInjectionPoints(); if (parameters.size() == 1 && parameters.get(0).getAnnotated().isAnnotationPresent(Observes.class)) { return DISPOSER_SIMPLE_STRATEGY; } else { return DISPOSER_DEFAULT_STRATEGY; } }
public static MethodInvocationStrategy forDisposer(MethodInjectionPoint<?, ?> method, BeanManagerImpl manager) { List<? extends ParameterInjectionPoint<?, ?>> parameters = method.getParameterInjectionPoints(); if (parameters.size() == 1 && parameters.get(0).getAnnotated().isAnnotationPresent(Observes.class)) { return DISPOSER_SIMPLE_STRATEGY; } else { return DISPOSER_DEFAULT_STRATEGY; } }
public static MethodInvocationStrategy forDisposer(MethodInjectionPoint<?, ?> method, BeanManagerImpl manager) { List<? extends ParameterInjectionPoint<?, ?>> parameters = method.getParameterInjectionPoints(); if (parameters.size() == 1 && parameters.get(0).getAnnotated().isAnnotationPresent(Observes.class)) { return DISPOSER_SIMPLE_STRATEGY; } else { return DISPOSER_DEFAULT_STRATEGY; } }
public static MethodInvocationStrategy forDisposer(MethodInjectionPoint<?, ?> method, BeanManagerImpl manager) { List<? extends ParameterInjectionPoint<?, ?>> parameters = method.getParameterInjectionPoints(); if (parameters.size() == 1 && parameters.get(0).getAnnotated().isAnnotationPresent(Observes.class)) { return DISPOSER_SIMPLE_STRATEGY; } else { return DISPOSER_DEFAULT_STRATEGY; } }
public static MethodInvocationStrategy forDisposer(MethodInjectionPoint<?, ?> method, BeanManagerImpl manager) { List<? extends ParameterInjectionPoint<?, ?>> parameters = method.getParameterInjectionPoints(); if (parameters.size() == 1 && parameters.get(0).getAnnotated().isAnnotationPresent(Observes.class)) { return DISPOSER_SIMPLE_STRATEGY; } else { return DISPOSER_DEFAULT_STRATEGY; } }
public static AnnotatedParameter<?> findHandlerParameter(final AnnotatedMethod<?> method) { if (!isHandler(method)) { throw new IllegalArgumentException("Method is not a valid handler"); } AnnotatedParameter<?> returnParam = null; for (AnnotatedParameter<?> param : method.getParameters()) { if (param.isAnnotationPresent(Handles.class)) { returnParam = param; break; } } return returnParam; }
private boolean isCDIOSGiMethod(AnnotatedMethod<? super T> method) { if (method.isAnnotationPresent(Inject.class)) { for (AnnotatedParameter parameter : method.getParameters()) { if (parameter.isAnnotationPresent(OSGiService.class)) { return true; } } } return false; }
private boolean containsJaxRsParameterizedCtor(AnnotatedType annotatedType) { for (AnnotatedConstructor<?> c : (Set<AnnotatedConstructor>) annotatedType.getConstructors()) { for (AnnotatedParameter<?> p : c.getParameters()) { for (Class<? extends Annotation> a : JaxRsParamProducer.JaxRsParamAnnotationTYPES) { if(p.isAnnotationPresent(a)) { return true; } } } } return false; }
private boolean isCDIOSGiConstructor(AnnotatedConstructor<T> constructor) { if (constructor.isAnnotationPresent(Inject.class)) { for (AnnotatedParameter parameter : constructor.getParameters()) { if (parameter.isAnnotationPresent(OSGiService.class)) { return true; } } } return false; }
@Test @SpecAssertion(section = PROCESS_ANNOTATED_TYPE, id = "bba") public void configuratorInitializedWithOriginalAT() { AnnotatedType<Cat> catAT = getCurrentManager().getExtension(ProcessAnnotatedTypeObserver.class).getOriginalCatAT(); assertTrue(catAT.isAnnotationPresent(RequestScoped.class)); AnnotatedConstructor<Cat> annotatedConstructor = catAT.getConstructors().stream() .filter(ac -> ac.getParameters().size() == 1 && ac.getParameters().get(0).getBaseType().equals(Feed.class)).findFirst().get(); assertTrue(annotatedConstructor.getParameters().iterator().next().isAnnotationPresent(Cats.class)); assertTrue(annotatedConstructor.isAnnotationPresent(Inject.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)); } }
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)); } }