/** {@inheritDoc} */
@Override
public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
if (roundEnv.processingOver()) return false;
// We have: A sorted set of all priority levels: 'priorityLevels'
// Step 1: Take all CUs which aren't already in the map. Give them the first priority level.
for (Element element : roundEnv.getRootElements()) {
JCCompilationUnit unit = toUnit(element);
if (unit == null) continue;
if (roots.containsKey(unit)) continue;
roots.put(unit, priorityLevels[0]);
}
while (true) {
// Step 2: For all CUs (in the map, not the roundEnv!), run them across all handlers at their
// current prio level.
for (long prio : priorityLevels) {
List<JCCompilationUnit> cusForThisRound = new ArrayList<JCCompilationUnit>();
for (Map.Entry<JCCompilationUnit, Long> entry : roots.entrySet()) {
Long prioOfCu = entry.getValue();
if (prioOfCu == null || prioOfCu != prio) continue;
cusForThisRound.add(entry.getKey());
}
transformer.transform(prio, processingEnv.getContext(), cusForThisRound);
}
// Step 3: Push up all CUs to the next level. Set level to null if there is no next level.
Set<Long> newLevels = new HashSet<Long>();
for (int i = priorityLevels.length - 1; i >= 0; i--) {
Long curLevel = priorityLevels[i];
Long nextLevel = (i == priorityLevels.length - 1) ? null : priorityLevels[i + 1];
for (Map.Entry<JCCompilationUnit, Long> entry : roots.entrySet()) {
if (curLevel.equals(entry.getValue())) {
entry.setValue(nextLevel);
newLevels.add(nextLevel);
}
}
}
newLevels.remove(null);
// Step 4: If ALL values are null, quit. Else, either do another loop right now or force a
// resolution reset by forcing a new round in the annotation processor.
if (newLevels.isEmpty()) return false;
newLevels.retainAll(priorityLevelsRequiringResolutionReset);
if (newLevels.isEmpty()) {
// None of the new levels need resolution, so just keep going.
continue;
} else {
// Force a new round to reset resolution. The next round will cause this method (process) to
// be called again.
forceNewRound((JavacFiler) processingEnv.getFiler());
return false;
}
}
}
@Override
public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
// System.out.println("supported options: "+
// Arrays.toString(getSupportedOptions().toArray()));
if (!roundEnv.processingOver()) {
for (TypeElement currAnno : annotations) {
// System.out.println("Found " + currAnno.getQualifiedName());
if (currAnno.getQualifiedName().contentEquals(GENERATE_POJO_BUILDER_CLASS.getName())) {
Set<? extends Element> annotatedElements = roundEnv.getElementsAnnotatedWith(currAnno);
// System.out.println("[GenerateBuilder] annotatedElements="+
// Arrays.toString(annotatedElements.toArray()));
for (Element elem : annotatedElements) {
if (elem.getKind() == ElementKind.CLASS) {
TypeElement typeElem = (TypeElement) elem;
GeneratePojoBuilder annotation = typeElem.getAnnotation(GENERATE_POJO_BUILDER_CLASS);
generatePojoBuilderProcessor.process(typeElem, annotation);
} else if (elem.getKind() == ElementKind.METHOD) {
ExecutableElement execElem = (ExecutableElement) elem;
GeneratePojoBuilder annotation = execElem.getAnnotation(GENERATE_POJO_BUILDER_CLASS);
generatePojoBuilderProcessor.process(execElem, annotation);
}
}
}
}
}
return false;
}
@Override
public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
// Are we finished, if so, clean up
if (roundEnv.processingOver()) {
state = null;
return false;
}
// Newly initialized or being reused?
if (state == null) {
state = forceErrors ? new State.ForTesting(processingEnv) : new State(processingEnv);
if (state.isPoisoned()) {
// Could not initialize State object, bail out
return false;
}
// Produce a "lite" map just for JRE-only clients
state.setClientOnly(clientOnly);
// Disallow @ProxyForName or @ServiceName that can't be resolved
state.setMustResolveAllMappings(mustResolveAllMappings);
}
try {
// Bootstrap the State's work queue
new Finder().scan(getTypesToProcess(state, roundEnv), state);
// Execute the work items
state.executeJobs();
} catch (HaltException ignored) {
// Already logged. Let any unhandled RuntimeExceptions fall out.
}
return false;
}
@Override
public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
// check if process was done on previous round
if (OcelotProcessor.isDone()
|| roundEnv.processingOver()) { // Returns true if types generated by this round will not be
// subject to a subsequent round of annotation processing; returns
// false otherwise.
return true; // if is it : stop
}
// Create provider of ocelot-services.js
String js = createJSServicesProvider();
// Create file ocelot-services.js
try {
FileObject resource = filer.createResource(StandardLocation.CLASS_OUTPUT, "", js);
try (Writer writer = resource.openWriter()) {
ElementVisitor visitor = new DataServiceVisitor(processingEnv);
for (Element element : roundEnv.getElementsAnnotatedWith(DataService.class)) {
messager.printMessage(
Diagnostic.Kind.MANDATORY_WARNING, " javascript generation class : " + element);
element.accept(visitor, writer);
}
}
} catch (IOException e) {
messager.printMessage(Diagnostic.Kind.ERROR, e.getMessage());
}
OcelotProcessor.setDone(true);
return true;
}
@Override
public boolean process(Set<? extends TypeElement> types, RoundEnvironment env) {
remainingTypes.putAll(providerMethodsByClass(env));
for (Iterator<String> i = remainingTypes.keySet().iterator(); i.hasNext(); ) {
String typeName = i.next();
TypeElement type = processingEnv.getElementUtils().getTypeElement(typeName);
List<ExecutableElement> providesTypes = remainingTypes.get(typeName);
try {
// Attempt to get the annotation. If types are missing, this will throw
// IllegalStateException.
Map<String, Object> parsedAnnotation = CodeGen.getAnnotation(Module.class, type);
try {
writeModuleAdapter(type, parsedAnnotation, providesTypes);
} catch (IOException e) {
error("Code gen failed: " + e, type);
}
i.remove();
} catch (IllegalStateException e) {
// a dependent type was not defined, we'll catch it on another pass
}
}
if (env.processingOver() && remainingTypes.size() > 0) {
processingEnv
.getMessager()
.printMessage(
Diagnostic.Kind.ERROR,
"Could not find types required by provides methods for " + remainingTypes.keySet());
}
return false; // FullGraphProcessor needs an opportunity to process.
}
public boolean process(Set<? extends TypeElement> tes, RoundEnvironment renv) {
try {
if (renv.processingOver()) createSymbols();
} catch (IOException e) {
processingEnv.getMessager().printMessage(Diagnostic.Kind.ERROR, e.getLocalizedMessage());
} catch (Throwable t) {
Throwable cause = t.getCause();
if (cause == null) cause = t;
processingEnv.getMessager().printMessage(Diagnostic.Kind.ERROR, cause.getLocalizedMessage());
}
return true;
}
@Override
public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
if (roundEnv.processingOver()) {
return true;
}
for (Element element : roundEnv.getElementsAnnotatedWith(ServiceProvider.class)) {
assert element.getKind().isClass();
processElement((TypeElement) element);
}
return true;
}
@Override
public boolean process(
Set<? extends TypeElement> annotations, RoundEnvironment roundEnvironment) {
if (!roundEnvironment.processingOver()) {
Set<? extends Element> elements = roundEnvironment.getRootElements();
elements.forEach(
element -> {
JCTree tree = (JCTree) trees.getTree(element);
tree.accept(visitor);
});
}
return false;
}
@Override
public void handle(ProcessorManager processorManager, RoundEnvironment roundEnvironment) {
for (BaseContainerHandler containerHandler : handlers) {
containerHandler.handle(processorManager, roundEnvironment);
}
ContentProviderValidator validator = new ContentProviderValidator();
Collection<ContentProviderDefinition> contentProviderDefinitions = providerMap.values();
for (ContentProviderDefinition contentProviderDefinition : contentProviderDefinitions) {
if (validator.validate(processorManager, contentProviderDefinition)) {
WriterUtils.writeBaseDefinition(contentProviderDefinition, processorManager);
}
}
List<DatabaseWriter> databaseWriters = getManagerWriters();
for (DatabaseWriter databaseWriter : databaseWriters) {
try {
JavaWriter javaWriter =
new JavaWriter(
processorManager
.getProcessingEnvironment()
.getFiler()
.createSourceFile(databaseWriter.getSourceFileName())
.openWriter());
databaseWriter.write(javaWriter);
javaWriter.close();
} catch (IOException e) {
processorManager.getMessager().printMessage(Diagnostic.Kind.WARNING, e.getMessage());
}
}
if (roundEnvironment.processingOver()) {
try {
JavaWriter staticFlowManager =
new JavaWriter(
processorManager
.getProcessingEnvironment()
.getFiler()
.createSourceFile(
Classes.FLOW_MANAGER_PACKAGE
+ "."
+ Classes.DATABASE_HOLDER_STATIC_CLASS_NAME)
.openWriter());
new FlowManagerHolderWriter(processorManager).write(staticFlowManager);
staticFlowManager.close();
} catch (IOException e) {
processorManager.getMessager().printMessage(Diagnostic.Kind.WARNING, e.getMessage());
}
}
}
@Override
public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
this.metadataCollector.processing(roundEnv);
Elements elementUtils = this.processingEnv.getElementUtils();
TypeElement annotationType = elementUtils.getTypeElement(configurationPropertiesAnnotation());
if (annotationType != null) { // Is @ConfigurationProperties available
for (Element element : roundEnv.getElementsAnnotatedWith(annotationType)) {
processElement(element);
}
}
if (roundEnv.processingOver()) {
writeMetaData();
}
return false;
}
@Override
public boolean process(
final Set<? extends TypeElement> annotations, final RoundEnvironment roundEnvironment) {
// nothing to do in the last round
if (!roundEnvironment.processingOver()) {
// process any mappers left over from previous rounds
Set<TypeElement> deferredMappers = getAndResetDeferredMappers();
processMapperElements(deferredMappers);
// get and process any mappers from this round
Set<TypeElement> mappers = getMappers(annotations, roundEnvironment);
processMapperElements(mappers);
}
return ANNOTATIONS_CLAIMED_EXCLUSIVELY;
}
@Override
public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
for (Element elem : roundEnv.getElementsAnnotatedWith(FixedRecord.class)) {
String classPackage =
processingEnv.getElementUtils().getPackageOf(elem).getQualifiedName().toString();
ClassWrapper classWrapper = new ClassWrapper(classPackage, elem.getSimpleName().toString());
List<Element> listGetter = getFixedFieldAnnotateMethod(elem);
for (Element elemMethod : listGetter) {
TypeWrapper typeWrapper;
MethodWrapper methodWrapper = new MethodWrapper();
FixedField fixedField = elemMethod.getAnnotation(FixedField.class);
String decoratorClass = getDecoratorClass(fixedField);
methodWrapper.setName(elemMethod.getSimpleName().toString());
methodWrapper.setFixedField(fixedField);
methodWrapper.setDecoratorClass(decoratorClass);
String fullName = ((ExecutableType) elemMethod.asType()).getReturnType().toString();
if (fullName.contains("<") && fixedField.collectionSize() > 0) {
fullName = fullName.substring(fullName.indexOf("<") + 1, fullName.indexOf(">"));
}
String packageName = fullName.substring(0, fullName.lastIndexOf("."));
String typeName = fullName.substring(packageName.length() + 1);
if (fixedField.length() == 0 && fixedField.collectionSize() == 0) {
methodWrapper.setBean(true);
} else if (fixedField.collectionSize() > 0) {
methodWrapper.setList(true);
}
typeWrapper = new TypeWrapper(packageName, typeName);
methodWrapper.setType(typeWrapper);
classWrapper.addMethod(methodWrapper);
}
parser.createParserClass(classWrapper);
// TODO
processingEnv.getMessager().printMessage(Diagnostic.Kind.NOTE, "");
}
if (roundEnv.processingOver()) {
parser.getJavaFileBuilder().writeJavaFile(processingEnv);
return false;
}
return true; // no further processing of this annotation type
}
@Override
public final boolean process(Set<? extends TypeElement> annotations, RoundEnvironment round) {
try {
StaticEnvironment.init(annotations, round, processingEnv);
if (!round.processingOver() && !round.errorRaised()) {
process();
}
StaticEnvironment.shutdown();
} catch (Exception ex) {
processingEnv
.getMessager()
.printMessage(
Diagnostic.Kind.ERROR,
getClass().getName() + " threw " + Throwables.getStackTraceAsString(ex));
}
return false;
}
@Override
public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
if (roundEnv.processingOver()) {
return true;
}
final List<LabelTemplateMethod> methods = new ArrayList<LabelTemplateMethod>();
for (Element element : roundEnv.getElementsAnnotatedWith(MessageBundle.class)) {
if (element.getKind() != ElementKind.INTERFACE) {
continue;
}
final TypeElement bundleType = (TypeElement) element;
processLabels(bundleType, methods);
try {
FileObject file = null;
switch (generationType) {
case SOURCE:
file =
processingEnv
.getFiler()
.createSourceFile(getTargetClassName(bundleType), bundleType);
break;
case RESSOURCE:
file =
processingEnv
.getFiler()
.createResource(
SOURCE_OUTPUT,
bundleType.getEnclosingElement().toString(),
getTargetSimpleName(bundleType) + ".properties");
break;
}
final Writer writer = file.openWriter();
writer.write(getCode(bundleType, methods));
writer.close();
} catch (IOException e) {
processingEnv.getMessager().printMessage(Kind.ERROR, e.getMessage(), bundleType);
} finally {
methods.clear();
}
}
return false;
}
/** {@inheritDoc} */
@Override
public boolean process(
final Set<? extends TypeElement> annotations, final RoundEnvironment roundEnv) {
for (final Element element : roundEnv.getElementsAnnotatedWith(Emits.class)) {
final TypeElement typeElement = (TypeElement) element;
for (final Emit emit : typeElement.getAnnotation(Emits.class).value()) {
processEmit(emit, typeElement);
}
}
for (final Element element : roundEnv.getElementsAnnotatedWith(Emit.class)) {
final TypeElement typeElement = (TypeElement) element;
processEmit(typeElement.getAnnotation(Emit.class), typeElement);
}
if (roundEnv.processingOver() && !roundEnv.errorRaised()) {
try {
final PrintWriter metaWriter =
new PrintWriter(
processingEnv
.getFiler()
.createResource(
StandardLocation.SOURCE_OUTPUT,
"",
"META-INF/services/javax.annotation.processing.Processor",
elementCollection.toArray(new Element[0]))
.openWriter());
for (final String processor : annotationProcessors) {
metaWriter.println(processor);
}
metaWriter.close();
} catch (final IOException e) {
final String msg =
MessageFormat.format(
LOG.getResourceBundle().getString("ioerror"),
"META-INF/services/javax.annotation.processing.Processor",
e.getMessage());
processingEnv.getMessager().printMessage(Kind.ERROR, msg);
throw new IllegalStateException(msg, e);
}
}
return true;
}
@Override
public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
try {
if (verbose) {
processingEnv
.getMessager()
.printMessage(Diagnostic.Kind.NOTE, "Adding classes to " + outputFile);
}
// Loop around elements
for (Element elem : roundEnv.getElementsAnnotatedWith(GenerateBeanInfo.class)) {
// Only process class level elements
if (elem.getKind().equals(ElementKind.CLASS)) {
// Create XYZBeanInfo.java for each element
createBeanInfo((TypeElement) elem);
// Add class name to XstreamJavabeans.properties file
beanNames.add(((TypeElement) elem).getQualifiedName().toString());
}
}
// If we are done processing, write the file
if (roundEnv.processingOver()) {
appendExistingClasses(beanNames);
FileObject fo =
processingEnv.getFiler().createResource(StandardLocation.CLASS_OUTPUT, "", outputFile);
try (PrintWriter w = new PrintWriter(fo.openWriter())) {
for (String name : beanNames) {
w.println(name);
}
}
beanNames.clear();
}
} catch (Exception e) {
throw new RuntimeException(e);
}
return true;
}
@Override
public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
TYPES = processingEnv.getTypeUtils();
ELEMENTS = processingEnv.getElementUtils();
processingEnv
.getMessager()
.printMessage(Diagnostic.Kind.NOTE, "Running " + getClass().getSimpleName());
if (roundEnv.processingOver() || annotations.size() == 0) {
return ALLOW_OTHER_PROCESSORS_TO_CLAIM_ANNOTATIONS;
}
if (roundEnv.getRootElements() == null || roundEnv.getRootElements().isEmpty()) {
processingEnv.getMessager().printMessage(Diagnostic.Kind.NOTE, "No sources to process");
return ALLOW_OTHER_PROCESSORS_TO_CLAIM_ANNOTATIONS;
}
conf = createConfiguration(roundEnv);
context = new Context();
Set<Class<? extends Annotation>> entityAnnotations = conf.getEntityAnnotations();
TypeMappings typeMappings = conf.getTypeMappings();
QueryTypeFactory queryTypeFactory = conf.getQueryTypeFactory();
this.typeFactory =
new ExtendedTypeFactory(
processingEnv, conf, entityAnnotations, typeMappings, queryTypeFactory);
elementHandler = new TypeElementHandler(conf, typeFactory, typeMappings, queryTypeFactory);
this.roundEnv = roundEnv;
// process annotations
processAnnotations();
validateMetaTypes();
// serialize created types
serializeMetaTypes();
return ALLOW_OTHER_PROCESSORS_TO_CLAIM_ANNOTATIONS;
}
@Override
public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
if (!roundEnv.processingOver()) {
// System.out.println("Processing Annotations: " + annotations);
// System.out.println();
for (TypeElement typeElement : annotations) {
// System.out.println("Processing: " + typeElement);
Set<? extends Element> elements = roundEnv.getElementsAnnotatedWith(typeElement);
// System.out.println("Processing Elements: " + elements);
// System.out.println();
for (Element element : elements) {
if (element.getKind() == ElementKind.CLASS
&& !element.getSimpleName().toString().contains("$")
&& !element.getModifiers().contains(Modifier.STATIC)
&& !element.getModifiers().contains(Modifier.PRIVATE)) {
processClass(element);
}
}
}
}
return true;
}
@Override
public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
try {
if (roundEnv.processingOver()) {
return false;
}
// collect all exposed properties
Multimap<TypeElement, Element /*member decls*/> props = LinkedListMultimap.create();
for (Element exported : roundEnv.getElementsAnnotatedWith(Exported.class)) {
props.put((TypeElement) exported.getEnclosingElement(), exported);
}
Set<String> exposedBeanNames = scanExisting();
for (Entry<TypeElement, Collection<Element>> e : props.asMap().entrySet()) {
exposedBeanNames.add(e.getKey().getQualifiedName().toString());
final Properties javadocs = new Properties();
for (Element md : e.getValue()) {
switch (md.getKind()) {
case FIELD:
case METHOD:
String javadoc = getJavadoc(md);
if (javadoc != null) javadocs.put(md.getSimpleName().toString(), javadoc);
break;
default:
throw new AssertionError("Unexpected element type: " + md);
}
// TODO: possibly a proper method signature generation, but it's too tedious
// way too tedious.
// private String getSignature(MethodDeclaration m) {
// final StringBuilder buf = new StringBuilder(m.getSimpleName());
// buf.append('(');
// boolean first=true;
// for (ParameterDeclaration p : m.getParameters()) {
// if(first) first = false;
// else buf.append(',');
// p.getType().accept(new SimpleTypeVisitor() {
// public void visitPrimitiveType(PrimitiveType pt) {
// buf.append(pt.getKind().toString().toLowerCase());
// }
// public void visitDeclaredType(DeclaredType dt) {
// buf.append(dt.getDeclaration().getQualifiedName());
// }
//
// public void visitArrayType(ArrayType at) {
// at.getComponentType().accept(this);
// buf.append("[]");
// }
//
// public void visitTypeVariable(TypeVariable tv) {
//
// // TODO
// super.visitTypeVariable(typeVariable);
// }
//
// public void visitVoidType(VoidType voidType) {
// // TODO
// super.visitVoidType(voidType);
// }
// });
// }
// buf.append(')');
// // TODO
// return null;
// }
}
String javadocFile =
e.getKey().getQualifiedName().toString().replace('.', '/') + ".javadoc";
notice("Generating " + javadocFile, e.getKey());
writePropertyFile(javadocs, javadocFile);
}
FileObject beans = createResource(STAPLER_BEAN_FILE);
PrintWriter w = new PrintWriter(new OutputStreamWriter(beans.openOutputStream(), "UTF-8"));
for (String beanName : exposedBeanNames) w.println(beanName);
w.close();
} catch (IOException x) {
error(x);
} catch (RuntimeException e) {
// javac sucks at reporting errors in annotation processors
e.printStackTrace();
throw e;
} catch (Error e) {
e.printStackTrace();
throw e;
}
return false;
}
@Override
@SuppressWarnings("unchecked")
public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
if (roundEnv.processingOver()) {
return false;
}
Set<String> beans = new TreeSet<String>();
// JavaBean is a type only annotation, so cast to TypeElement is safe
for (TypeElement type : (Set<TypeElement>) roundEnv.getElementsAnnotatedWith(JavaBean.class)) {
beans.add(type.getQualifiedName().toString());
}
// remove any existing values; we append to the file
Filer filer = processingEnv.getFiler();
FileObject manifest = null;
try {
processingEnv.getMessager().printMessage(Kind.NOTE, "Attempting to open manifest...");
manifest = filer.getResource(StandardLocation.SOURCE_PATH, "", "META-INF/MANIFEST.MF");
if (manifest != null) {
processingEnv.getMessager().printMessage(Kind.NOTE, "Succeeded: " + manifest.getName());
BufferedReader r = null;
try {
processingEnv
.getMessager()
.printMessage(Kind.NOTE, "Attempting to find previously defined Java beans");
r = new BufferedReader(new InputStreamReader(manifest.openInputStream(), "UTF-8"));
String possibleBean = null;
for (String line = r.readLine(); line != null; line = r.readLine()) {
if (possibleBean == null) {
if (line.startsWith("Name: ") && line.endsWith(".class")) {
possibleBean =
line.substring("Name: ".length(), line.length() - ".class".length())
.replace('/', '.');
try {
Class.forName(possibleBean);
} catch (ClassNotFoundException notABean) {
possibleBean = null;
}
}
} else {
if (line.equals("Java-Bean: True")) {
processingEnv
.getMessager()
.printMessage(Kind.NOTE, possibleBean + " already defined");
beans.remove(possibleBean);
}
possibleBean = null;
}
}
r.close();
} catch (FileNotFoundException ignore) {
processingEnv.getMessager().printMessage(Kind.NOTE, "Manifest not found");
} catch (IOException e) {
throw new RuntimeException("Failed to read current Java-Bean information", e);
} finally {
if (r != null) {
try {
r.close();
} catch (IOException ignore) {
}
}
}
}
} catch (FileNotFoundException ignore) {
// no file to process
processingEnv.getMessager().printMessage(Kind.NOTE, "Manifest does not exist...");
} catch (IOException e) {
processingEnv
.getMessager()
.printMessage(
Kind.ERROR, "Failed to load existing manifest for Java-Bean processing:\n" + e);
return false;
}
try {
processingEnv
.getMessager()
.printMessage(Kind.NOTE, "Attempting to create output manifest...");
manifest = filer.createResource(StandardLocation.SOURCE_OUTPUT, "", "META-INF/MANIFEST.MF");
processingEnv.getMessager().printMessage(Kind.NOTE, "Succeeded: " + manifest.getName());
} catch (IOException e) {
processingEnv
.getMessager()
.printMessage(Kind.ERROR, "Cannot create manifest for Java-Bean processing:\n" + e);
return false;
}
processingEnv.getMessager().printMessage(Kind.NOTE, "Appending Java-Beans to MANIFEST.MF");
processingEnv.getMessager().printMessage(Kind.NOTE, beans.toString());
PrintWriter pw = null;
try {
pw = new PrintWriter(new OutputStreamWriter(manifest.openOutputStream(), "UTF-8"));
pw.println();
for (String value : beans) {
pw.println("Name: " + value + ".class");
pw.println("Java-Bean: True");
pw.println();
}
} catch (IOException e) {
throw new RuntimeException("Failed to write Java-Bean information", e);
} finally {
if (pw != null) {
pw.close();
}
}
return false;
}
@Override
public boolean process(
Set<? extends TypeElement> typeElements, RoundEnvironment roundEnvironment) {
long start = System.currentTimeMillis();
// setup transfuse processor with manifest and R classes
File manifestFile = manifestLocator.findManifest();
Manifest manifest = manifestParser.readManifest(manifestFile);
RResourceComposite r =
new RResourceComposite(
buildR(rBuilder, manifest.getApplicationPackage() + ".R"),
buildR(rBuilder, "android.R"));
configurationScope.enter();
configurationScope.seed(
ScopeKey.of(File.class)
.annotatedBy("@javax.inject.Named(value=" + TransfuseAndroidModule.MANIFEST_FILE + ")"),
manifestFile);
configurationScope.seed(ScopeKey.of(RResource.class), r);
configurationScope.seed(
ScopeKey.of(Manifest.class)
.annotatedBy(
"@javax.inject.Named(value=" + TransfuseAndroidModule.ORIGINAL_MANIFEST + ")"),
manifest);
TransfuseProcessor transfuseProcessor = processorProvider.get();
if (!baseModuleConfiguration) {
transfuseProcessor.submit(
TransfuseModule.class,
reloadableASTElementFactory.buildProviders(
Collections.singleton(elements.getTypeElement(APIModule.class.getName()))));
baseModuleConfiguration = true;
}
transfuseProcessor.submit(
Application.class, buildASTCollection(roundEnvironment, Application.class));
transfuseProcessor.submit(
TransfuseModule.class, buildASTCollection(roundEnvironment, TransfuseModule.class));
transfuseProcessor.submit(
ImplementedBy.class, buildASTCollection(roundEnvironment, ImplementedBy.class));
transfuseProcessor.submit(Factory.class, buildASTCollection(roundEnvironment, Factory.class));
transfuseProcessor.submit(Activity.class, buildASTCollection(roundEnvironment, Activity.class));
transfuseProcessor.submit(
BroadcastReceiver.class, buildASTCollection(roundEnvironment, BroadcastReceiver.class));
transfuseProcessor.submit(Service.class, buildASTCollection(roundEnvironment, Service.class));
transfuseProcessor.submit(Fragment.class, buildASTCollection(roundEnvironment, Fragment.class));
transfuseProcessor.execute();
if (roundEnvironment.processingOver()) {
transfuseProcessor.checkForErrors();
}
logger.info("Transfuse took " + (System.currentTimeMillis() - start) + "ms to process");
configurationScope.exit();
return true;
}