xdean.annotation.processor.toolkit.meta

Class AbstractMetaProcessor<T extends Annotation>

java.lang.Object

javax.annotation.processing.AbstractProcessor

xdean.annotation.processor.toolkit.XAbstractProcessor

xdean.annotation.processor.toolkit.meta.AbstractMetaProcessor<T>

All Implemented Interfaces:

Processor, CommonUtil

public abstract class AbstractMetaProcessor<T extends Annotation>
extends XAbstractProcessor

Nested Class Summary

Nested classes/interfaces inherited from class xdean.annotation.processor.toolkit.XAbstractProcessor

XAbstractProcessor.Assert<T>, XAbstractProcessor.Log

Nested classes/interfaces inherited from interface xdean.annotation.processor.toolkit.CommonUtil

CommonUtil.ActionE0<E extends Exception>, CommonUtil.FuncE0<R,E extends Exception>

Field Summary

Fields

Modifier and Type	Field and Description
protected Class<T>	metaClass
protected NestCompileFile	metaFile
protected Set<TypeElement>	nestMetaAnnotations

Fields inherited from class xdean.annotation.processor.toolkit.XAbstractProcessor

elements, filer, isDebug, messager, types

Fields inherited from class javax.annotation.processing.AbstractProcessor

processingEnv

Constructor Summary

Constructors

Constructor and Description
AbstractMetaProcessor()

Method Summary

Modifier and Type	Method and Description
Set<String>	getSupportedAnnotationTypes() If the processor class is annotated with SupportedAnnotation or SupportedAnnotationTypes, return an unmodifiable set with the same set of strings as the annotation.
protected TypeElement	handleMetaFor(TypeElement origin)
void	init(ProcessingEnvironment processingEnv)
protected String	metaPath(Class<?> metaClass)
protected abstract void	process(RoundEnvironment env, T t, AnnotationMirror mid, Element element)
boolean	processActual(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) Processes a set of annotation types on type elements originating from the prior round and returns whether or not these annotation types are claimed by this processor.
protected void	processMeta(RoundEnvironment env, T t, Element element)
protected void	writeMetaClasses(List<TypeElement> annotatedAnnotations)

Methods inherited from class xdean.annotation.processor.toolkit.XAbstractProcessor

assertDo, assertDo, assertNonNull, assertThat, assertThat, assertThat, assertType, debug, error, handleAssert, process, warning

Methods inherited from class javax.annotation.processing.AbstractProcessor

getCompletions, getSupportedOptions, getSupportedSourceVersion, isInitialized

Methods inherited from class java.lang.Object

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

Methods inherited from interface xdean.annotation.processor.toolkit.CommonUtil

ensureFileSystem, getStackTraceString, throwAsUncheck, uncatch, uncatch, uncheck, uncheck

Field Detail

metaClass

protected Class<T extends Annotation> metaClass

metaFile

protected NestCompileFile metaFile

nestMetaAnnotations

protected Set<TypeElement> nestMetaAnnotations

Constructor Detail

AbstractMetaProcessor

public AbstractMetaProcessor()

Method Detail

init

public void init(ProcessingEnvironment processingEnv)

Description copied from class: XAbstractProcessor

Specified by:

init in interface Processor

Overrides:

init in class XAbstractProcessor

processActual

public boolean processActual(Set<? extends TypeElement> annotations,
                             RoundEnvironment roundEnv)
                      throws AssertException

Description copied from class: XAbstractProcessor

Processes a set of annotation types on type elements originating from the prior round and returns whether or not these annotation types are claimed by this processor. If true is returned, the annotation types are claimed and subsequent processors will not be asked to process them; if false is returned, the annotation types are unclaimed and subsequent processors may be asked to process them. A processor may always return the same boolean value or may vary the result based on chosen criteria.

The input set will be empty if the processor supports "*" and the root elements have no annotations. A Processor must gracefully handle an empty set of annotations.

Specified by:

processActual in class XAbstractProcessor

Parameters:

annotations - the annotation types requested to be processed

roundEnv - environment for information about the current and prior round

Returns:

whether or not the set of annotation types are claimed by this processor

Throws:

AssertException - throw the AssertException to quit the process directly

See Also:

XAbstractProcessor.assertThat(boolean), XAbstractProcessor.handleAssert(Runnable)

writeMetaClasses

protected void writeMetaClasses(List<TypeElement> annotatedAnnotations)
                         throws Error

Throws:

Error

handleMetaFor

protected TypeElement handleMetaFor(TypeElement origin)

processMeta

protected void processMeta(RoundEnvironment env,
                           T t,
                           Element element)
                    throws AssertException

Throws:

AssertException

process

protected abstract void process(RoundEnvironment env,
                                T t,
                                AnnotationMirror mid,
                                Element element)
                         throws AssertException

Throws:

AssertException

metaPath

protected String metaPath(Class<?> metaClass)

getSupportedAnnotationTypes

public Set<String> getSupportedAnnotationTypes()

Description copied from class: XAbstractProcessor

If the processor class is annotated with SupportedAnnotation or SupportedAnnotationTypes, return an unmodifiable set with the same set of strings as the annotation. If the class is not so annotated, an empty set is returned.

Specified by:

getSupportedAnnotationTypes in interface Processor

Overrides:

getSupportedAnnotationTypes in class XAbstractProcessor