|
||||||||||
PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |
java.lang.Objectorg.eclipse.jdt.internal.compiler.AbstractAnnotationProcessorManager
org.eclipse.jdt.internal.compiler.apt.dispatch.BaseAnnotationProcessorManager
public abstract class BaseAnnotationProcessorManager
This class is the central dispatch point for Java 6 annotation processing.
This is created and configured by the JDT core; specifics depend on how
compilation is being performed, ie from the command line, via the Tool
interface, or within the IDE. This class manages the discovery of annotation
processors and other information spanning multiple rounds of processing;
context that is valid only within a single round is managed by
RoundDispatcher
. There may be multiple instances of this class;
there is in general one of these for every Compiler that has annotation
processing enabled. Within the IDE there will typically be one for every
Java project, because each project potentially has a separate processor path.
TODO: do something useful with _supportedOptions and _supportedAnnotationTypes.
Field Summary | |
---|---|
protected PrintWriter |
_err
|
protected boolean |
_isFirstRound
|
protected PrintWriter |
_out
|
protected boolean |
_printProcessorInfo
|
protected boolean |
_printRounds
|
protected BaseProcessingEnvImpl |
_processingEnv
|
protected List<ProcessorInfo> |
_processors
The list of processors that have been loaded so far. |
protected int |
_round
|
Constructor Summary | |
---|---|
BaseAnnotationProcessorManager()
|
Method Summary | |
---|---|
void |
configure(Object batchCompiler,
String[] options)
Configure the receiver using the given batch compiler and the given options. |
void |
configureFromPlatform(Compiler compiler,
Object compilationUnitLocator,
Object javaProject)
Configure the receiver using the given compiler, the given compilationUnitLocator and the given java project. |
ICompilationUnit[] |
getDeletedUnits()
Returns the deleted units. |
List<ProcessorInfo> |
getDiscoveredProcessors()
|
ReferenceBinding[] |
getNewClassFiles()
Return the new binary bindings created in the last round. |
ICompilationUnit[] |
getNewUnits()
Return the new units created in the last round. |
void |
processAnnotations(CompilationUnitDeclaration[] units,
ReferenceBinding[] referenceBindings,
boolean isLastRound)
A single "round" of processing, in the sense implied in javax.lang.annotation.processing.Processor . |
void |
reset()
Reinitialize the receiver |
void |
setErr(PrintWriter err)
Set the print writer for the standard error. |
void |
setOut(PrintWriter out)
Set the print writer for the standard output. |
void |
setProcessors(Object[] processors)
Set the processors for annotation processing. |
Methods inherited from class java.lang.Object |
---|
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait |
Methods inherited from interface org.eclipse.jdt.internal.compiler.apt.dispatch.IProcessorProvider |
---|
discoverNextProcessor, reportProcessorException |
Field Detail |
---|
protected PrintWriter _out
protected PrintWriter _err
protected BaseProcessingEnvImpl _processingEnv
protected boolean _isFirstRound
protected List<ProcessorInfo> _processors
protected boolean _printProcessorInfo
protected boolean _printRounds
protected int _round
Constructor Detail |
---|
public BaseAnnotationProcessorManager()
Method Detail |
---|
public void configure(Object batchCompiler, String[] options)
AbstractAnnotationProcessorManager
AbstractAnnotationProcessorManager.configureFromPlatform(Compiler, Object, Object)
.
configure
in class AbstractAnnotationProcessorManager
batchCompiler
- the given batch compiler objectoptions
- the given optionspublic void configureFromPlatform(Compiler compiler, Object compilationUnitLocator, Object javaProject)
AbstractAnnotationProcessorManager
configureFromPlatform
in class AbstractAnnotationProcessorManager
compiler
- the given compilercompilationUnitLocator
- the given compilation unit locatorjavaProject
- the given java projectpublic List<ProcessorInfo> getDiscoveredProcessors()
getDiscoveredProcessors
in interface IProcessorProvider
IProcessorProvider.discoverNextProcessor()
is called.public ICompilationUnit[] getDeletedUnits()
AbstractAnnotationProcessorManager
getDeletedUnits
in class AbstractAnnotationProcessorManager
public ICompilationUnit[] getNewUnits()
AbstractAnnotationProcessorManager
getNewUnits
in class AbstractAnnotationProcessorManager
public ReferenceBinding[] getNewClassFiles()
AbstractAnnotationProcessorManager
getNewClassFiles
in class AbstractAnnotationProcessorManager
public void reset()
AbstractAnnotationProcessorManager
reset
in class AbstractAnnotationProcessorManager
public void setErr(PrintWriter err)
AbstractAnnotationProcessorManager
setErr
in class AbstractAnnotationProcessorManager
err
- the given print writer for errorpublic void setOut(PrintWriter out)
AbstractAnnotationProcessorManager
setOut
in class AbstractAnnotationProcessorManager
out
- the given print writer for outputpublic void setProcessors(Object[] processors)
AbstractAnnotationProcessorManager
setProcessors
in class AbstractAnnotationProcessorManager
processors
- the given processorspublic void processAnnotations(CompilationUnitDeclaration[] units, ReferenceBinding[] referenceBindings, boolean isLastRound)
javax.lang.annotation.processing.Processor
.
The Java 6 Processor spec contains ambiguities about how processors that support "*" are
handled. Eclipse tries to match Sun's implementation in javac. What that actually does is
analogous to inspecting the set of annotions found in the root units and adding an
"imaginary" annotation if the set is empty. Processors are then called in order of discovery;
for each processor, the intersection between the set of root annotations and the set of
annotations the processor supports is calculated, and if it is non-empty, the processor is
called. If the processor returns true
then the intersection (including the
imaginary annotation if one exists) is removed from the set of root annotations and the loop
continues, until the set is empty. Of course, the imaginary annotation is not actually
included in the set of annotations passed in to the processor. A processor's process() method
is not called until its intersection set is non-empty, but thereafter it is called on every
round. Note that even if a processor is not called in the first round, if it is called in
subsequent rounds, it will be called in the order in which the processors were discovered,
rather than being added to the end of the list.
processAnnotations
in class AbstractAnnotationProcessorManager
units
- the given source typereferenceBindings
- the given binary typesisLastRound
- flag to notify the last round
|
||||||||||
PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |