/** * Extract the relevant Elements to work with from the round environment before they're passed on * to {@link SpecModelFactory#create(Elements, Types, TypeElement, Messager, EnumSet, * DependencyInjectionHelper, InterStageStore)}. */ @Override public Set<Element> extract(RoundEnvironment roundEnvironment) { return (Set<Element>) roundEnvironment.getElementsAnnotatedWith(TestSpec.class); }
@Override public Set<Element> extract(RoundEnvironment roundEnvironment) { return (Set<Element>) roundEnvironment.getElementsAnnotatedWith(LayoutSpec.class); }
@Override public Set<Element> extract(RoundEnvironment roundEnvironment) { return (Set<Element>) roundEnvironment.getElementsAnnotatedWith(GroupSectionSpec.class); }
@Override public Set<Element> extract(RoundEnvironment roundEnvironment) { return (Set<Element>) roundEnvironment.getElementsAnnotatedWith(DiffSectionSpec.class); }
@Override public Set<Element> extract(RoundEnvironment roundEnvironment) { return (Set<Element>) roundEnvironment.getElementsAnnotatedWith(MountSpec.class); }
private Set<? extends Element> findProvidesMethods(RoundEnvironment env) { Set<Element> result = new LinkedHashSet<Element>(); result.addAll(env.getElementsAnnotatedWith(Provides.class)); return result; }
List<TypeElement> getElementsFor( Class<? extends Annotation> clazz, RoundEnvironment env) { Collection<? extends Element> annotatedElements = env.getElementsAnnotatedWith(clazz); return ElementFilter.typesIn(annotatedElements); }
private void processElements( RoundEnvironment roundEnv ) { Set<? extends Element> functions = roundEnv.getElementsAnnotatedWith( supportedAnnotationType ); visitedElements.addAll( functions ); functions.stream().flatMap( this::validate ).forEachOrdered( messagePrinter::print ); }
@Override public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) { processDefaultLifeCycle(roundEnv.getElementsAnnotatedWith(DefaultLifeCycle.class)); return true; }
private void extractRootElementsAnnotations(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv, AnnotationElementsHolder extractedModel) { for (TypeElement annotation : annotations) { extractedModel.putRootAnnotatedElements(annotation.getQualifiedName().toString(), roundEnv.getElementsAnnotatedWith(annotation)); } }
private void findAndParseListener(RoundEnvironment env, Class<? extends Annotation> annotationClass, Map<TypeElement, BindingSet.Builder> builderMap, Set<TypeElement> erasedTargetNames) { for (Element element : env.getElementsAnnotatedWith(annotationClass)) { if (!SuperficialValidation.validateElement(element)) continue; try { parseListenerAnnotation(annotationClass, element, builderMap, erasedTargetNames); } catch (Exception e) { StringWriter stackTrace = new StringWriter(); e.printStackTrace(new PrintWriter(stackTrace)); error(element, "Unable to generate view binder for @%s.\n\n%s", annotationClass.getSimpleName(), stackTrace.toString()); } } }
private void collectSubscribers(Set<? extends TypeElement> annotations, RoundEnvironment env, Messager messager) { for (TypeElement annotation : annotations) { Set<? extends Element> elements = env.getElementsAnnotatedWith(annotation); for (Element element : elements) { if (element instanceof ExecutableElement) { ExecutableElement method = (ExecutableElement) element; if (checkHasNoErrors(method, messager)) { TypeElement classElement = (TypeElement) method.getEnclosingElement(); methodsByClass.putElement(classElement, method); } } else { messager.printMessage(Diagnostic.Kind.ERROR, "@Subscribe is only valid for methods", element); } } } }
private Set<String> findInjectedClassNames(RoundEnvironment env) { // First gather the set of classes that have @Inject-annotated members. Set<String> injectedTypeNames = new LinkedHashSet<String>(); for (Element element : env.getElementsAnnotatedWith(Inject.class)) { if (!validateInjectable(element)) { continue; } injectedTypeNames.add(rawTypeToString(element.getEnclosingElement().asType(), '.')); } return injectedTypeNames; }
private void handleException(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv, ProcessingException e) { String errorMessage = errorHelper.getErrorMessage(processingEnv, e, coreVersion); /* * Printing exception as an error on a random element. The exception is not * related to this element, but otherwise it wouldn't show up in eclipse. */ Iterator<? extends TypeElement> iterator = annotations.iterator(); if (iterator.hasNext()) { Element element = roundEnv.getElementsAnnotatedWith(iterator.next()).iterator().next(); LOGGER.error(element, "Something went wrong: {}", errorMessage); } else { LOGGER.error("Something went wrong: {}", errorMessage); } }
@Override public void findAndParseObjects(RoundEnvironment env, Map<String, JsonObjectHolder> jsonObjectMap, Elements elements, Types types) { for (Element element : env.getElementsAnnotatedWith(JsonObject.class)) { try { processJsonObjectAnnotation(element, jsonObjectMap, elements, types); } catch (Exception e) { StringWriter stackTrace = new StringWriter(); e.printStackTrace(new PrintWriter(stackTrace)); error(element, "Unable to generate injector for %s. Stack trace incoming:\n%s", JsonObject.class, stackTrace.toString()); } } }
@Override public void findAndParseObjects(RoundEnvironment env, Map<String, JsonObjectHolder> jsonObjectMap, Elements elements, Types types) { for (Element element : env.getElementsAnnotatedWith(OnJsonParseComplete.class)) { try { processOnCompleteMethodAnnotation(element, jsonObjectMap, elements); } catch (Exception e) { StringWriter stackTrace = new StringWriter(); e.printStackTrace(new PrintWriter(stackTrace)); error(element, "Unable to generate injector for %s. Stack trace incoming:\n%s", OnJsonParseComplete.class, stackTrace.toString()); } } }
@Override public void findAndParseObjects(RoundEnvironment env, Map<String, JsonObjectHolder> jsonObjectMap, Elements elements, Types types) { for (Element element : env.getElementsAnnotatedWith(OnPreJsonSerialize.class)) { try { processOnPreJsonSerializeMethodAnnotation(element, jsonObjectMap, elements); } catch (Exception e) { StringWriter stackTrace = new StringWriter(); e.printStackTrace(new PrintWriter(stackTrace)); error(element, "Unable to generate injector for %s. Stack trace incoming:\n%s", OnPreJsonSerialize.class, stackTrace.toString()); } } }
@Override public void findAndParseObjects(RoundEnvironment env, Map<String, JsonObjectHolder> jsonObjectMap, Elements elements, Types types) { for (Element element : env.getElementsAnnotatedWith(JsonField.class)) { try { processJsonFieldAnnotation(element, jsonObjectMap, elements, types); } catch (Exception e) { StringWriter stackTrace = new StringWriter(); e.printStackTrace(new PrintWriter(stackTrace)); error(element, "Unable to generate injector for %s. Stack trace incoming:\n%s", JsonField.class, stackTrace.toString()); } } }
/** {@inheritDoc} */ @Override public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) { for (Element element : roundEnv.getElementsAnnotatedWith(BugPattern.class)) { gson.toJson(BugPatternInstance.fromElement(element), pw); pw.write("\n"); } if (roundEnv.processingOver()) { // this was the last round, do cleanup cleanup(); } return true; }
void process(RoundEnvironment roundEnv) { for (Element modelFieldElement : roundEnv.getElementsAnnotatedWith(AutoModel.class)) { try { addFieldToControllerClass(modelFieldElement, controllerClassMap); } catch (Exception e) { errorLogger.logError(e); } } try { updateClassesForInheritance(controllerClassMap); } catch (Exception e) { errorLogger.logError(e); } }