Class AbstractTypeProcessor

  • All Implemented Interfaces:
    javax.annotation.processing.Processor
    Direct Known Subclasses:
    BasicTypeProcessor, SignaturePrinter, SourceChecker, TreePrinter

    public abstract class AbstractTypeProcessor
    extends javax.annotation.processing.AbstractProcessor
    This class is an abstract annotation processor designed to be a convenient superclass for concrete "type processors", processors that require the type information in the processed source.

    Type processing occurs in one round after the tool (e.g. Java compiler) analyzes the source (all sources taken as input to the tool and sources generated by other annotation processors).

    The tool infrastructure will interact with classes extending this abstract class as follows.

    1-3 are identical to the Processor life cycle. 4-5 are unique to AbstractTypeProcessor subclasses.

    1. If an existing Processor object is not being used, to create an instance of a processor the tool calls the no-arg constructor of the processor class.
    2. Next, the tool calls the init method with an appropriate ProcessingEnvironment.
    3. Afterwards, the tool calls getSupportedAnnotationTypes, getSupportedOptions, and getSupportedSourceVersion. These methods are only called once per run, not on each round.
    4. For each class containing a supported annotation, the tool calls typeProcess method on the Processor. The class is guaranteed to be type-checked Java code and all the tree type and symbol information is resolved.
    5. Finally, the tool calls the typeProcessingOver method on the Processor.

    The tool is permitted to ask type processors to process a class once it is analyzed before the rest of classes are analyzed. The tool is also permitted to stop type processing immediately if any errors are raised, without invoking typeProcessingOver().

    A subclass may override any of the methods in this class, as long as the general Processor contract is obeyed, with one notable exception. process(Set, RoundEnvironment) may not be overridden, as it is called during the declaration annotation phase before classes are analyzed.

    • Field Summary

      • Fields inherited from class javax.annotation.processing.AbstractProcessor

        processingEnv
    • Constructor Summary

      Constructors 
      Modifier Constructor Description
      protected AbstractTypeProcessor()
      Constructor for subclasses to call.
    • Method Summary

      All Methods Instance Methods Abstract Methods Concrete Methods 
      Modifier and Type Method Description
      com.sun.tools.javac.util.Log getCompilerLog()
      Return the compiler log, which contains errors and warnings.
      void init​(javax.annotation.processing.ProcessingEnvironment env)
      boolean process​(java.util.Set<? extends javax.lang.model.element.TypeElement> annotations, javax.annotation.processing.RoundEnvironment roundEnv)
      The use of this method is obsolete in type processors.
      abstract void typeProcess​(javax.lang.model.element.TypeElement element, com.sun.source.util.TreePath tree)
      Processes a fully-analyzed class that contains a supported annotation (see AbstractProcessor.getSupportedAnnotationTypes()).
      void typeProcessingOver()
      A method to be called once all the classes are processed.
      void typeProcessingStart()
      A method to be called once before the first call to typeProcess.
      • Methods inherited from class javax.annotation.processing.AbstractProcessor

        getCompletions, getSupportedAnnotationTypes, getSupportedOptions, getSupportedSourceVersion, isInitialized
      • Methods inherited from class java.lang.Object

        clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
    • Constructor Detail

      • AbstractTypeProcessor

        protected AbstractTypeProcessor()
        Constructor for subclasses to call.
    • Method Detail

      • init

        public void init​(javax.annotation.processing.ProcessingEnvironment env)

        Register a TaskListener that will get called after FLOW.

        Specified by:
        init in interface javax.annotation.processing.Processor
        Overrides:
        init in class javax.annotation.processing.AbstractProcessor
      • process

        public final boolean process​(java.util.Set<? extends javax.lang.model.element.TypeElement> annotations,
                                     javax.annotation.processing.RoundEnvironment roundEnv)
        The use of this method is obsolete in type processors. The method is called during declaration annotation processing phase only. It registers the names of elements to process.
        Specified by:
        process in interface javax.annotation.processing.Processor
        Specified by:
        process in class javax.annotation.processing.AbstractProcessor
      • typeProcessingStart

        public void typeProcessingStart()
        A method to be called once before the first call to typeProcess.

        Subclasses may override this method to do any initialization work.

      • typeProcess

        public abstract void typeProcess​(javax.lang.model.element.TypeElement element,
                                         com.sun.source.util.TreePath tree)
        Processes a fully-analyzed class that contains a supported annotation (see AbstractProcessor.getSupportedAnnotationTypes()).

        The passed class is always valid type-checked Java code.

        Parameters:
        element - element of the analyzed class
        tree - the tree path to the element, with the leaf being a ClassTree
      • typeProcessingOver

        public void typeProcessingOver()
        A method to be called once all the classes are processed.

        Subclasses may override this method to do any aggregate analysis (e.g. generate report, persistence) or resource deallocation.

        Method getCompilerLog() can be used to access the number of compiler errors.

      • getCompilerLog

        @SideEffectFree
        public com.sun.tools.javac.util.Log getCompilerLog()
        Return the compiler log, which contains errors and warnings.
        Returns:
        the compiler log, which contains errors and warnings