Java RoundEnvironment类代码示例

import javax.annotation.processing.RoundEnvironment; //导入依赖的package包/类
@Override
public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {

    try {
        ToolingProvider.setTooling(processingEnv);

        Set<? extends Element> set = roundEnv.getElementsAnnotatedWith(TestAnnotation.class);

        if (set.size() == 1) {
            testCase((TypeElement) set.iterator().next());
        }

    } finally {
        ToolingProvider.clearTooling();
    }
    return false;
}
 

import javax.annotation.processing.RoundEnvironment; //导入依赖的package包/类
@Override
public boolean process(Set<? extends TypeElement> typeElements, RoundEnvironment env) {
    List<ValidationClass> validationClasses = findAndParseValidations(env);

    // Generate validation classes source code
    for (ValidationClass validationClass : validationClasses) {
        try {
            JavaFile javaFile = JavaFiler.cookJava(validationClass);
            javaFile.writeTo(this.filer);
        } catch (IOException e) {
            error(validationClass.getTypeElement(), "Unable to write validation for type %s: %s", validationClass.getTypeElement(), e.getMessage());
        }
    }

    return false;
}
 

import javax.annotation.processing.RoundEnvironment; //导入依赖的package包/类
@Override
public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {

  if (roundEnv.processingOver()) {
    return false;
  }

  Set<? extends Element> elementsAnnotatedWith =
      roundEnv.getElementsAnnotatedWith(Annotation1.class);

  if (elementsAnnotatedWith.size() != 1) {
    throw new IllegalStateException(
        "There must be exactly one element to process. Actual=" + elementsAnnotatedWith.size());
  }

  for (Element element : elementsAnnotatedWith) {
    inputTypeForElement = inputTypeFinder.findInputTypeForElement(element);
  }

  return false;
}
 

import javax.annotation.processing.RoundEnvironment; //导入依赖的package包/类
private void processRound(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
	loop: for (TypeElement annotation : annotations) {
		for (Element element : roundEnv.getElementsAnnotatedWith(annotation)) {
			if (element.getAnnotation(Activator.class).extension()) {
				extensionActivator = element.asType().toString();
			} else {
				activator = element.asType().toString();
			}
			if (activator != null && extensionActivator != null) {
				break loop;
			}
		}
	}
	try {
		generateFile();
	} catch (IOException e) {
		messager.printMessage(Kind.ERROR, "IOException while generating file with contracts! " + e.getMessage());
		e.printStackTrace();
	}
}
 

import javax.annotation.processing.RoundEnvironment; //导入依赖的package包/类
private Map<ExecutableElement, String> getMethodToFieldNameMap(RoundEnvironment roundEnvironment) {
    final Map<ExecutableElement, String> methodToFieldNameMap = new HashMap<>();

    for (Element byElement : roundEnvironment.getElementsAnnotatedWith(By.class)) {
        if (byElement.getKind() != ElementKind.FIELD) {
            continue;
        }
        VariableElement byField = (VariableElement) byElement;
        for (Element element : typeUtils.asElement(byField.asType()).getEnclosedElements()) {
            if (element.getKind() != ElementKind.METHOD) {
                continue;
            }
            ExecutableElement method = (ExecutableElement) element;
            methodToFieldNameMap.put(method, byField.getSimpleName().toString());
        }
    }

    return methodToFieldNameMap;
}
 

import javax.annotation.processing.RoundEnvironment; //导入依赖的package包/类
@Override
public boolean incrementalProcess(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
  for (TypeElement annotation : annotations) {
    System.out.println("Processing annotation:" + annotation);
  }

  if (isProcessingDone) {
    return false;
  }

  // generates a class with a constant that contains the name of all classes containing an annotation.
  Set<? extends Element> annotatedElements = roundEnv.getElementsAnnotatedWith(Annotation1.class);
  Map<String, Set<? extends Element>> mapGeneratedFileNameToOriginatingElements = processElements(annotatedElements);
  generateFiles(incrementalProcessingEnvironment.getFiler(), mapGeneratedFileNameToOriginatingElements);
  isProcessingDone = true;
  return false;
}
 

import javax.annotation.processing.RoundEnvironment; //导入依赖的package包/类
@Override public boolean process(Set<? extends TypeElement> elements, RoundEnvironment env) {
  Map<TypeElement, BindingSet> bindingMap = findAndParseTargets(env);

  for (Map.Entry<TypeElement, BindingSet> entry : bindingMap.entrySet()) {
    TypeElement typeElement = entry.getKey();
    BindingSet binding = entry.getValue();

    JavaFile javaFile = binding.brewJava(sdk);
    try {
      javaFile.writeTo(filer);
    } catch (IOException e) {
      error(typeElement, "Unable to write binding for type %s: %s", typeElement, e.getMessage());
    }
  }

  return false;
}
 

