xdean.annotation.processor.toolkit

Class XAbstractProcessor

java.lang.Object

javax.annotation.processing.AbstractProcessor

xdean.annotation.processor.toolkit.XAbstractProcessor

All Implemented Interfaces:

Processor, CommonUtil

Direct Known Subclasses:

AbstractMetaProcessor

public abstract class XAbstractProcessor
extends AbstractProcessor
implements CommonUtil

An more powerful abstract annotation processor designed to be a convenient superclass for most concrete annotation processors.

Differences with AbstractProcessor:

• Use SupportedAnnotation to define supported annotation by Class instead of String
• Assert methods for quick exit rather than check and return
• Convenient access to common utilities and log

Author:

XDean

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
protected class	XAbstractProcessor.Assert<T> ASSERT
protected class	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 Elements	elements
protected Filer	filer
protected boolean	isDebug
protected Messager	messager
protected Types	types

Fields inherited from class javax.annotation.processing.AbstractProcessor

processingEnv

Constructor Summary

Constructors

Constructor and Description
XAbstractProcessor()

Method Summary

Modifier and Type	Method and Description
protected <T> XAbstractProcessor.Assert<T>	assertDo(Callable<T> task)
protected XAbstractProcessor.Assert<Void>	assertDo(CommonUtil.ActionE0<?> task)
protected <T> XAbstractProcessor.Assert<T>	assertNonNull(T t)
protected XAbstractProcessor.Assert<Void>	assertThat(boolean b)
protected <T> XAbstractProcessor.Assert<T>	assertThat(T t, boolean b)
protected <T> XAbstractProcessor.Assert<T>	assertThat(T t, Predicate<T> b)
protected <T> XAbstractProcessor.Assert<T>	assertType(Object o, Class<T> clz)
protected XAbstractProcessor.Log	debug() LOG
protected XAbstractProcessor.Log	error()
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 void	handleAssert(Runnable task) Override this method to do something for AssertException. The default behavior is log the message as error if present.
void	init(ProcessingEnvironment processingEnv)
boolean	process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) Use processActual(Set, RoundEnvironment)
abstract 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 XAbstractProcessor.Log	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

types

protected Types types

elements

protected Elements elements

messager

protected Messager messager

filer

protected Filer filer

isDebug

protected boolean isDebug

Constructor Detail

XAbstractProcessor

public XAbstractProcessor()

Method Detail

init

public void init(ProcessingEnvironment processingEnv)

Specified by:

init in interface Processor

Overrides:

init in class AbstractProcessor

process

public final boolean process(Set<? extends TypeElement> annotations,
                             RoundEnvironment roundEnv)

Use processActual(Set, RoundEnvironment)

Specified by:

process in interface Processor

Specified by:

process in class AbstractProcessor

processActual

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

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.

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:

assertThat(boolean), handleAssert(Runnable)

handleAssert

protected void handleAssert(Runnable task)

Override this method to do something for AssertException.
The default behavior is log the message as error if present.

Parameters:

task - task who will throw AssertException

getSupportedAnnotationTypes

public 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. If the class is not so annotated, an empty set is returned.

Specified by:

getSupportedAnnotationTypes in interface Processor

Overrides:

getSupportedAnnotationTypes in class AbstractProcessor

assertThat

protected <T> XAbstractProcessor.Assert<T> assertThat(T t,
                                                      Predicate<T> b)

assertThat

protected <T> XAbstractProcessor.Assert<T> assertThat(T t,
                                                      boolean b)

assertThat

protected XAbstractProcessor.Assert<Void> assertThat(boolean b)

assertType

protected <T> XAbstractProcessor.Assert<T> assertType(Object o,
                                                      Class<T> clz)

assertNonNull

protected <T> XAbstractProcessor.Assert<T> assertNonNull(T t)

assertDo

protected <T> XAbstractProcessor.Assert<T> assertDo(Callable<T> task)

assertDo

protected XAbstractProcessor.Assert<Void> assertDo(CommonUtil.ActionE0<?> task)

debug

protected XAbstractProcessor.Log debug()

LOG

warning

protected XAbstractProcessor.Log warning()

error

protected XAbstractProcessor.Log error()