javax.validation.constraints.Past#com.google.gwt.user.rebind.SourceWriter源码实例Demo

private String generateProviderField(SourceWriter w, JClassType type) {
    final String fieldName = getFieldName(type);
    final String autoBeanFactoryMethodName = factoryFieldName + "." + fieldName;
    final String providerFieldName = fieldName + "Provider";

    w.println("private final Provider %s = new Provider<%s>() {", providerFieldName,
            type.getQualifiedSourceName());
    w.println("    @Override");
    w.println("    public Class<%s> getType() {", type.getQualifiedSourceName());
    w.println("        return %s.class;", type.getQualifiedSourceName());
    w.println("    }");
    w.println();
    w.println("    @Override");
    w.println("    public %s getInstance() {", type.getQualifiedSourceName());
    w.println("        return %s().as();", autoBeanFactoryMethodName);
    w.println("    }");
    w.println("};");
    w.println();

    return providerFieldName;
}
 

private void generateConstructor(TreeLogger logger, SourceWriter srcWriter) {
	int lastIndex = this.proxyModelQualifiedName.lastIndexOf('.');
	String className =
		lastIndex == -1 ? this.proxyModelQualifiedName :
			this.proxyModelQualifiedName.substring(lastIndex + 1, this.proxyModelQualifiedName.length());
	srcWriter.println("public %s(){", className);
	srcWriter.indent();

	if (this.subModels.get(this.parentType) != null) {
		srcWriter.println("super(%s.INSTANCE, %s.class);", this.subModels.get(this.parentType),
			this.beanType.getSimpleSourceName());
		srcWriter.println();
	} else {
		srcWriter.println("super(%s.class);", this.beanType.getSimpleSourceName());
		srcWriter.println();
	}

	srcWriter.outdent();
	srcWriter.println("}");
}
 

public String create(TreeLogger logger, GeneratorContext context) {
	PrintWriter printWriter = context.tryCreate(logger, this.packageName, this.viewProxySimpleName);
	if (printWriter == null) {
		return this.viewProxyQualifiedName;
	}

	SourceWriter srcWriter = this.getSourceWriter(printWriter, context);

	srcWriter.indent();
	this.generateProxy(logger, srcWriter);
	srcWriter.println();
	this.generateTokenPrefixes(logger, srcWriter);
	srcWriter.println();
	if (this.placeTokenizerClass == null) {
		this.generateInternalTokenizer(logger, srcWriter);
	} else {
		this.generateDelegateTokenizer(logger, srcWriter);
	}
	this.generateActivityFactory(logger, srcWriter);
	srcWriter.outdent();

	srcWriter.commit(logger);
	return this.viewProxyQualifiedName;
}
 

public String create(TreeLogger logger, GeneratorContext context) throws UnableToCompleteException, NotFoundException {
	PrintWriter printWriter = this.getPrintWriter(logger, context);
	if (printWriter == null) {
		return this.proxyModelQualifiedName;
	}

	this.serializerTypeName = this.createSerializer(logger, context);
	this.collectImports();

	SourceWriter srcWriter = this.getSourceWriter(printWriter, context);

	srcWriter.indent();
	srcWriter.println();
	this.generateSerializer(srcWriter);
	srcWriter.println();
	this.generateServiceImplementation(logger, srcWriter);
	this.generateServiceImplementationWithCallback(logger, srcWriter);

	srcWriter.outdent();
	srcWriter.commit(logger);
	return this.proxyModelQualifiedName;
}
 

private void generateServiceImplementationWithCallback(TreeLogger logger, SourceWriter srcWriter)
	throws UnableToCompleteException {
	for (JMethod method : this.serviceBinderType.getMethods()) {
		JParameter[] methodParams = method.getParameters();
		JParameter callbackParam = null;
		if (methodParams != null && methodParams.length > 0) {
			callbackParam = methodParams[methodParams.length - 1];
		}
		if (callbackParam == null) {
			break;
		}
		this.writeStartMethod(srcWriter, method);
		this.writeCommandDefinition(logger, srcWriter, method, callbackParam);
		this.writeCommandParam(srcWriter, method, null, callbackParam);
		this.writeEndMethod(srcWriter, method);
	}
}
 