import javax.annotation.processing.RoundEnvironment; //导入依赖的package包/类
@Override public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
    if (roundEnv.processingOver() || written++ > 0) {
        return false;
    }
    messager.printMessage(Diagnostic.Kind.NOTE, "writing Generated.java");
    try {
        Writer w = processingEnv.getFiler().createSourceFile("p.Generated").openWriter();
        try {
            w.write("package p; public class Generated { public static void m() { } }");
        } finally {
            w.close();
        }
    } catch (IOException x) {
        messager.printMessage(Diagnostic.Kind.ERROR, x.toString());
    }
    return true;
}
 

import javax.annotation.processing.RoundEnvironment; //导入依赖的package包/类
/**
 * Prepare global config
 *
 * @param roundEnv annotation processor environment
 */
private Element prepareGlobalConfig(RoundEnvironment roundEnv) {
    Element sqlFirstApcConfigElement = null;

    //TODO read with filer for the case of partial compilation
    Set<? extends Element> annotatedElements = roundEnv.getElementsAnnotatedWith(SqlFirstApcConfig.class);
    for (Element element : annotatedElements) {
        if (sqlFirstApcConfigElement == null) {
            sqlFirstApcConfigElement = element;
        } else {
            processingEnv.getMessager().printMessage(Diagnostic.Kind.ERROR, "SqlFirstApcConfig annotation must be declared only once ", element);
        }
    }
    return sqlFirstApcConfigElement;
    
}
 

import javax.annotation.processing.RoundEnvironment; //导入依赖的package包/类
@Override
public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
	if (annotations.isEmpty()) {
		return false;
	}

	try {
		return throwableProcess(roundEnv);
	} catch (RuntimeException e) {
		getMessager().printMessage(Diagnostic.Kind.OTHER, "Moxy compilation failed. Could you copy stack trace above and write us (or make issue on Githhub)?");
		e.printStackTrace();
		getMessager().printMessage(Diagnostic.Kind.ERROR, "Moxy compilation failed; see the compiler error output for details (" + e + ")");
	}

	return true;
}
 

import javax.annotation.processing.RoundEnvironment; //导入依赖的package包/类
@Override
public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
    if (processingEnv.getElementUtils().getModuleElement("m1x") == null) {
        throw new AssertionError("No m1x module found.");
    }

    Messager messager = processingEnv.getMessager();

    for (TypeElement clazz : ElementFilter.typesIn(roundEnv.getRootElements())) {
        for (VariableElement field : ElementFilter.fieldsIn(clazz.getEnclosedElements())) {
            messager.printMessage(Kind.NOTE, "field: " + field.getSimpleName());
        }
    }

    return false;
}
 

import javax.annotation.processing.RoundEnvironment; //导入依赖的package包/类
@Override
public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
    if (round++ == 0) {
        try (Writer out = processingEnv.getFiler()
                                             .createSourceFile("Anno.java")
                                             .openWriter()) {
            String target = processingEnv.getOptions().get("target");
            String code = "import java.lang.annotation.ElementType;\n" +
                          "import java.lang.annotation.Target;\n" +
                          "@Target(ElementType." + target + ")\n" +
                          "@interface Anno { public String value(); }\n";
            out.write(code);
        } catch (IOException exc) {
            throw new IllegalStateException(exc);
        }
    }
    return true;
}
 

import javax.annotation.processing.RoundEnvironment; //导入依赖的package包/类
@Override
public boolean process(Set<? extends TypeElement> set, RoundEnvironment roundEnvironment) {

    try {
        if (!findAnnotatedViewModels(roundEnvironment)) {
            return true;
        }

        for (TypeElement viewModelElement : viewModels) {
            generateViewModelFactory(viewModelElement);
        }

    } catch (IOException e) {
        error("An error has occurred.");
        e.printStackTrace();
    }

    return true;
}
 

import javax.annotation.processing.RoundEnvironment; //导入依赖的package包/类
@Override
public final boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {

  if (roundEnv.processingOver()) {
    return false;
  }

  for (ProcessorPipeline processorPipeline : processorPipelines) {
    try {
      processorPipeline.process(annotations, roundEnv);
    } catch (Throwable e) {
      errorReporter.reportError(
          String.format(
              Locale.getDefault(),
              "Fatal error running %s processor: %s",
              processorPipeline.getAnnotationType().getSimpleName(),
              e.getMessage()));
    }
  }
  return false;
}
 

import javax.annotation.processing.RoundEnvironment; //导入依赖的package包/类
public boolean process(Set<? extends TypeElement> tes, RoundEnvironment renv) {
    try {
        if (renv.processingOver())
            createSymbols();
    } catch (IOException e) {
        processingEnv.getMessager()
                .printMessage(Diagnostic.Kind.ERROR, e.getLocalizedMessage());
    } catch (Throwable t) {
        Throwable cause = t.getCause();
        if (cause == null)
            cause = t;
        processingEnv.getMessager()
                .printMessage(Diagnostic.Kind.ERROR, cause.getLocalizedMessage());
    }
    return true;
}