How to use

org.jboss.seam.solder.reflection.annotated.AnnotatedTypeBuilder

constructor

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);