private void writeCommandDefinition(TreeLogger logger, SourceWriter srcWriter, JMethod method,
	JParameter callbackParameter) throws UnableToCompleteException {
	srcWriter.print("CommandDefinition commandDefinition  = new CommandDefinition(");
	srcWriter.print("\"%s\", ", this.serviceType.getQualifiedSourceName());
	srcWriter.print("\"%s\", ", method.getName());
	if (callbackParameter != null) {
		JParameterizedType parameterizedCallback = callbackParameter.getType().isParameterized();
		if (parameterizedCallback != null) {
			srcWriter.print("\"%s\" ", parameterizedCallback.getTypeArgs()[0].getQualifiedSourceName());
		} else {
			logger.branch(TreeLogger.ERROR, "Callback argument type for method " + method.getName()
				+ " is not parametrized", null);
			throw new UnableToCompleteException();
		}

	} else {
		srcWriter.print("\"%s\" ", method.getReturnType().getQualifiedSourceName());
	}
	for (JParameter parameter : method.getParameters()) {
		if (!parameter.equals(callbackParameter)) {
			srcWriter.print(", \"%s\"", parameter.getType().getQualifiedSourceName());
		}
	}
	srcWriter.println(");");
}
 

private SourceWriter createSourceWriter(
    TreeLogger logger,
    GeneratorContext context,
    JClassType eventBinderType,
    JClassType targetType) {
  String simpleName = getSimpleGeneratedClassName(eventBinderType);
  String packageName = eventBinderType.getPackage().getName();
  ClassSourceFileComposerFactory composer =
      new ClassSourceFileComposerFactory(packageName, simpleName);

  composer.setSuperclass(AbstractEventBinder.class.getCanonicalName()
      + "<" + targetType.getQualifiedSourceName() + ">");
  composer.addImplementedInterface(eventBinderType.getName());

  composer.addImport(EventBinder.class.getCanonicalName());
  composer.addImport(EventBus.class.getCanonicalName());
  composer.addImport(GenericEvent.class.getCanonicalName());
  composer.addImport(GenericEventHandler.class.getCanonicalName());
  composer.addImport(HandlerRegistration.class.getCanonicalName());
  composer.addImport(LinkedList.class.getCanonicalName());
  composer.addImport(List.class.getCanonicalName());

  PrintWriter printWriter = context.tryCreate(logger, packageName, simpleName);
  return (printWriter != null) ? composer.createSourceWriter(context, printWriter) : null;
}
 

@Override
public void writeEntryPoint(SourceWriter srcWriter) {
	srcWriter.println("ErrorManager.get();");
	if (!ErrorDisplayer.class.equals(this.errorDisplay)) {
		srcWriter.println("ErrorManager.get().setErrorDisplayer(GWT.<ErrorDisplayer> create(%s.class));",
			InjectCreatorUtil.toClassName(this.errorDisplay));
	}
	if (this.errorHandlers != null) {
		for (Class<? extends ErrorHandler> handlerClass : this.errorHandlers) {
			srcWriter.println("ErrorManager.get().registerErrorHandler(new %s());",
				InjectCreatorUtil.toClassName(handlerClass));
		}
	}
	if (this.errorHandlers != null) {
		for (JMethod handlerMethod : this.handlerMethods) {
			srcWriter.println("ErrorManager.get().registerErrorHandler("
				+ "new fr.putnami.pwt.core.error.client.ErrorHandler() {");
			srcWriter.indent();
			srcWriter.println("@Override public boolean handle(Throwable error) { return %s.this.%s(error); }",
				this.injectorName, handlerMethod.getName());
			srcWriter.println("@Override public int getPriority() { return HIGH_PRIORITY; }");
			srcWriter.outdent();
			srcWriter.println("});");
		}
	}
}
 

