Java ProcessingEnvironment.getTypeUtils方法代码示例

import javax.annotation.processing.ProcessingEnvironment; //导入方法依赖的package包/类
TypeMirrors(ProcessingEnvironment env) {
    final Types typeUtils = env.getTypeUtils();
    final Elements elementUtils = env.getElementUtils();

    STRING_MIRROR = elementUtils.getTypeElement("java.lang.String").asType();
    BINARY_MIRROR = typeUtils.getArrayType(typeUtils.getPrimitiveType(TypeKind.BYTE));
    BOOLEAN_MIRROR = elementUtils.getTypeElement(Boolean.class.getName()).asType();
    LONG_MIRROR = elementUtils.getTypeElement(Long.class.getName()).asType();
    INTEGER_MIRROR = elementUtils.getTypeElement(Integer.class.getName()).asType();
    SHORT_MIRROR = elementUtils.getTypeElement(Short.class.getName()).asType();
    BYTE_MIRROR = elementUtils.getTypeElement(Byte.class.getName()).asType();
    DOUBLE_MIRROR = elementUtils.getTypeElement(Double.class.getName()).asType();
    FLOAT_MIRROR = elementUtils.getTypeElement(Float.class.getName()).asType();
    DATE_MIRROR = elementUtils.getTypeElement(Date.class.getName()).asType();

    PRIMITIVE_LONG_MIRROR = typeUtils.getPrimitiveType(TypeKind.LONG);
    PRIMITIVE_INT_MIRROR = typeUtils.getPrimitiveType(TypeKind.INT);
    PRIMITIVE_SHORT_MIRROR = typeUtils.getPrimitiveType(TypeKind.SHORT);
    PRIMITIVE_BYTE_MIRROR = typeUtils.getPrimitiveType(TypeKind.BYTE);
}
 

import javax.annotation.processing.ProcessingEnvironment; //导入方法依赖的package包/类
@Override
public synchronized void init(final ProcessingEnvironment processingEnvironment) {
	super.init(processingEnvironment);

	elementUtil = processingEnvironment.getElementUtils();
	messager = processingEnvironment.getMessager();
	filer = processingEnvironment.getFiler();

	final CoreHelpers coreHelpers = new CoreHelpers(
			processingEnvironment.getElementUtils(),
			processingEnvironment.getTypeUtils());

	companionGenerator = new CompanionGenerator(coreHelpers);
	basicValidator = new BasicValidator();
	typeValidator = new TypeValidator(coreHelpers);

	createRequiredFiles();
}
 

import javax.annotation.processing.ProcessingEnvironment; //导入方法依赖的package包/类
@Override
public synchronized void init(ProcessingEnvironment processingEnvironment) {
    super.init(processingEnvironment);

    this.elementUtils = processingEnvironment.getElementUtils();
    this.typeUtils = processingEnvironment.getTypeUtils();
    this.messager = processingEnvironment.getMessager();
    this.filer = processingEnvironment.getFiler();

    try {
        trees = Trees.instance(processingEnv);
    } catch (IllegalArgumentException ignored) { }
}
 

import javax.annotation.processing.ProcessingEnvironment; //导入方法依赖的package包/类
@Override
public synchronized void init(ProcessingEnvironment processingEnv) {
  super.init(processingEnv);
  elementUtils = processingEnv.getElementUtils();
  errorReporter = new ErrorReporter(processingEnv.getMessager());
  typesUtils = processingEnv.getTypeUtils();
  processorPipelines.addAll(getProcessorPipelines(this));
}
 

import javax.annotation.processing.ProcessingEnvironment; //导入方法依赖的package包/类
@Override
public synchronized void init(ProcessingEnvironment processingEnv) {
	super.init(processingEnv);

	sMessager = processingEnv.getMessager();
	sTypeUtils = processingEnv.getTypeUtils();
	sElementUtils = processingEnv.getElementUtils();
	sOptions = processingEnv.getOptions();
}
 

import javax.annotation.processing.ProcessingEnvironment; //导入方法依赖的package包/类
@Override
public synchronized void init(ProcessingEnvironment processingEnv) {
    super.init(processingEnv);
    elementUtils = processingEnv.getElementUtils();
    filer = processingEnv.getFiler();
    messager = processingEnv.getMessager();
    typeUtils = processingEnv.getTypeUtils();
}
 

import javax.annotation.processing.ProcessingEnvironment; //导入方法依赖的package包/类
@Override
public synchronized void init(ProcessingEnvironment processingEnv) {
    super.init(processingEnv);
    this.typeUtils=processingEnv.getTypeUtils();
    this.elementUtils=processingEnv.getElementUtils();
    this.filer=processingEnv.getFiler();
    this.messager=processingEnv.getMessager();
    this.elementFactory=new ElementFactory(elementUtils, typeUtils);
}
 

