@Override FileObject createFileObject(Logger logger, Filer filer, Type type) throws IOException { return new GwtFileObject(filer, type); } },
public void writeTo(Type type, OutputType outputType) { writeTo(type, outputType, null); }
public CodeSnippet parse() { return outputter.parse(this); }
public void write() { aggregates.values().forEach(ProviderBundleAggregate::write); logger.debug("Generating named provider bundle collection."); outputter.configure(TEMPLATE) .withParam("bundles", bundles) .withImports(getImports()) .writeTo(TYPE, file); }
private FileObject prepareSourceFile(OutputBuilder builder) throws IOException { Optional<FileObject> sourceFile = builder.getSourceFile(); if (sourceFile.isPresent()) { return sourceFile.get(); } else { return prepareSourceFile(builder.getType().get(), builder.getOutputType().get()); } }
CodeSnippet parse(OutputBuilder builder) { try (Writer writer = new StringWriter()) { merge(builder, writer); String code = writer.toString(); Collection<String> imports = builder.getImports(); return new CodeSnippet(code, imports); } catch (IOException e) { logger.error().throwable(e).log("Can not parse `%s`.", builder.getErrorLogParameter().get()); throw new UnableToProcessException(); } }
public FileObject prepareSourceFile(Type type) { return prepareSourceFile(type, OutputType.GWT); }
public OutputBuilder withParam(String key, Iterable<? extends HasImports> value) { context.put(key, value); if (value != null) { withImports(FluentIterable.from(value).transformAndConcat(EXTRACT_IMPORTS_FUNCTION).toList()); } // TODO: Resolve simple name clashes if value instanceof Type. return this; }
public OutputBuilder configure(String templateFile) { return new OutputBuilder(this, processor, templateFile); }
private void writeTo(Type type, OutputType outputType, FileObject sourceFile) { this.type = of(type); this.sourceFile = fromNullable(sourceFile); this.outputType = fromNullable(outputType); if (!errorLogParameter.isPresent()) { errorLogParameter = of(type.getQualifiedName()); } outputter.writeSource(this); }
@Override public OutputStream openOutputStream() throws IOException { OutputStream prodOutputStream = prodFileObject.openOutputStream(); return new MultiFileOutputStream(prodOutputStream, devFileObject.openOutputStream()); }
@Override public Writer openWriter() throws IOException { Writer prodWriter = prodFileObject.openWriter(); return new MultiFileWriter(prodWriter, devFileObject.openWriter()); }
@Override protected void processAsApp(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) { ensureAppDataIsInitialized(); extractNameTokens(roundEnv); if (roundEnv.processingOver()) { outputter.configure(TEMPLATE) .withParam("tokens", tokens) .writeTo(REGISTRY_TYPE, registryFile); } }
public void writeTo(Type type, FileObject sourceFile) { writeTo(type, null, sourceFile); }
ProviderBundleCollection( Logger logger, Outputter outputter) { this.logger = logger; this.outputter = outputter; this.file = outputter.prepareSourceFile(TYPE); this.bundles = new HashMap<>(); this.aggregates = new HashMap<>(); }
public void writeTo(Type type) { writeTo(type, OutputType.GWT); }
@Override public Void process(SubResource subResource) { Type impl = subResource.getType(); Type subResourceType = subResource.getResourceType(); logger.debug("Generating sub-resource implementation `%s`.", impl); List<CodeSnippet> methods = methodProcessors.processAll(subResource.getMethods()); outputter.configure(TEMPLATE) .withParam("subResourceType", subResourceType) .withParam("methods", methods) .withParam("fields", subResource.getFields()) .writeTo(impl); return null; } }
private void outputBundle(Type bundleType) { logger.debug("Generating provider bundle `%s`.", bundleType); Type roundBundleType = new Type( bundleType.getPackageName(), appendRoundNumber(bundleType.getSimpleName()), bundleType.getTypeArguments()); outputter.configure(TEMPLATE) .withParam("providerTypes", bundleContents.get(bundleType)) .withParam("name", bundleNames.get(bundleType)) .writeTo(roundBundleType); }