Making a Custom Annotation similar to @Deprecated

Question

I want to make an annotation for a method (and annotation processor) that at compile-time will throw a custom warning/error if a user ever uses the annotated method during compile time.
Currently I have a way to throw a warning/error at the declaration of the method, but not at the method's use.
I'd like it to only throw an error at a usage of the method. I'm thinking i may have to do some tricky stuff with reflection, but I'd like to know if annotations already have some way to do this (I can't find any after several searches).
I'm hoping that it is easy, since @Deprecated already does a similar thing (errors at use, not declaration)
Here's my code at the moment (again, it causes errors for the declarations of the methods, not the uses).
A) The actual annotation
package unsupported;
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 Unsupported {
}B) The annotation processor
package unsupported;
import java.util.Set;
import javax.annotation.processing.AbstractProcessor;
import javax.annotation.processing.ProcessingEnvironment;
import javax.annotation.processing.RoundEnvironment;
import javax.annotation.processing.SupportedAnnotationTypes;
import javax.lang.model.element.Element;
import javax.lang.model.element.TypeElement;
import javax.tools.Diagnostic.Kind;
@SupportedAnnotationTypes("unsupported.Unsupported")
public class UnsupportedProcessor extends AbstractProcessor {
    private ProcessingEnvironment env;
    @Override
    public synchronized void init(ProcessingEnvironment procEnv) {
        this.env = procEnv;
    @Override
    public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
        if (!roundEnv.processingOver()) {
            for (TypeElement myTypeElement : annotations) {
                final Set< ? extends Element> elements = roundEnv.getElementsAnnotatedWith(myTypeElement);
                for (Element elt : elements) {
                    env.getMessager().printMessage(Kind.ERROR,
                            String.format("%s : The Following Element is Unsupported: %s"
                            + "\nThe Compiler will now exit. \n\n", roundEnv.getRootElements(), elt),
                            myTypeElement);
        return true;
}I then compile these 2 files into a JAR, along with the folder: "META_INF/services" that has the file: "javax.annotation.processing.Processor", with 1 line of text giving the path to the processor: "unsupported.UnsupportedProcessor" (this lets javac know to use the processor at compile time)
I can then import this jar to my libraries and use the @Unsupported annotation like this:
class OtherClass1
   @Unsupported
   public void unsupportedmethod()
      System.out.println("hi1") ;
}Then, when compiling the above code i get this:
error: [OtherClass1] : The Following Element is Unsupported: unsupportedmethod()
The Compiler will now exit. Any ideas on how i can modify this to only throw an error when the method is used?
Thanks,
- JT
Edited by: 00jt on Jul 6, 2011 7:57 AM

Answer 1

Hi,
I read your blog. The solution that you provided in the blog is creating new Assignment Block and integrate it in BT application on the UI level. The data is populated from the UI by calling Function Module and fill the value context node.
This will not propagate to GenIL, therefore you will not see any thing on GenIL layer, because there is no integration on GenIL layer.
The approach needs to be the other way around. Your approach is make something available in UI and you want to propagate it to backend(GenIL). The value node that you created in the UI is not dependent object. It is only a context node which is only available in UI. The right approach is you make the dependent object on the backend(GenIL) and than you propagate the dependent object to the UI.
You can try transaction EEWB to create custom table for BT application and this will generate for you also the dependent object on the GenIL layer. This solution provided by EEWB has also a generic assignment block that displays the generated dependent object and show it in BT overview page. To see the generic assignment block from BT you can open the component BT_GEN_EXT.
Regards,
Steve