/** * @param predicate Testing the original {@link AnnotatedMethod} * @return a sequence of {@link AnnotatedMethodConfigurator}s matching the given predicate * @see AnnotatedMethodConfigurator#getAnnotated() */ default Stream<AnnotatedMethodConfigurator<? super T>> filterMethods(Predicate<AnnotatedMethod<? super T>> predicate) { return methods().stream().filter(c -> predicate.test(c.getAnnotated())); }
/** * Remove all the annotations. * * @return self */ default AnnotatedMethodConfigurator<T> removeAll() { return remove((a) -> true); }
/** * * @param predicate Testing the original {@link AnnotatedParameter} * @return a sequence of {@link AnnotatedParameterConfigurator}s matching the given predicate * @see AnnotatedParameterConfigurator#getAnnotated() */ default Stream<AnnotatedParameterConfigurator<T>> filterParams(Predicate<AnnotatedParameter<T>> predicate) { return params().stream().filter(p -> predicate.test(p.getAnnotated())); }
if (result.getAnnotated().isAnnotationPresent(annotation.annotationType())) { result.add(annotation); });
void letOtherExtensionsUseRegistries(@Observes final BeforeBeanDiscovery beforeBeanDiscovery, final BeanManager beanManager) { beforeBeanDiscovery.addQualifier(RegistryType.class); beanManager.fireEvent(applicationRegistry); beanManager.fireEvent(applicationRegistry, new RegistryTypeImpl(MetricRegistry.Type.APPLICATION)); beanManager.fireEvent(baseRegistry, new RegistryTypeImpl(MetricRegistry.Type.BASE)); beanManager.fireEvent(vendorRegistry, new RegistryTypeImpl(MetricRegistry.Type.VENDOR)); // we make @Metric.name binding (to avoid to write producers relying on injection point) beforeBeanDiscovery.configureQualifier(org.eclipse.microprofile.metrics.annotation.Metric.class) .methods().stream().filter(method -> method.getAnnotated().getJavaMember().getName().equals("name")) .forEach(method -> method.remove(a -> a.annotationType() == Nonbinding.class)); }
AnnotatedMethod<? super AnimalShelter> annotatedMethod = methodConfigurator.getAnnotated(); annotatedMethodEqual.set(AnnotatedTypes.compareAnnotatedCallable( event.getAnnotatedType().getMethods().stream().filter(m -> m.getJavaMember().getName().equals("observesRoomInShelter")).findAny().get(), annotatedTypeConfigurator.methods().stream().forEach(AnnotatedMethodConfigurator::removeAll); annotatedTypeConfigurator.methods().stream().forEach(annotatedMethodConfigurator -> { annotatedMethodConfigurator.params().stream().forEach(AnnotatedParameterConfigurator::removeAll); }); annotatedTypeConfigurator.fields().stream().forEach(AnnotatedFieldConfigurator::removeAll);
@Produces @RequestScoped public Product createInterceptedProduct(InterceptionFactory<Product> interceptionFactory) { interceptionFactory.configure().add(ProductInterceptorBinding3.BindingLiteral.INSTANCE).filterMethods(m -> m.getJavaMember().getName().equals("ping")) .findFirst().get() .add(ProductInterceptorBinding1.BindingLiteral.INSTANCE) .add(ProductInterceptorBinding2.BindingLiteral.INSTANCE); return interceptionFactory.createInterceptedInstance(new Product()); }
Id id = routes.get(m.getAnnotated().getJavaMember().toGenericString()); if (id != null) { m.filterParams(p -> p.isAnnotationPresent(Observes.class)).findFirst().ifPresent(param -> { param.add(id); LOGGER.debug("Add id qualifier {0} to parameter {1}", id, param.getAnnotated());
void observesCatPAT(@Observes ProcessAnnotatedType<Cat> event) { AnnotatedTypeConfigurator<Cat> annotatedTypeConfigurator = event.configureAnnotatedType(); originalCatAT = annotatedTypeConfigurator.getAnnotated(); // remove @RequestScoped from Cat annotatedTypeConfigurator.remove(a -> a.annotationType().equals(RequestScoped.class)); // remove @Produces and @Cats Cat.produceCatName() getAMConfiguratorByName(annotatedTypeConfigurator, "produceCatFeed").remove(a -> a.equals(ProducesLiteral.INSTANCE)) .remove(a -> a.equals(Cats.CatsLiteral.INSTANCE)); // remove @Inject from Cat.feed annotatedTypeConfigurator.filterFields(af -> af.getJavaMember().getName().equals("feed")).findFirst().get() .remove(a -> a.equals(InjectLiteral.INSTANCE)); // remove @Inject and @Cats from constructor with parameter annotatedTypeConfigurator.filterConstructors(ac -> ac.getParameters().size() == 1 && ac.getParameters().get(0).getBaseType().equals(Feed.class)) .findFirst().get().remove(a -> a.equals(InjectLiteral.INSTANCE)).params().get(0).remove(a -> a.equals(Cats.CatsLiteral.INSTANCE)); // remove @Observes from Cat.observesCatsFeed method parameter getAMConfiguratorByName(annotatedTypeConfigurator, "observesCatsFeed") .filterParams(ap -> ap.getPosition() == 0).findFirst().get().remove(a -> a.annotationType().equals(Observes.class)); }
void observesDogDependenciesProducerPAT(@Observes ProcessAnnotatedType<DogDependenciesProducer> event) { AnnotatedTypeConfigurator<DogDependenciesProducer> annotatedTypeConfigurator = event.configureAnnotatedType(); // add @Produces and @Created to DogDependenciesProducer.produceFeed getAMConfiguratorByName(annotatedTypeConfigurator, "produceFeed").add(ProducesLiteral.INSTANCE) .add(Dogs.DogsLiteral.INSTANCE); // add @Produces and @Created to DogDependenciesProducer.dogName annotatedTypeConfigurator.filterFields(af -> af.getJavaMember().getName().equals("dogName")).findFirst().get().add(ProducesLiteral.INSTANCE) .add(Dogs.DogsLiteral.INSTANCE); // add @Disposes to DogDependenciesProducer.disposeFeed getAMConfiguratorByName(annotatedTypeConfigurator, "disposeFeed") .filterParams(ap -> ap.getPosition() == 0).findFirst().get().add(DisposesLiteral.INSTANCE).add(Dogs.DogsLiteral.INSTANCE); }
if (result.getAnnotated().isAnnotationPresent(annotation.annotationType())) { result.add(annotation); });
void addTimedInterceptorBinding(@Observes BeforeBeanDiscovery bbd) { bbd.configureInterceptorBinding(Timed.class).methods().forEach(method -> method.add(Nonbinding.Literal.INSTANCE)); }
private DelegatingGauge<?> buildDelegatingGauge(String gaugeName, AnnotatedMethodConfigurator<?> site, BeanManager bm) { Bean<?> bean = bm.getBeans(site.getAnnotated().getJavaMember().getDeclaringClass()) .stream() .findFirst() .orElseThrow(() -> new IllegalArgumentException("Cannot find bean for annotated gauge " + gaugeName)); return DelegatingGauge.newInstance( site.getAnnotated().getJavaMember(), getReference(bm, bean.getBeanClass(), bean), site.getAnnotated().getJavaMember().getReturnType()); }
if (result.getAnnotated().isAnnotationPresent(annotation.annotationType())) { result.add(annotation); });
/** * Remove all the annotations. * * @return self */ default AnnotatedMethodConfigurator<T> removeAll() { return remove((a) -> true); }
/** * * @param predicate Testing the original {@link AnnotatedParameter} * @return a sequence of {@link AnnotatedParameterConfigurator}s matching the given predicate * @see AnnotatedParameterConfigurator#getAnnotated() */ default Stream<AnnotatedParameterConfigurator<T>> filterParams(Predicate<AnnotatedParameter<T>> predicate) { return params() .stream() .filter(ap -> predicate.test(ap.getAnnotated())); }
@Produces public Bar createBar(InterceptionFactory<Bar> interceptionFactory) { interceptionFactory.configure().filterMethods(m -> m.getJavaMember().getName().equals("ping")).findFirst().get() .add(BarInterceptorBinding.BarInterceptorBindingLiteral.INSTANCE); return interceptionFactory.createInterceptedInstance(new Bar()); }
private void recordAnnotatedGaugeSite(@Observes @WithAnnotations(Gauge.class) ProcessAnnotatedType<?> pat) { LOGGER.log(Level.FINE, () -> "### recordAnnoatedGaugeSite for class " + pat.getAnnotatedType().getJavaClass()); AnnotatedType<?> type = pat.getAnnotatedType(); LOGGER.log(Level.FINE, () -> "### Processing annotations for " + type.getJavaClass().getName()); // Register metrics based on annotations AnnotatedTypeConfigurator<?> configurator = pat.configureAnnotatedType(); Class<?> clazz = configurator.getAnnotated().getJavaClass(); // If abstract class, then handled by concrete subclasses if (Modifier.isAbstract(clazz.getModifiers())) { return; } // Process @Gauge methods keeping non-private declared on this class configurator.filterMethods(method -> method.getJavaMember().getDeclaringClass().equals(clazz) && !Modifier.isPrivate(method.getJavaMember().getModifiers()) && method.isAnnotationPresent(Gauge.class)) .forEach(method -> { Method javaMethod = method.getAnnotated().getJavaMember(); String explicitGaugeName = method.getAnnotated().getAnnotation(Gauge.class).name(); String gaugeName = String.format("%s.%s", clazz.getName(), explicitGaugeName != null && explicitGaugeName.length() > 0 ? explicitGaugeName : javaMethod.getName()); annotatedGaugeSites.put(gaugeName, method); LOGGER.log(Level.FINE, () -> String.format("### Recorded annotated gauge with name %s", gaugeName)); }); }
/** * removes all Annotations * @return self */ default AnnotatedMethodConfigurator<T> removeAll() { remove((e) -> true); return this; }
/** * * @param predicate Testing the original {@link AnnotatedParameter} * @return a sequence of {@link AnnotatedParameterConfigurator}s matching the given predicate * @see AnnotatedParameterConfigurator#getAnnotated() */ default Stream<AnnotatedParameterConfigurator<T>> filterParams(Predicate<AnnotatedParameter<T>> predicate) { return params().stream().filter(p -> predicate.test(p.getAnnotated())); }