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); }
public OutputBuilder configure(String templateFile) { return new OutputBuilder(this, processor, templateFile); }
private void merge(OutputBuilder builder, Writer writer) throws IOException { VelocityContext context = builder.getContext(); Optional<Type> type = builder.getType(); Collection<String> imports = cleanupImports(builder.getImports(), type); if (type.isPresent()) { context.put("impl", type.get()); } context.put("processor", builder.getProcessor()); context.put("processingDate", PROCESSING_DATE_FORMAT.format(new Date())); context.put("imports", imports); getEngine().mergeTemplate(builder.getTemplateFile(), ENCODING, context, writer); }
@Override public CodeSnippet process(ResourceMethod resourceMethod) { EndPointMethod endPointMethod = (EndPointMethod) resourceMethod; String methodName = qualifiedMethodName(resourceMethod); EndPoint endPoint = endPointMethod.getEndPoint(); logger.debug("Generating end-point method `%s`.", methodName); CodeSnippet code = outputter.configure(TEMPLATE) .withParam("method", endPointMethod.getMethod()) .withParam("endPointType", endPoint.getType()) .withParam("endPointArguments", endPoint.getFields()) .withErrorLogParameter(methodName) .parse(); endPointProcessor.process(endPoint); return code; }
public void writeTo(Type type) { writeTo(type, OutputType.GWT); }
public OutputBuilder withParams(Map<String, Object> params) { for (Entry<String, Object> param : params.entrySet()) { withParam(param.getKey(), param.getValue()); } return this; }
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; }
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(); } }
void writeSource(OutputBuilder builder) { try (Writer writer = prepareSourceFile(builder).openWriter()) { merge(builder, writer); } catch (IOException e) { logger.error().throwable(e).log("Can not write `%s`.", builder.getErrorLogParameter().get()); throw new UnableToProcessException(); } }
@Override public CodeSnippet process(ResourceMethod resourceMethod) { SubResourceMethod subResourceMethod = (SubResourceMethod) resourceMethod; String methodName = qualifiedMethodName(resourceMethod); SubResource subResource = subResourceMethod.getSubResource(); logger.debug("Generating sub-resource method `%s`.", methodName); CodeSnippet code = outputter.configure(TEMPLATE) .withParam("method", subResourceMethod.getMethod()) .withParam("subResourceType", subResource.getType()) .withParam("subResourceArguments", subResource.getFields()) .withErrorLogParameter(methodName) .parse(); subResourceProcessor.process(subResource); return code; }
public void writeTo(Type type, OutputType outputType) { writeTo(type, outputType, null); }
public OutputBuilder withParam(String key, HasImports value) { context.put(key, value); if (value != null) { withImports(value.getImports()); } // TODO: Resolve simple name clashes if value instanceof Type. In the meantime, use can. names and skip imports. return this; }
private void outputModule(Type moduleType) { logger.debug("Generating GIN module `%s`.", moduleType.getQualifiedName()); FileObject fileObject = sourceFiles.get(moduleType); Multimap<Type, GinBinding> setBindings = setBinders.get(moduleType); Set<Entry<Type, Collection<GinBinding>>> setBindingsEntries = setBindings == null ? new HashSet<>() : setBindings.asMap().entrySet(); outputter .configure(TEMPLATE) .withParam("bindings", bindings.get(moduleType)) .withParam("setBindings", setBindingsEntries) .withParam("subModules", subModules.get(moduleType)) .writeTo(moduleType, fileObject); } }
public void writeTo(Type type, FileObject sourceFile) { writeTo(type, null, sourceFile); }
@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); } }
@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); }
@Override public Void process(EndPoint endPoint) { Type type = endPoint.getType(); logger.debug("Generating end-point implementation `%s`.", type); EndPointDetails endPointDetails = endPoint.getEndPointDetails(); List<CodeSnippet> paramSnippets = createInitializerSnippets(endPointDetails.getHttpVariables()); outputter.configure(TEMPLATE) .withParam("endPoint", endPointDetails) .withParam("paramSnippets", paramSnippets) .withParam("fields", endPoint.getFields()) .writeTo(type); generateSerializers(endPoint); return null; }