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 FileObject prepareSourceFile(Type type) { return prepareSourceFile(type, OutputType.GWT); }
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); }
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(); } }
public CodeSnippet parse() { return outputter.parse(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(); } }
@Override public synchronized void init(ProcessingEnvironment processingEnv) { super.init(processingEnv); try { Map<String, String> options = processingEnv.getOptions(); logger = new Logger(processingEnv.getMessager(), options); utils = new Utils(logger, processingEnv.getTypeUtils(), processingEnv.getElementUtils(), options); outputter = new Outputter(logger, this, processingEnv.getFiler(), getMacroFiles()); initSafe(); } catch (UnableToProcessException ignore) { } catch (Exception e) { logger.error().throwable(e).log(UNRESOLVABLE_EXCEPTION); } }
@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); } }
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 write() { logger.debug("Generating named provider bundle aggregate `%s`.", type); outputter.configure(TEMPLATE) .withParam("bundles", content) .writeTo(type, file); }
ProviderBundleAggregate( Logger logger, Outputter outputter, String bundleName) { this.logger = logger; this.outputter = outputter; this.type = new Type(PACKAGE_NAME, bundleName + "ProviderBundleAggregate"); this.file = outputter.prepareSourceFile(type); this.content = new ArrayList<>(); }
@Override public void processLast() { logger.debug("Generating Jackson serialization policy `%s`.", impl.getQualifiedName()); outputter.configure(TEMPLATE) .withParam("mappers", mappers.values()) .writeTo(impl, sourceFile); } }
private void ensureSourceFileIsCreated(BindingContext context) { Type moduleType = context.getModuleType(); if (!sourceFiles.containsKey(moduleType)) { FileObject file = outputter.prepareSourceFile(moduleType); sourceFiles.put(moduleType, file); } }
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 BufferedWriter getOrCreateWriter(String bundleName) throws IOException { BufferedWriter writer; if (writers.containsKey(bundleName)) { writer = writers.get(bundleName); } else { FileObject file = outputter.prepareSourceFile(new Type("", "gwtp/bundles/" + bundleName), META_INF); writer = new BufferedWriter(file.openWriter()); writers.put(bundleName, writer); } return writer; }
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); }
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()); } }
@Override public JacksonMapper process(SerializationContext context) { logger.debug("Generating Jackson mapper for `%s`.", context.getType().getQualifiedParameterizedName()); JacksonMapper mapper = processMapper(context); outputter.configure(TEMPLATE) .withParam("mapped", mapper.getMapped()) .writeTo(mapper.getType()); return mapper; }
private void ensureAppDataIsInitialized() { if (registryFile == null) { registryFile = outputter.prepareSourceFile(REGISTRY_TYPE); bindingsProcessors.process(newBinding( MAIN_MODULE_TYPE, new Type(PlaceTokenRegistry.class), REGISTRY_TYPE, Singleton.class)); tokens.addAll(metaInfResource.readAll()); } }
@Override public Type process(ProxyDetails proxy) { logger.debug("Generating proxy `%s`.", proxy.getProxyType()); outputter.configure(TEMPLATE) .withParam("proxy", proxy) .writeTo(proxy.getType()); BundleDetails bundleDetails = proxy.getBundleDetails(); if (bundleDetails != null) { providerBundleProcessor.process(bundleDetails); } proxyModules.bindProxy(proxy); return proxy.getType(); } }