checkers.source

Class AbstractTypeProcessor

java.lang.Object

javax.annotation.processing.AbstractProcessor

checkers.source.AbstractTypeProcessor

All Implemented Interfaces:

Processor

Direct Known Subclasses:

AggregateChecker, SignaturePrinter, SourceChecker, TreePrinter

public abstract class AbstractTypeProcessor
extends 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: Identical to Processor life cycle]
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-5: Unique to AbstractTypeProcessor subclasses]
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 tools 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.

Author:

Mahmood Ali, Werner Dietl

Field Summary

Fields inherited from class javax.annotation.processing.AbstractProcessor

processingEnv

Constructor Summary

Constructors

Modifier	Constructor and Description
protected	AbstractTypeProcessor() Constructor for subclasses to call.

Method Summary

Methods

Modifier and Type	Method and Description
void	init(ProcessingEnvironment env) Register a TaskListener that will get called after FLOW.
boolean	process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) The use of this method is obsolete in type processors.
abstract void	typeProcess(TypeElement element, @Nullable TreePath tree) Processes a fully analyzed class that contains a supported annotation (look AbstractProcessor.getSupportedAnnotationTypes()).
void	typeProcessingOver() A method to be called once all the classes are processed and no error is reported.
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, toString

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

Constructor Detail

AbstractTypeProcessor

protected AbstractTypeProcessor()

Constructor for subclasses to call.

Method Detail

init

public void init(ProcessingEnvironment env)

Register a TaskListener that will get called after FLOW.

Specified by:

init in interface Processor

Overrides:

init in class AbstractProcessor

process

public final boolean process(Set<? extends TypeElement> annotations,
              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 Processor

Specified by:

process in class 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(TypeElement element,
               @Nullable TreePath tree)

Processes a fully analyzed class that contains a supported annotation (look 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 and no error is reported.

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

If an error (a Java error or a processor error) is reported, this method is not guaranteed to be invoked.