/** * @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())); }
/** * * @param predicate Testing the original {@link AnnotatedConstructor} * @return a sequence of {@link AnnotatedConstructorConfigurator}s matching the given predicate * @see AnnotatedConstructorConfigurator#getAnnotated() */ default Stream<AnnotatedConstructorConfigurator<T>> filterConstructors(Predicate<AnnotatedConstructor<T>> predicate) { return constructors().stream().filter(c -> predicate.test(c.getAnnotated())); }
/** * @param predicate Testing the original {@link AnnotatedField} * @return a sequence of {@link AnnotatedFieldConfigurator}s matching the given predicate * @see AnnotatedFieldConfigurator#getAnnotated() */ default Stream<AnnotatedFieldConfigurator<? super T>> filterFields(Predicate<AnnotatedField<? super T>> predicate) { return fields().stream().filter(f -> predicate.test(f.getAnnotated())); }
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)); }); }
Class<?> clazz = configurator.getAnnotated().getJavaClass(); configurator.filterMethods(method -> !Modifier.isPrivate(method.getJavaMember().getModifiers())) .forEach(method -> { METRIC_ANNOTATIONS.forEach(annotation -> { configurator.filterConstructors(constructor -> !Modifier.isPrivate(constructor.getJavaMember().getModifiers())) .forEach(constructor -> { METRIC_ANNOTATIONS.forEach(annotation -> {
.filterConstructors(ac -> ac.isAnnotationPresent(Inject.class)) .findFirst().get(); AnnotatedFieldConfigurator<? super AnimalShelter> fieldConfigurator = annotatedTypeConfigurator.filterFields(annotatedField -> { return annotatedField.getJavaMember().getName().equals("cat"); }).findFirst().get(); annotatedTypeConfigurator.removeAll(); annotatedTypeConfigurator.constructors().stream().forEach(AnnotatedConstructorConfigurator::removeAll); annotatedTypeConfigurator.methods().stream().forEach(AnnotatedMethodConfigurator::removeAll); annotatedTypeConfigurator.methods().stream().forEach(annotatedMethodConfigurator -> { annotatedMethodConfigurator.params().stream().forEach(AnnotatedParameterConfigurator::removeAll); }); annotatedTypeConfigurator.fields().stream().forEach(AnnotatedFieldConfigurator::removeAll);
/** * Remove all the annotations. * * @return self */ default AnnotatedTypeConfigurator<T> removeAll() { return remove((a) -> true); }
void registerLoggedIn(@Observes @WithAnnotations(LoggedIn.class) ProcessAnnotatedType<?> pat) { if (pat.getAnnotatedType().isAnnotationPresent(LoggedIn.class)) { pat.configureAnnotatedType().methods().forEach(amc -> { amc.add(LoggedIn.INSTANCE); amc.add(Secured.INSTANCE); }); } else { pat.configureAnnotatedType() .filterMethods(m -> m.isAnnotationPresent(LoggedIn.class)) .forEach(amc -> { amc.add(Secured.INSTANCE); }); } }
void observesDogProducerPAT(@Observes ProcessAnnotatedType<DogProducer> event) { // remove all @Produces from DogProducer AnnotatedTypeConfigurator<DogProducer> annotatedTypeConfigurator = event.configureAnnotatedType(); annotatedTypeConfigurator.methods().stream().forEach(am -> am.remove(a -> a.annotationType().equals(Produces.class))); annotatedTypeConfigurator.fields().stream().forEach(am -> am.remove(a -> a.annotationType().equals(Produces.class))); }
void observesDogPAT(@Observes ProcessAnnotatedType<Dog> event) { annotatedTypesEqual.set(AnnotatedTypes.compareAnnotatedTypes(event.configureAnnotatedType().getAnnotated(), event.getAnnotatedType())); AnnotatedTypeConfigurator<Dog> annotatedTypeConfigurator = event.configureAnnotatedType(); // add @RequestScoped to Dog and @Inject and @Dogs to its Feed field annotatedTypeConfigurator.add(RequestScoped.Literal.INSTANCE) .filterFields(af -> (af.getJavaMember() .getName().equals("feed"))).findFirst().get().add(InjectLiteral.INSTANCE).add(Dogs.DogsLiteral.INSTANCE); // add @Inject to Dog constructor and @Dogs to its param annotatedTypeConfigurator.constructors().iterator().next().add(InjectLiteral.INSTANCE) .filterParams(ap -> ap.getPosition() == 0).findFirst().get().add(Dogs.DogsLiteral.INSTANCE); }
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)); }
private <T> AnnotatedMethodConfigurator<? super T> getAMConfiguratorByName(AnnotatedTypeConfigurator<T> annotatedTypeConfigurator, String name) { return annotatedTypeConfigurator.filterMethods(am -> am.getJavaMember().getName().equals(name)).findFirst().get(); }
@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()); }
public void processAnnotatedType(@Observes ProcessAnnotatedType<Bravo> event){ event.configureAnnotatedType().add(ProcessedByExtension.ProcessedByExtensionLiteral.INSTANCE); }
public void addAnnotatedType(@Observes BeforeBeanDiscovery event, final BeanManager beanManager) { new AddForwardingAnnotatedTypeAction<Boss>() { @Override public String getBaseId() { return BeforeBeanDiscoveryObserver.class.getName(); } @Override public AnnotatedType<Boss> delegate() { return new AnnotatedTypeWrapper<Boss>(beanManager.createAnnotatedType(Boss.class), true); } }.perform(event); //add Baz annotatedType via AnnotatedTypeConfigurator event.addAnnotatedType(Baz.class, BeforeBeanDiscoveryObserver.class.getName() + ":" + Baz.class.getName()) .add(Pro.ProLiteral.INSTANCE) .add(RequestScoped.Literal.INSTANCE) .filterFields(annotatedField -> annotatedField.getJavaMember().getType().equals(Instance.class)).findFirst().get() .add(InjectLiteral.INSTANCE) .add(Pro.ProLiteral.INSTANCE); }
/** * Remove all the annotations. * * @return self */ default AnnotatedTypeConfigurator<T> removeAll() { return remove((a) -> true); }
void registerHasAllRoles(@Observes @WithAnnotations(HasAllRoles.class) ProcessAnnotatedType<?> pat) { if (pat.getAnnotatedType().isAnnotationPresent(HasAllRoles.class)) { HasAllRoles hasAllRoles = pat.getAnnotatedType().getAnnotation(HasAllRoles.class); pat.configureAnnotatedType().methods().forEach(amc -> { amc.add(hasAllRoles); amc.add(Secured.INSTANCE); }); } else { pat.configureAnnotatedType() .filterMethods(m -> m.isAnnotationPresent(HasAllRoles.class)) .forEach(amc -> { amc.add(Secured.INSTANCE); }); } }
Class<?> clazz = configurator.getAnnotated().getJavaClass(); configurator.filterMethods(method -> !Modifier.isPrivate(method.getJavaMember().getModifiers())) .forEach(method -> { METRIC_ANNOTATIONS.forEach(annotation -> { configurator.filterConstructors(constructor -> !Modifier.isPrivate(constructor.getJavaMember().getModifiers())) .forEach(constructor -> { METRIC_ANNOTATIONS.forEach(annotation -> {
@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)); }); }