import javax.annotation.processing.ProcessingEnvironment; //导入方法依赖的package包/类
private static boolean isValueSpecMarker(
    TypeMirror returnType, ProcessingEnvironment processingEnvironment) {
  Types types = processingEnvironment.getTypeUtils();
  Elements elements = processingEnvironment.getElementUtils();

  return types.isSameType(
      returnType, elements.getTypeElement(dataenum_case.class.getCanonicalName()).asType());
}
 

import javax.annotation.processing.ProcessingEnvironment; //导入方法依赖的package包/类
@Override
public synchronized void init(ProcessingEnvironment env) {
    super.init(env);

    mElementUtils = env.getElementUtils();
    mTypeUtils = env.getTypeUtils();
    mFiler = env.getFiler();
    mJsonObjectMap = new HashMap<>();
    mProcessors = Processor.allProcessors(processingEnv);
}
 

import javax.annotation.processing.ProcessingEnvironment; //导入方法依赖的package包/类
@Override
public synchronized void init(ProcessingEnvironment processingEnv) {
    super.init(processingEnv);
    mTypeUtils = processingEnv.getTypeUtils();
    mElementUtils = processingEnv.getElementUtils();
    mFiler = processingEnv.getFiler();
    mMessager = processingEnv.getMessager();
}
 

import javax.annotation.processing.ProcessingEnvironment; //导入方法依赖的package包/类
@Override
public synchronized void init(ProcessingEnvironment env) {
  super.init(env);
  Types typeUtils = env.getTypeUtils();
  Elements elementUtils = env.getElementUtils();
  Filer filer = env.getFiler();
  messager = env.getMessager();
  ErrorMessages errorMessages = ErrorMessages.builder()
      .cycleInDefinitionSources("Cycle in @Configuration class @Imports {0}")
      .cycleInObjectDefinitions("Cycle in spring bean dependencies {0}")
      .duplicateObjectDefinitions("Duplicate in spring beans {0}")
      .nonLiteralStaticMemberVariables("Non literal static member variables can break class instantiation and leak state")
      .knownDamagingClass("Known damaging class import (contains non-literal static member variables)")
      .missingBeanDefinitions("Missing bean definitions for spring beans {0},"
         + " create definitions or list them in @Verified'''s expected field")
      .missingRelevantAnnotations("Missing @Verified or @Configuration on classes {0}")
      .unmatchedTypes("Unmatched types {0}")
      .duplicatedMatchingDependencies("Duplicated matching dependencies {0}")
      .duplicatedMatchingDefinitions("Duplicated matching definitions {0}")
      .noMatchingDefinition("No matching definition {0}")
      .unusedExpected("Expected bean name is unnecessary {0}")
      .couldNotStore("Could not store incremental build file for {0}")
      .couldNotRead("Could not read incremental build file for {0}")
      .dependencyShaMismatch("Sha256 mismatch of dependency model of prior analyzed @Configuration model")
      .rootNodeImported("@Verfied(root=true) may not be @Imported by other @Verified @Configuration classes: {0}")
      .build();
  definitionAggregator = new AptParsingContext(errorMessages, filer, elementUtils, typeUtils);
}
 

import javax.annotation.processing.ProcessingEnvironment; //导入方法依赖的package包/类
@Override
public synchronized void init(final ProcessingEnvironment pe) {
    super.init(pe);

    logger = pe.getMessager();
    typesUtil = pe.getTypeUtils();
    elementsUtil = pe.getElementUtils();
    filer = pe.getFiler();
}
 

import javax.annotation.processing.ProcessingEnvironment; //导入方法依赖的package包/类
@Override
public synchronized void init(ProcessingEnvironment env) {
    super.init(env);

    elementUtils = env.getElementUtils();
    typeUtils = env.getTypeUtils();
    filer = env.getFiler();
}
 

import javax.annotation.processing.ProcessingEnvironment; //导入方法依赖的package包/类
public EntityHandler(ProcessingEnvironment processingEnv) {
    this.elementUtils = processingEnv.getElementUtils();
    this.typeUtils = processingEnv.getTypeUtils();
    this.filer = processingEnv.getFiler();
    this.messager = processingEnv.getMessager();
    classEntityMap = new HashMap<>();
}
 

import javax.annotation.processing.ProcessingEnvironment; //导入方法依赖的package包/类
@Override
public synchronized void init(ProcessingEnvironment env) {
	super.init(env);

	ProcessorLog.init(env);

	mElementUtils = env.getElementUtils();
	mTypeUtils = env.getTypeUtils();
	mFiler = env.getFiler();
}