public ReflectionCacheSourceCreator (TreeLogger logger, GeneratorContext context, JClassType type) { this.logger = logger; this.context = context; this.type = type; this.packageName = type.getPackage().getName(); this.simpleName = type.getSimpleSourceName() + "Generated"; logger.log(Type.INFO, type.getQualifiedSourceName()); }
public ReflectionCacheSourceCreator (TreeLogger logger, GeneratorContext context, JClassType type) { this.logger = logger; this.context = context; this.type = type; this.packageName = type.getPackage().getName(); this.simpleName = type.getSimpleSourceName() + "Generated"; logger.log(Type.INFO, type.getQualifiedSourceName()); }
private void createProxy (JClassType type) { ClassSourceFileComposerFactory composer = new ClassSourceFileComposerFactory(type.getPackage().getName(), type.getSimpleSourceName() + "Proxy"); PrintWriter printWriter = context.tryCreate(logger, packageName, simpleName); if (printWriter == null) { return; } SourceWriter writer = composer.createSourceWriter(context, printWriter); writer.commit(logger); }
private void createProxy (JClassType type) { ClassSourceFileComposerFactory composer = new ClassSourceFileComposerFactory(type.getPackage().getName(), type.getSimpleSourceName() + "Proxy"); PrintWriter printWriter = context.tryCreate(logger, packageName, simpleName); if (printWriter == null) { return; } SourceWriter writer = composer.createSourceWriter(context, printWriter); writer.commit(logger); }
/** * Returns the import prefix for a type, including the trailing hyphen. */ public static String getImportPrefix(JClassType importType) { String prefix = importType.getSimpleSourceName(); ImportedWithPrefix exp = importType.getAnnotation(ImportedWithPrefix.class); if (exp != null) { prefix = exp.value(); } return prefix + "-"; }
/** * Returns the import prefix for a type, including the trailing hyphen. */ public static String getImportPrefix(JClassType importType) { String prefix = importType.getSimpleSourceName(); ImportedWithPrefix exp = importType.getAnnotation(ImportedWithPrefix.class); if (exp != null) { prefix = exp.value(); } return prefix + "-"; }
if (!writer.isElementAssignableTo(toAdd, paramClass)) { writer.die(child, "Expected child of type %s in %s, found %s", paramClass.getSimpleSourceName(), child, toAdd);
static String badContextReturnType(JMethod method, JClassType requestInterface, JClassType instanceRequestInterface) { return String.format("Return type %s in method %s must be an interface assignable" + " to %s or %s", method.getReturnType(), method.getName(), requestInterface .getSimpleSourceName(), instanceRequestInterface.getSimpleSourceName()); }
static String badContextReturnType(JMethod method, JClassType requestInterface, JClassType instanceRequestInterface) { return String.format("Return type %s in method %s must be an interface assignable" + " to %s or %s", method.getReturnType(), method.getName(), requestInterface .getSimpleSourceName(), instanceRequestInterface.getSimpleSourceName()); }
protected String getName(JClassType source) { if (source.getEnclosingType() != null) { return getName(source.getEnclosingType()) + "_" + source.getSimpleSourceName(); } return source.getSimpleSourceName(); }
protected String getName(JClassType source) { if (source.getEnclosingType() != null) { return getName(source.getEnclosingType()) + "_" + source.getSimpleSourceName(); } return source.getSimpleSourceName(); }
/** * Returns the import prefix for a type, including the trailing hyphen. */ public static String getImportPrefix(JClassType importType) { String prefix = importType.getSimpleSourceName(); ImportedWithPrefix exp = importType.getAnnotation(ImportedWithPrefix.class); if (exp != null) { prefix = exp.value(); } return prefix + "-"; }
@Override public void createDelegates(JClassType injectableType, Collection<InjectorCreatorDelegate> delegates) { Collection<JMethod> methods = InjectCreatorUtil.listMethod(injectableType, PresentHandler.class); delegates.add(new InjectPresenterCreator(methods)); Collection<JField> services = InjectCreatorUtil.listFields(injectableType, InjectService.class); String injectorName = injectableType.getSimpleSourceName() + AbstractInjectorCreator.PROXY_SUFFIX; delegates.add(new SuspendServiceOnPresentCreator(injectorName, !services.isEmpty())); }
public InjectTemplateCreator(JClassType viewType) { this.viewType = viewType; this.templateInterfaceName = viewType.getSimpleSourceName() + "TemplateBinder"; Templated templateAnnotation = viewType.getAnnotation(Templated.class); if (Templated.DEFAULT_VALUE.equals(templateAnnotation.value())) { this.templateName = null; } else { this.templateName = templateAnnotation.value(); } }
private void generateCreate(TreeLogger logger, SourceWriter srcWriter) { srcWriter.println("public %s newInstance() {", this.beanType.getSimpleSourceName()); srcWriter.indent(); if (!this.beanType.isAbstract()) { srcWriter.println("return new %s();", this.beanType.getSimpleSourceName()); } else { srcWriter.println("throw new RuntimeException(\"Can not instantiate the abstract class %s\");", this.beanType.getSimpleSourceName()); } srcWriter.outdent(); srcWriter.println("}"); }
public InjectErrorManagerCreator(JClassType injectableType, ErrorManagmentDescription errorManagmentDescritpion) { this.injectorName = injectableType.getSimpleSourceName() + AbstractInjectorCreator.PROXY_SUFFIX; this.errorDisplay = errorManagmentDescritpion.errorDisplay(); this.errorHandlers = errorManagmentDescritpion.errorHandlers(); this.handlerMethods = InjectCreatorUtil.listMethod(injectableType, fr.putnami.pwt.core.inject.client.annotation.ErrorHandler.class); }
public ReflectionCacheSourceCreator (TreeLogger logger, GeneratorContext context, JClassType type) { this.logger = logger; this.context = context; this.type = type; this.packageName = type.getPackage().getName(); this.simpleName = type.getSimpleSourceName() + "Generated"; logger.log(Type.INFO, type.getQualifiedSourceName()); }
private SourceWriter getSourceWriter(PrintWriter printWriter, GeneratorContext ctx) { ClassSourceFileComposerFactory composerFactory = new ClassSourceFileComposerFactory(this.packageName, this.proxyName); composerFactory.addImport(GWT.class.getName()); composerFactory.addImport(this.injectableType.getQualifiedSourceName()); composerFactory.setSuperclass(this.injectableType.getSimpleSourceName()); for (InjectorWritterInit delegate : Iterables.filter(this.delegates, InjectorWritterInit.class)) { delegate.initComposer(composerFactory); } return composerFactory.createSourceWriter(ctx, printWriter); }
private void createProxy (JClassType type) { ClassSourceFileComposerFactory composer = new ClassSourceFileComposerFactory(type.getPackage().getName(), type.getSimpleSourceName() + "Proxy"); PrintWriter printWriter = context.tryCreate(logger, packageName, simpleName); if (printWriter == null) { return; } SourceWriter writer = composer.createSourceWriter(context, printWriter); writer.commit(logger); }
private WriteHolder createWriteHolder(TreeLogger logger, GeneratorContext context, JClassType classType, SelectionProperty property, String typeName) { // get the package name String packageName = classType.getPackage().getName(); // build name for implementation class String simpleName = classType.getSimpleSourceName() + "_" + property.getCurrentValue(); PrintWriter printWriter = context.tryCreate(logger, packageName, simpleName); ClassSourceFileComposerFactory composer = new ClassSourceFileComposerFactory(packageName, simpleName); composer.addImplementedInterface(typeName); return new WriteHolder(packageName, simpleName, composer, printWriter); }