@Override
public void writePresent(SourceWriter srcWriter) {
	srcWriter
		.println("final HandlerRegistrationCollection mayStopRegistrations = new HandlerRegistrationCollection();");
	for (JMethod mayStopMethod : this.presenterMethods) {
		srcWriter.println("mayStopRegistrations.add(EventBus.get()"
			+ ".addHandlerToSource(MayStopActivityEvent.TYPE, place, new MayStopActivityEvent.Handler() {");
		srcWriter.indent();
		srcWriter.println("@Override public void onMayStopActivity(MayStopActivityEvent event) {");
		srcWriter.indent();
		srcWriter.println("if (event.getMessage() == null) { event.setMessage(%s.this.%s()); }", this.injectorName,
			mayStopMethod.getName());
		srcWriter.outdent();
		srcWriter.outdent();
		srcWriter.println("}}));");
	}
	srcWriter.println("mayStopRegistrations.add(EventBus.get()"
		+ ".addHandlerToSource(StopActivityEvent.TYPE, place, new StopActivityEvent.Handler() {");
	srcWriter.indent();
	srcWriter.println("@Override public void onStopActivity(StopActivityEvent event) {");
	srcWriter.indent();
	srcWriter.println("mayStopRegistrations.removeHandler();");
	srcWriter.outdent();
	srcWriter.outdent();
	srcWriter.println("}}));");
}
 

@Override
public void writeAfterPresent(SourceWriter srcWriter) {
	if (!this.hasService) {
		srcWriter.println("displayer.setWidget(%s.this);", this.injectorName);
	} else {
		srcWriter.println("commandController.flush(new CallbackAdapter<List<CommandResponse>>() {");
		srcWriter.indent();
		srcWriter.println("@Override");
		srcWriter.println("public void onSuccess(List<CommandResponse> result) {");
		srcWriter.indent();
		srcWriter.println("displayer.setWidget(%s.this);", this.injectorName);
		srcWriter.outdent();
		srcWriter.println("};");
		srcWriter.outdent();
		srcWriter.println("});");
		srcWriter.println("commandController.setSuspended(isSuspended);");
	}
}
 

@Override
public void writeEntryPoint(SourceWriter srcWriter) {
	srcWriter.println("MvpController mvpController = MvpController.get();");
	srcWriter.println("AcceptsOneWidget mvpDisplay = null;");
	if (this.display != null && !AcceptsOneWidget.class.equals(this.display)) {
		srcWriter.println("mvpDisplay = GWT.create(%s.class);", InjectCreatorUtil.toClassName(this.display));
	}
	srcWriter.println("if(mvpDisplay != null){");
	srcWriter.indent();
	srcWriter.println("mvpController.setDisplay(mvpDisplay);");
	srcWriter.outdent();
	srcWriter.println("}");
	srcWriter.println("if(mvpDisplay instanceof IsWidget){");
	srcWriter.indent();
	srcWriter.println("RootPanel.get().add((IsWidget) mvpDisplay);");
	srcWriter.outdent();
	srcWriter.println("}");

	if (this.defaultPlace != null && !Place.class.equals(this.defaultPlace)) {
		srcWriter.println("mvpController.setDefaultPlace(new %s());", InjectCreatorUtil.toClassName(this.defaultPlace));
	}
	for (Class<?> activity : this.activities) {
		srcWriter.println("mvpController.registerActivity(GWT.<ActivityFactory> create(%s.class));",
			InjectCreatorUtil.toClassName(activity));
	}
}
 

@Override
public void writePresent(SourceWriter srcWriter) {
	srcWriter.println("final HandlerRegistrationCollection stopRegistrations = new HandlerRegistrationCollection();");
	for (JMethod mayStopMethod : this.presenterMethods) {
		srcWriter.println("stopRegistrations.add(EventBus.get()"
			+ ".addHandlerToSource(StopActivityEvent.TYPE, place, new StopActivityEvent.Handler() {");
		srcWriter.indent();
		srcWriter.println("@Override public void onStopActivity(StopActivityEvent event) {");
		srcWriter.indent();
		srcWriter.println("%s.this.%s();", this.injectorName, mayStopMethod.getName());
		srcWriter.outdent();
		srcWriter.outdent();
		srcWriter.println("}}));");
	}
	srcWriter.println("stopRegistrations.add(EventBus.get()"
		+ ".addHandlerToSource(StopActivityEvent.TYPE, place, new StopActivityEvent.Handler() {");
	srcWriter.indent();
	srcWriter.println("@Override public void onStopActivity(StopActivityEvent event) {");
	srcWriter.indent();
	srcWriter.println("stopRegistrations.removeHandler();");
	srcWriter.outdent();
	srcWriter.outdent();
	srcWriter.println("}}));");
}
 

