Java Code Examples for javax.enterprise.inject.spi.ProcessAnnotatedType#veto()

<T> void excludeBeans(@Observes @WithAnnotations({Scope.class, NormalScope.class}) ProcessAnnotatedType<T> pat) {

        if (excludedBeanClasses.contains(pat.getAnnotatedType().getJavaClass())) {
            pat.veto();
            return;
        }

        Set<Type> typeClosure = pat.getAnnotatedType().getTypeClosure();
        for (Type excludedBeanType : excludedBeanTypes) {
            if (typeClosure.contains(excludedBeanType)) {
                pat.veto();
                return;
            }
        }
    }
 

void onPat(@Observes final ProcessAnnotatedType<?> pat, final BeanManager bm) {
    final AnnotatedType<?> at = pat.getAnnotatedType();
    if (isJaxRsEndpoint(bm, at)) {
        pat.setAnnotatedType(new JAXRSFIeldInjectionAT(this, at));
    } else if (isVetoedMeecrowaveCore(at.getJavaClass().getName())) {
        pat.veto();
    }
}
 

public void findClients(@Observes @WithAnnotations({RegisterRestClient.class}) ProcessAnnotatedType<?> pat) {
    Class<?> restClient = pat.getAnnotatedType().getJavaClass();
    if (restClient.isInterface()) {
        restClientClasses.add(restClient);
        pat.veto();
    } else {
        errors.add(new IllegalArgumentException("The class " + restClient
                + " is not an interface"));
    }
}
 

@SuppressWarnings("unchecked")
<X> void processAnnotatedType(@Observes ProcessAnnotatedType<X> event)
{
    if (!isActivated)
    {
        return;
    }

    if (isVetoed(event.getAnnotatedType()))
    {
        event.veto();
    }
    else if (isRepository(event.getAnnotatedType()))
    {
        Class<X> repositoryClass = event.getAnnotatedType().getJavaClass();

        LOG.log(Level.FINER, "getHandlerClass: Repository annotation detected on {0}",
                event.getAnnotatedType());
        if (Deactivatable.class.isAssignableFrom(repositoryClass)
                && !ClassDeactivationUtils.isActivated((Class<? extends Deactivatable>) repositoryClass))
        {
            LOG.log(Level.FINER, "Class {0} is Deactivated", repositoryClass);
            return;
        }

        repositoryClasses.add(repositoryClass);
        REPOSITORY_CLASSES.add(repositoryClass);
    }
}
 

protected void vetoCustomProjectStageBeans(ProcessAnnotatedType processAnnotatedType)
{
    //currently there is a veto for all project-stage implementations,
    //but we still need @Typed() for the provided implementations in case of the deactivation of this behaviour
    if (ProjectStage.class.isAssignableFrom(processAnnotatedType.getAnnotatedType().getJavaClass()))
    {
        processAnnotatedType.veto();
    }
}
 

public void vetoProbeHandlers(@Observes ProcessAnnotatedType<? extends Handler<RoutingContext>> event) {
    if (event.getAnnotatedType().getJavaClass().getName().startsWith(PROBE_PACKAGE)) {
        event.veto();
    }
}
 

void vetoJacksonIfNotHere(@Observes final ProcessAnnotatedType<JacksonOpenAPIYamlBodyWriter> event) {
    if (!jacksonIsPresent) {
        event.veto();
    }
}
 

void pat(@Observes final ProcessAnnotatedType<BValInterceptor> stockBvalInterceptor) {
    stockBvalInterceptor.veto();
}
 

protected void vetoScannedCDIJCacheHelperQualifiers(final @Observes ProcessAnnotatedType<CDIJCacheHelper> pat) {
    if (!needHelper) { // already seen, shouldn't really happen,just a protection
        pat.veto();
    }
    needHelper = false;
}
 

@SuppressWarnings("UnusedDeclaration")
public <X> void findConverterAndValidatorsWhichNeedProxiesForDependencyInjectionSupport(
        @Observes ProcessAnnotatedType<X> pat, BeanManager beanManager)
{
    if (!this.isActivated)
    {
        return;
    }

    Class<X> beanClass = pat.getAnnotatedType().getJavaClass();

    if (!(Converter.class.isAssignableFrom(beanClass) || (Validator.class.isAssignableFrom(beanClass))))
    {
        return;
    }

    Bean<X> bean = new BeanBuilder<X>(beanManager).readFromType(pat.getAnnotatedType()).create();
    // veto normal converters/validators -> they will get excluded from the special handling later on
    if (!hasInjectionPoints(bean) && !hasNormalScopeAnnotation(bean, beanManager))
    {
        pat.veto();
        return;
    }

    // converters/validators without properties for tags, will be handled by the corresponding manual wrapper
    if (!hasPublicProperty(beanClass))
    {
        return;
    }

    if (!(Modifier.isFinal(beanClass.getModifiers())))
    {
        this.classesToProxy.add(beanClass);
        pat.veto();
    }
    else
    {
        LOG.warning("To use dependency-injection in converters/validators with properties, " +
                "you they aren't allowed to be 'final'.");
    }
}
 

private void veto(ProcessAnnotatedType processAnnotatedType, String vetoType)
{
    processAnnotatedType.veto();
    LOG.finer(vetoType + " based veto for bean with type: " +
            processAnnotatedType.getAnnotatedType().getJavaClass());
}