Java TypeMirrorFactory类代码示例

import io.vertx.codegen.type.TypeMirrorFactory; //导入依赖的package包/类
public CodeTranslator(ProcessingEnvironment processingEnv) {
  this.trees = Trees.instance(processingEnv);
  this.SystemType = (DeclaredType) processingEnv.getElementUtils().getTypeElement(System.class.getName()).asType();
  this.ThrowableType = (DeclaredType) processingEnv.getElementUtils().getTypeElement(Throwable.class.getName()).asType();
  Context context = ((JavacProcessingEnvironment)processingEnv).getContext();
  this.attr = Attr.instance(context);
  this.typeUtils = processingEnv.getTypeUtils();
  this.factory = new TypeMirrorFactory(processingEnv.getElementUtils(), processingEnv.getTypeUtils()) {
    @Override
    public TypeInfo create(TypeUse use, TypeMirror type) {
      if (type.getKind() == TypeKind.WILDCARD) {
        WildcardType wildcardType = (WildcardType) type;
        if (wildcardType.getExtendsBound() != null) {
          return super.create(wildcardType.getExtendsBound());
        } else if (wildcardType.getSuperBound() != null) {
          return super.create(use, wildcardType.getSuperBound());
        }
      }
      return super.create(use, type);
    }
  };
}
 

import io.vertx.codegen.type.TypeMirrorFactory; //导入依赖的package包/类
boolean process() {
  if (!processed) {
    if (modelElt.getKind() != ElementKind.ENUM) {
      throw new GenException(modelElt, "@VertxGen can only be used with interfaces or enums" + modelElt.asType().toString());
    }
    doc = docFactory.createDoc(modelElt);
    type = (EnumTypeInfo) new TypeMirrorFactory(elementUtils, typeUtils).create(modelElt.asType());
    Helper.checkUnderModule(this, "@VertxGen");
    values = elementUtils.
        getAllMembers(modelElt).
        stream().
        filter(elt -> elt.getKind() == ElementKind.ENUM_CONSTANT).
        flatMap(Helper.cast(VariableElement.class)).
        map(elt -> new EnumValueInfo(elt.getSimpleName().toString(), docFactory.createDoc(elt))).
        collect(Collectors.toList());
    if (values.isEmpty()) {
      throw new GenException(modelElt, "No empty enums");
    }
    processed = true;
    return true;
  } else {
    return false;
  }
}
 

import io.vertx.codegen.type.TypeMirrorFactory; //导入依赖的package包/类
public Factory(Messager messager, Elements elementUtils, Types typeUtils, TypeMirrorFactory typeFactory, TypeElement ownerElt) {
  this.messager = messager;
  this.elementUtils = elementUtils;
  this.typeUtils = typeUtils;
  this.typeFactory = typeFactory;
  this.ownerElt = ownerElt;
}
 

import io.vertx.codegen.type.TypeMirrorFactory; //导入依赖的package包/类
/**
 * Create a tag mapper that remaps tags with extra contexutal info like @link tags.
 *
 * @param elementUtils the element utils
 * @param typeUtils the type utils
 * @param ownerElt the type element in which this tag is declared
 * @return the mapper
 */
public static Function<Token, Token> tagMapper(
    Elements elementUtils, Types typeUtils, TypeElement ownerElt) {
  TypeMirrorFactory typeFactory = new TypeMirrorFactory(elementUtils, typeUtils);
  return token -> {
    if (token.isInlineTag()) {
      Tag tag = ((Token.InlineTag) token).getTag();
      if (tag.getName().equals("link")) {
        Matcher matcher = LINK_REFERENCE_PATTERN.matcher(tag.getValue());
        if (matcher.find()) {
          Element resolvedElt = Helper.resolveSignature(
              elementUtils,
              typeUtils,
              ownerElt,
              matcher.group(1));
          if (resolvedElt != null) {
            TypeElement resolvedTypeElt = Helper.getElementTypeOf(resolvedElt);
            if (resolvedTypeElt != null) {
              DeclaredType resolvedType = (DeclaredType) resolvedTypeElt.asType();
              Tag.Link tagLink = new Tag.Link(
                  tag.getValue(),
                  resolvedElt,
                  typeFactory.create(resolvedType),
                  tag.getValue().substring(matcher.end()));
              token = new Token.InlineTag(token.getValue(), tagLink);
            }
          }
        }
      }
    }
    return token;
  };
}
 

import io.vertx.codegen.type.TypeMirrorFactory; //导入依赖的package包/类
@Override
public void init(ProcessingEnvironment processingEnv) {
  factory = new TypeMirrorFactory(processingEnv.getElementUtils(), processingEnv.getTypeUtils());
  translator = new CodeTranslator(processingEnv);
  env = processingEnv;
}
 

import io.vertx.codegen.type.TypeMirrorFactory; //导入依赖的package包/类
public EnumModel(Messager messager, Elements elementUtils, Types typeUtils, TypeElement modelElt) {
  this.docFactory = new Doc.Factory(messager, elementUtils, typeUtils, new TypeMirrorFactory(elementUtils, typeUtils), modelElt);
  this.typeUtils = typeUtils;
  this.elementUtils = elementUtils;
  this.modelElt = modelElt;
}