private <X> AnnotatedTypeBuilder<X> initializeBuilder(final AnnotatedTypeBuilder<X> currentBuilder, final AnnotatedType<X> source) { if (currentBuilder == null) { return new AnnotatedTypeBuilder<X>().readFromType(source); } return currentBuilder; }
<X> void detectBundleInjectionTargets(@Observes ProcessInjectionTarget<X> event, BeanManager beanManager) { AnnotatedType<X> type = event.getAnnotatedType(); for (AnnotatedField<?> f : type.getFields()) { Field field = f.getJavaMember(); Class<?> clz = field.getType(); if (clz.isAnnotationPresent(MessageBundle.class)) { log.info("Add @MessageBundle to " + type.getJavaClass().getName() + "." + field.getName() + " injection point for the type: " + clz.getName()); AnnotatedTypeBuilder<X> typeBuilder = new AnnotatedTypeBuilder<X>().readFromType(type); typeBuilder.addToField(field, MessageBundleLiteral.INSTANCE); event.setInjectionTarget(beanManager.createInjectionTarget(typeBuilder.create())); } } } }
public BeanResult(Class<X> type, boolean readAnnotations, BeanResultType beanType, List<FieldValueObject> fieldValues, List<BeanResult<?>> inlineBeans, BeanManager beanManager) { this.beanManager = beanManager; this.type = type; builder = new AnnotatedTypeBuilder<X>().setJavaClass(type); builder.addToClass(XmlConfiguredBeanLiteral.INSTANCE); if (readAnnotations) { builder.readFromType(type); // we don't want to keep the veto annotation on the class builder.removeFromClass(Veto.class); } this.beanType = beanType; this.fieldValues = new ArrayList<FieldValueObject>(fieldValues); this.inlineBeans = new ArrayList<BeanResult<?>>(inlineBeans); }
/** * Creates a wrapper around an AutoProxy handler class * * @param handlerClass The handler class * @throws IllegalArgumentException if the handler class is does not have a * suitable @AroundInvoke method */ ServiceHandlerManager(Class<T> handlerClass, BeanManager beanManager) throws IllegalArgumentException { this.handlerClass = handlerClass; handlerMethod = getHandlerMethod(handlerClass); //now create the InjectionTarget AnnotatedTypeBuilder<T> typeBuilder = new AnnotatedTypeBuilder<T>().readFromType(handlerClass); injectionTarget = beanManager.createInjectionTarget(typeBuilder.create()); }
public <T> void processAnnotatedType(@Observes final ProcessAnnotatedType<T> event) { AnnotatedTypeBuilder<T> builder = new AnnotatedTypeBuilder<T>(); builder.readFromType(event.getAnnotatedType()); boolean modifiedType = false; for (AnnotatedField<?> f : event.getAnnotatedType().getFields()) { if (f.isAnnotationPresent(InputField.class)) { builder.overrideFieldType(f.getJavaMember(), Object.class); modifiedType = true; } } if (modifiedType) { AnnotatedType<T> replacement = builder.create(); typeOverrides.put(replacement.getJavaClass(), replacement); event.setAnnotatedType(replacement); } }
final AnnotatedTypeBuilder<X> builder = new AnnotatedTypeBuilder<X>().readFromType(type); builder.addToClass(genericBeanQualifier); builder.redefine(Inject.class, new AnnotationRedefiner<Inject>()
private AnnotatedType<Object> decorateType(final AnnotatedType<Object> type, final Class<? extends Annotation> jsfScope) { final Class<? extends Annotation> cdiScope = getCdiScopeFor(jsfScope); AnnotationInstanceProvider provider = new AnnotationInstanceProvider(); final Annotation cdiScopeAnnotation = provider.get(cdiScope, Collections.EMPTY_MAP); AnnotatedTypeBuilder builder; builder = new AnnotatedTypeBuilder() .readFromType(type) .removeFromClass(jsfScope) .addToClass(cdiScopeAnnotation); return builder.create(); } }
builder = new AnnotatedTypeBuilder<X>().readFromType(tp); for (Annotation a : tp.getAnnotations()) builder = new AnnotatedTypeBuilder<X>().readFromType(tp); builder = new AnnotatedTypeBuilder<X>().readFromType(tp);