annotation-processing

While reading the code of a custom annotation processor in Java, I noticed this piece of code in the processor's process method: @Override public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) { if (!roundEnv.errorRaised() && !roundEnv.processingOver()) { processRound(annotations, roundEnv); } return false; } It happened that I'm working on a custom Annotation processor too, & I wanted to use the snippet above in my annotation processor. I tried the code above this way: if (!roundEnv.errorRaised() && !roundEnv.processingOver()) { processRound(annotations,

I am building an annotation processor plugin for eclipse, what i would like to do is to examine several files inside the project folder during the processing. I would like to know how can I get the project path from within my processor. I believe this can be done because the project source path is provided to the processor - but I cannot find a way to reach it. I tried looking at the System.properties and at the processingEnv.getOptions() but there is no useful information there.. eventually I would like to use this annotation processor on Netbeans too so if there is a public API that can

I'm writing a tool that uses the annotation processor to generate source code depending on the return type of methods of an annotated class. The return type is always some subtype (interface or class) of an interface A that defines a type variable T . interface A<T>{T m();}; I would like to find the type parameter for the method m() return value type variable T . The return type is represented by the annotation processor as a javax.lang.model.type.TypeMirror instance. The simplest case is to return A<T> directly. @SomeAnnotation class SomeClass{ A<T> x(); } The processor code to find out T is

I'm looking to access the generic type of a declared field during runtime. I was previously under the impression that this was not possible due to the Java type erasure. However, this must not be the case because some well known frameworks leverage the generic type through reflection during runtime. As an example, Guice will implement a Provider based upon the generic type you provide: public class Injectable{ @Inject private Provider<SomeType> someTypeProvider; } How does one access the 'SomeType' generic attribute of a field or any such type/method/etc through the reflection API?

I am trying to access the actual original source code of a type from within a Java Annotation Processor. Is this possible somehow? Thanks! Adriano Nobre Oliveira I had a problem where I had to access some source code (the initializer code for a non-String/non-primitive constant) and got it solved by accessing the source code via the Compiler Tree API . Here's the general recipe: 1. Create a custom TreePathScanner: private static class CodeAnalyzerTreeScanner extends TreePathScanner<Object, Trees> { private String fieldName; private String fieldInitializer; public void setFieldName(String

I have an custom annotation called @Pojo which I use for automatic wiki documentation generation: package com.example.annotations; import java.lang.annotation.ElementType; import java.lang.annotation.Retention; import java.lang.annotation.RetentionPolicy; import java.lang.annotation.Target; @Retention(RetentionPolicy.SOURCE) @Target(ElementType.METHOD) public @interface Pojo { Class<?> value(); } I use it like this: @Pojo(com.example.restserver.model.appointment.Appointment.class) to annotation a resource method so that the annotation processor can automatically generate a wiki page describing