private SourceWriter getSourceWriter(PrintWriter printWriter, GeneratorContext ctx) {

		String packageName = this.binderType.getPackage().getName();
		String className = this.binderProxySimpleName;

		ClassSourceFileComposerFactory composerFactory = new ClassSourceFileComposerFactory(packageName, className);

		composerFactory.addImport(GWT.class.getName());
		composerFactory.addImport(UiBinder.class.getName());
		composerFactory.addImport(UiBinderLocalized.class.getName());
		composerFactory.addImport(UiTemplate.class.getName());

		composerFactory.addImport(this.binderType.getQualifiedSourceName());
		composerFactory.addImport(this.widgetType.getQualifiedSourceName());
		composerFactory.addImport(this.targetType.getQualifiedSourceName());

		composerFactory.addImplementedInterface(UiBinderLocalized.class.getSimpleName() + "<"
			+ this.widgetType.getSimpleSourceName() + "," + this.targetType.getSimpleSourceName() + ">");
		composerFactory.addImplementedInterface(UiBinder.class.getSimpleName() + "<"
			+ this.widgetType.getSimpleSourceName() + "," + this.targetType.getSimpleSourceName() + ">");
		composerFactory.addImplementedInterface(this.binderType.getSimpleSourceName());

		return composerFactory.createSourceWriter(ctx, printWriter);
	}
 

void writeClass(SourceWriter sourceWriter,
                String callBackType) {
  sourceWriter.print("public void load(");
  sourceWriter.print(callBackType);
  sourceWriter.println(" callback) {");
  sourceWriter.indent();
  sourceWriter.println("GWT.runAsync(callback);");
  sourceWriter.outdent();
  sourceWriter.println("}");
}
 

private void writeEndMethod(SourceWriter srcWriter, JMethod method) {
	if (method.getReturnType().equals(JPrimitiveType.BOOLEAN)) {
		srcWriter.println("return false;");
	} else if (method.getReturnType().equals(JPrimitiveType.BYTE) || method.getReturnType().equals(JPrimitiveType.CHAR)
		|| method.getReturnType().equals(JPrimitiveType.DOUBLE) || method.getReturnType().equals(JPrimitiveType.FLOAT)
		|| method.getReturnType().equals(JPrimitiveType.INT) || method.getReturnType().equals(JPrimitiveType.LONG)
		|| method.getReturnType().equals(JPrimitiveType.SHORT)) {
		srcWriter.println("return 0;");
	} else if (!method.getReturnType().equals(JPrimitiveType.VOID)) {
		srcWriter.println("return null;");
	}
	srcWriter.outdent();
	srcWriter.println("}");
}
 

private SourceWriter getSourceWriter(TreeLogger logger,
                                     GeneratorContext context,
                                     JClassType originalType,
                                     String packageName,
                                     String generatedClassName)
  throws UnableToCompleteException {

  logger.log(TreeLogger.INFO,
             "Generating writer for " + packageName + "." + generatedClassName,
             null);

  PrintWriter printWriter = context.tryCreate(logger,
                                              packageName,
                                              generatedClassName);
  if (printWriter == null) {
    return null;
  }

  ClassSourceFileComposerFactory classFactory = new ClassSourceFileComposerFactory(packageName,
                                                                                   generatedClassName);

  classFactory.addImplementedInterface(originalType.getName());
  String[] classesToImport = getClassesToImport();
  for (String classToImport : classesToImport) {
    classFactory.addImport(classToImport);
  }

  return classFactory.createSourceWriter(context,
                                         printWriter);
}
 

public String create(TreeLogger logger, GeneratorContext context) {
	PrintWriter printWriter = this.getPrintWriter(logger, context, this.proxyModelQualifiedName);
	if (printWriter == null) {
		return this.proxyModelQualifiedName;
	}

	JField[] fields = this.beanType.getFields();
	JMethod[] methods = this.beanType.getMethods();

	this.parentType = this.beanType.getSuperclass();
	this.imports.add(this.parentType);

	this.listPublicFields(fields);
	this.listGetters(methods);
	this.listSetters(methods);

	this.createSubModels(logger, context);

	SourceWriter srcWriter = this.getSourceWriter(printWriter, context);

	srcWriter.indent();
	srcWriter.println();
	this.generateSingleton(logger, srcWriter);
	srcWriter.println();
	srcWriter.println();
	this.generateStaticInitializer(logger, srcWriter);
	srcWriter.println();
	this.generateConstructor(logger, srcWriter);
	srcWriter.println();
	this.generateCreate(logger, srcWriter);
	srcWriter.println();
	this.generateInternalSet(logger, srcWriter);
	srcWriter.println();
	this.generateInternalGet(logger, srcWriter);

	srcWriter.outdent();

	srcWriter.commit(logger);
	return this.proxyModelQualifiedName;
}
 

private void generateSingleton(TreeLogger logger, SourceWriter srcWriter) {
	String className =
		this.proxyModelQualifiedName.indexOf('.') == -1 ? this.proxyModelQualifiedName :
			this.proxyModelQualifiedName.substring(this.proxyModelQualifiedName.lastIndexOf('.') + 1,
				this.proxyModelQualifiedName.length());
	srcWriter.println("public static final %s INSTANCE = new %s();", className, className);
}
 

private void writeMethodCall(SourceWriter srcWriter, JMethod method, JParameter callbackParam) {
	srcWriter.print("REST.<%s> withCallback(compositeCallback).call(restService).%s(", this.typeAsString(method
		.getReturnType(), true), method.getName());
	int i = 0;
	for (JParameter parameter : method.getParameters()) {
		if (!parameter.equals(callbackParam)) {
			if (i++ > 0) {
				srcWriter.print(", ");
			}
			srcWriter.print("$%d_%s", i, parameter.getName());
		}
	}
	srcWriter.println(");");
}
 

private void appendPatternValidator(SourceWriter w, JField field) {
	Pattern patternAnnotation = field.getAnnotation(Pattern.class);
	if (patternAnnotation != null) {
		w.println(", new PatternValidator(\"%s\", \"%s\")", patternAnnotation.message(), patternAnnotation.regexp()
			.replace("\\", "\\\\"), patternAnnotation.flags());
	}
}
 

private void generateConstructor(SourceWriter sourceWriter) {
    // start constructor source generation
    sourceWriter.println("public " + className + "() { ");
    sourceWriter.indent();
    sourceWriter.println("super();");
    sourceWriter.outdent();
    sourceWriter.println("}");
}
 

/**
 * Generate source code for new class. Class extends
 * <code>HashMap</code>.
 *
 * @param logger  Logger object
 * @param context Generator context
 */
private void generateClass(TreeLogger logger, GeneratorContext context) throws Throwable {

    // get print writer that receives the source code
    PrintWriter printWriter = context.tryCreate(logger, packageName, className);

    // print writer if null, source code has ALREADY been generated, return
    if (printWriter == null) { return; }

    // init composer, set class properties, create source writer
    ClassSourceFileComposerFactory composerFactory =
            new ClassSourceFileComposerFactory(packageName, className);

    // Imports
    composerFactory.addImport("org.jboss.as.console.client.Console");
    composerFactory.addImport("org.jboss.as.console.client.ProductConfig");

    composerFactory.addImport("java.util.*");

    // Interfaces
    composerFactory.addImplementedInterface("org.jboss.as.console.client.ProductConfig");

    // SourceWriter
    SourceWriter sourceWriter = composerFactory.createSourceWriter(context, printWriter);

    // ctor
    generateConstructor(sourceWriter);

    // Methods
    generateMethods(logger, sourceWriter, context);

    // close generated class
    sourceWriter.outdent();
    sourceWriter.println("}");

    // commit generated class
    context.commit(logger, printWriter);
}
 

private void generateMethods(SourceWriter sourceWriter)
{

    sourceWriter.println("public List<PropertyBinding> getBindingsForType(Class<?> type) { ");
    sourceWriter.indent();
    sourceWriter.println("return registry.get(type);");
    sourceWriter.outdent();
    sourceWriter.println("}");

    sourceWriter.println("public BeanMetaData getBeanMetaData(Class<?> type) { ");
    sourceWriter.indent();
    sourceWriter.println("return new BeanMetaData(type, addressing.get(type), registry.get(type));");
    sourceWriter.outdent();
    sourceWriter.println("}");

    sourceWriter.println("public FormMetaData getFormMetaData(Class<?> type) { ");
    sourceWriter.indent();
    sourceWriter.println("return new FormMetaData(type, registry.get(type));");
    sourceWriter.outdent();
    sourceWriter.println("}");

    sourceWriter.println("public Mutator getMutator(Class<?> type) { ");
    sourceWriter.indent();
    sourceWriter.println("return mutators.get(type);");
    sourceWriter.outdent();
    sourceWriter.println("}");

    sourceWriter.println("public <T> EntityFactory<T> getFactory(Class<T> type) {");
    sourceWriter.indent();
    sourceWriter.println("return factories.get(type);");
    sourceWriter.outdent();
    sourceWriter.println("}");

    generateMethodMethods(sourceWriter);
}
 

private void generateInternalSet(TreeLogger logger, SourceWriter srcWriter) {
	srcWriter.println("protected <P> void internalSet(%s bean, String fieldName, P value){",
		this.beanType.getSimpleSourceName());
	srcWriter.indent();
	for (String propertyName : this.propertyTypes.keySet()) {
		JType propertyType = this.propertyTypes.get(propertyName);
		JPrimitiveType primitiveType = propertyType.isPrimitive();
		JMethod setter = this.setters.get(propertyName);
		if (setter != null) {
			if (primitiveType != null) {
				srcWriter.println(
					"if(\"%s\".equals(fieldName)){  bean.%s((%s) PrimitiveUtils.asPrimitive((%s)value)); }",
					propertyName, setter.getName(), propertyType.getSimpleSourceName(),
					primitiveType.getQualifiedBoxedSourceName());
			} else {
				srcWriter.println("if(\"%s\".equals(fieldName)){  bean.%s((%s) value); }", propertyName,
					setter.getName(),
					propertyType.getSimpleSourceName());
			}
		} else if (this.publicFields.containsKey(propertyName)) {
			if (primitiveType != null) {
				srcWriter
					.println("if(\"%s\".equals(fieldName)){ bean.%s = PrimitiveUtils.asPrimitive((%s) value); }",
						propertyName, propertyName, primitiveType.getQualifiedBoxedSourceName());
			} else {
				srcWriter
					.println("if(\"%s\".equals(fieldName)){  bean.%s = (%s) value; }", propertyName, propertyName,
						propertyType.getSimpleSourceName());
			}
		}
	}
	srcWriter.outdent();
	srcWriter.println("}");
}
 

private void generateActivityFactory(TreeLogger logger, SourceWriter srcWriter) {
	srcWriter.println("@Override");
	srcWriter.println("public Activity createActivity(Place place) {");
	srcWriter.indent();
	srcWriter.println("return new ViewActivity(this, place);");
	srcWriter.outdent();
	srcWriter.println("}");
}
 

private void generateInternalTokenizer(TreeLogger logger, SourceWriter srcWriter) {
	boolean hasTokeConstructor = false;
	for (JConstructor constructor : this.placeType.getConstructors()) {
		if (constructor.getParameters().length == 1
			&& constructor.getParameters()[0].getType().getSimpleSourceName().equals(String.class.getSimpleName())) {
			hasTokeConstructor = true;
		}
	}
	srcWriter.println("@Override");
	srcWriter.println("public %s getPlace(String token) {", this.placeType.getSimpleSourceName());
	srcWriter.indent();
	if (hasTokeConstructor) {
		srcWriter.println("return new %s(token);", this.placeType.getSimpleSourceName());
	} else {
		srcWriter.println("%s place = new %s();",
			this.placeType.getSimpleSourceName(), this.placeType.getSimpleSourceName());
		srcWriter.println("place.setToken(token);");
		srcWriter.println("return place;");
	}
	srcWriter.outdent();
	srcWriter.println("}");
	srcWriter.println("@Override");
	srcWriter.println("public String getToken(%s place) {", this.placeType.getSimpleSourceName());
	srcWriter.indent();
	srcWriter.println("if(place instanceof ViewPlace){");
	srcWriter.indent();
	srcWriter.println("return ((ViewPlace)place).getToken();");
	srcWriter.outdent();
	srcWriter.println("}");
	srcWriter.println("return null;");
	srcWriter.outdent();
	srcWriter.println("}");
}
 

private void generateDelegateTokenizer(TreeLogger logger, SourceWriter srcWriter) {
	srcWriter.println("@Override");
	srcWriter.println("public %s getPlace(String token) {", this.placeType.getSimpleSourceName());
	srcWriter.indent();
	srcWriter.println("return new %s().getPlace(token);", this.placeTokenizerClass.getSimpleName());
	srcWriter.outdent();
	srcWriter.println("}");
	srcWriter.println("@Override");
	srcWriter.println("public String getToken(%s place) {", this.placeType.getSimpleSourceName());
	srcWriter.indent();
	srcWriter.println("return new %s().getToken(place);", this.placeTokenizerClass.getSimpleName());
	srcWriter.outdent();
	srcWriter.println("}");
}
 

private void generateTokenPrefixes(TreeLogger logger, SourceWriter srcWriter) {
	List<String> tokens = Lists.newArrayList();
	tokens.add("\"" + this.placeType.getSimpleSourceName().replaceAll("Place$", "") + "\"");
	for (String alias : this.activityDescrition.aliases()) {
		tokens.add("\"" + alias + "\"");
	}

	srcWriter.println("@Override");
	srcWriter.println("public String[] getPlacePrefixes(){");
	srcWriter.indent();
	srcWriter.println("return new String[]{ %s };", Joiner.on(", ").join(tokens));
	srcWriter.outdent();
	srcWriter.println("}");
}
 

private void generateMethods(SourceWriter srcWriter) {
    srcWriter.println("@Override");
    srcWriter.println("public List<Serdes<?>> getSerdes() {");
    srcWriter.println("    return serdesList;");
    srcWriter.println("}");
    srcWriter.println();
    srcWriter.println("@Override");
    srcWriter.println("public List<Provider<?>> getProviders() {");
    srcWriter.println("    return providersList;");
    srcWriter.println("}");
    srcWriter.println();
}
 

private SourceWriter getSourceWriter(PrintWriter printWriter, GeneratorContext ctx) {
	ClassSourceFileComposerFactory composerFactory =
		new ClassSourceFileComposerFactory(this.packageName, this.viewProxySimpleName);

	composerFactory.setSuperclass(this.placeType.getSimpleSourceName());

	composerFactory.addImport(GWT.class.getName());
	composerFactory.addImport(RunAsyncCallback.class.getName());
	composerFactory.addImport(ViewProxy.class.getName());
	composerFactory.addImport(Place.class.getName());
	composerFactory.addImport(ViewPlace.class.getName());
	composerFactory.addImport(Activity.class.getName());
	composerFactory.addImport(ViewActivity.class.getName());
	composerFactory.addImport(ApplicationUnreachableException.class.getName());
	composerFactory.addImport(this.placeType.getQualifiedSourceName());
	composerFactory.addImport(this.activityDescrition.view().getCanonicalName());
	if (this.placeTokenizerClass != null) {
		composerFactory.addImport(this.placeTokenizerClass.getCanonicalName());
	}
	if (this.viewDecoratorClass != null) {
		composerFactory.addImport(this.viewDecoratorClass.getCanonicalName());
	}

	composerFactory.addImplementedInterface(
		ViewProxy.class.getSimpleName() + "<" + this.placeType.getSimpleSourceName() + ">");

	return composerFactory.createSourceWriter(ctx, printWriter);
}