private void emitMenu(SourceWriter writer, Element el) throws UnableToCompleteException { for (Node n = el.getFirstChild(); n != null; n = n.getNextSibling()) { if (n.getNodeType() != Node.ELEMENT_NODE) continue; Element child = (Element) n; if (child.getTagName().equals("cmd")) { String cmdId = child.getAttribute("refid"); writer.print("callback.addCommand("); writer.print("\"" + Generator.escape(cmdId) + "\", "); writer.println("this.cmds." + cmdId + "());"); } else if (child.getTagName().equals("separator")) { writer.println("callback.addSeparator();"); } else if (child.getTagName().equals("menu")) { String label = child.getAttribute("label"); writer.println("callback.beginMenu(\"" + Generator.escape(label) + "\");"); emitMenu(writer, child); writer.println("callback.endMenu();"); } else if (child.getTagName().equals("dynamic")) { String dynamicClass = child.getAttribute("class"); writer.println("new " + dynamicClass + "().execute(callback);"); } else { logger_.log(TreeLogger.Type.ERROR, "Unexpected tag " + el.getTagName() + " in menu"); throw new UnableToCompleteException(); } } }
private void writeMethod(TreeLogger logger, MethodWrapper method, SourceWriter writer) { JType ptype = this.resolveType(method.getDeclaringType()); writer.println("new Method(){ "); writer.indent(); writer.println("public String getName() {"); writer.indentln("return \"" + method.getBaseMethod().getName() + "\";"); writer.println(" }"); writer.println("public Object invoke( Object target, Object[] args ) throws Exception {"); writer.indent(); writer.println(ptype.getQualifiedSourceName() + " casted ="); writer.println("(" + ptype.getQualifiedSourceName() + ") target;"); logger.log( TreeLogger.SPAM, "Method: " + method.getBaseMethod().getName() + " " + method.getBaseMethod().getReturnType().getQualifiedSourceName(), null); if (!(method.getBaseMethod().getReturnType().isPrimitive() == JPrimitiveType.VOID)) { writer.print("return "); } JType type = this.resolveType(method.getBaseMethod().getReturnType()); boolean boxed = this.box(type, writer); writer.print("casted." + method.getBaseMethod().getName() + "("); if (method.getBaseMethod().getParameters() != null) { for (int j = 0; j < method.getBaseMethod().getParameters().length; j++) { JType arg = this.resolveType(method.getBaseMethod().getParameters()[j].getType()); this.unbox(arg, "args[" + j + "]", writer); if (j != (method.getBaseMethod().getParameters().length - 1)) { writer.print(", "); } } } writer.print(")"); if (boxed) { writer.print(")"); } writer.println(";"); if (method.getBaseMethod().getReturnType().getQualifiedSourceName().equals("void")) { writer.println("return null;"); } writer.outdent(); writer.println("}"); writer.outdent(); writer.println("};"); }
public static boolean ensureProviderClass( TreeLogger logger, String packageName, String simpleName0, String canonical, String qualifiedSourceName, GeneratorContext ctx) { String simpleName = SourceUtil.toSourceName(simpleName0); String generatedName = InjectionUtils.generatedProviderName(simpleName); String cleanedCanonical = SourceUtil.toSourceName(canonical); logger.log(Type.DEBUG, "Creating provider for " + packageName + "." + generatedName); PrintWriter printWriter = ctx.tryCreate(logger, packageName, generatedName); if (printWriter == null) { logger.log(Type.TRACE, "Already generated " + generatedName); return false; } logger.log( Type.TRACE, "Newly Generating provider " + generatedName + " <- " + qualifiedSourceName); ClassSourceFileComposerFactory composer = new ClassSourceFileComposerFactory(packageName, generatedName); composer.setSuperclass(SingletonInitializer.class.getName() + "<" + simpleName0 + ">"); composer.addImport(cleanedCanonical); composer.addImport(GWT.class.getName()); composer.addImport(SingletonProvider.class.getName()); SourceWriter sw = composer.createSourceWriter(ctx, printWriter); sw.println("@Override"); sw.println("public " + simpleName + " initialValue(){"); sw.indent(); sw.print("return GWT.<" + cleanedCanonical + ">create("); sw.print(SourceUtil.toSourceName(qualifiedSourceName) + ".class"); sw.println(");"); sw.outdent(); sw.println("}"); sw.println(); // now, print a static final provider instance sw.print("public static final SingletonProvider<"); sw.print(simpleName0 + "> "); sw.print("theProvider = "); sw.println("new " + generatedName + "();"); sw.commit(logger); return true; }
@Override void toJS(FragmentGeneratorContext context) throws UnableToCompleteException { TreeLogger logger = context.parentLogger.branch( TreeLogger.DEBUG, "Writing function() wrapper for JSFunction", null); SourceWriter sw = context.sw; TypeOracle typeOracle = context.typeOracle; JClassType functionClass = context.returnType.isClassOrInterface(); if (functionClass.equals(typeOracle.findType(JSFunction.class.getName()))) { logger.log( TreeLogger.ERROR, "You must use a subinterface of JSFunction" + " so that the generator can extract a method signature.", null); throw new UnableToCompleteException(); } // This is to support the JSFunction having the same lifetime as the // JSFunction object without having to use GWT.create on every JSFunction // object as that would discourage anonymous classes. sw.print("("); sw.print(context.parameterName); // sw.print("[email protected]::exportedFunction || ("); sw.print(".@" + JSFunction.class.getName() + "::exportedFunction || ("); sw.print(context.parameterName); // sw.print("[email protected]::exportedFunction = "); sw.print(".@" + JSFunction.class.getName() + "::exportedFunction = "); writeFunctionForMethod(context, findExportedMethod(logger, functionClass)); sw.print("))"); }
private void writeIntrospectables( TreeLogger logger, List introspectables, MethodWrapper[] methods, SourceWriter writer) { for (Iterator it = introspectables.iterator(); it.hasNext(); ) { BeanResolver bean = (BeanResolver) it.next(); logger.branch( TreeLogger.DEBUG, "Introspecting: " + bean.getType().getQualifiedSourceName(), null); try { if (bean.getProperties().size() == 0) { continue; } writer.print("private static BeanDescriptor "); writer.print(bean.getType().getQualifiedSourceName().replaceAll("\\.", "_")); writer.println(" = null;"); } catch (Exception e) { logger.log(TreeLogger.ERROR, "Unable to introspect class. Is class a bean?", e); } } }
private boolean unbox(JType type, String reference, SourceWriter writer) { if ((type.isPrimitive() != null) && (type.isPrimitive() == JPrimitiveType.INT)) { writer.print("((Integer) " + reference + ").intValue()"); return true; } if ((type.isPrimitive() != null) && (type.isPrimitive() == JPrimitiveType.LONG)) { writer.print("((Long) " + reference + ").longValue()"); return true; } if ((type.isPrimitive() != null) && (type.isPrimitive() == JPrimitiveType.FLOAT)) { writer.print("((Float) " + reference + ").floatValue()"); return true; } if ((type.isPrimitive() != null) && (type.isPrimitive() == JPrimitiveType.DOUBLE)) { writer.print("((Double) " + reference + ").doubleValue()"); return true; } if ((type.isPrimitive() != null) && (type.isPrimitive() == JPrimitiveType.CHAR)) { writer.print("((Character) " + reference + ").charValue()"); return true; } if ((type.isPrimitive() != null) && (type.isPrimitive() == JPrimitiveType.BYTE)) { writer.print("((Byte) " + reference + ").byteValue()"); return true; } if ((type.isPrimitive() != null) && (type.isPrimitive() == JPrimitiveType.BOOLEAN)) { writer.print("((Boolean) " + reference + ").booleanValue()"); return true; } writer.print("(" + type.getQualifiedSourceName() + ") " + reference); return false; }
private boolean box(JType type, SourceWriter writer) { if ((type.isPrimitive() != null) && (type.isPrimitive() == JPrimitiveType.INT)) { writer.print("new Integer( "); return true; } if ((type.isPrimitive() != null) && (type.isPrimitive() == JPrimitiveType.LONG)) { writer.print("new Long( "); return true; } if ((type.isPrimitive() != null) && (type.isPrimitive() == JPrimitiveType.FLOAT)) { writer.print("new Float( "); return true; } if ((type.isPrimitive() != null) && (type.isPrimitive() == JPrimitiveType.DOUBLE)) { writer.print("new Double( "); return true; } if ((type.isPrimitive() != null) && (type.isPrimitive() == JPrimitiveType.CHAR)) { writer.print("new Character( "); return true; } if ((type.isPrimitive() != null) && (type.isPrimitive() == JPrimitiveType.BYTE)) { writer.print("new Byte( "); return true; } if ((type.isPrimitive() != null) && (type.isPrimitive() == JPrimitiveType.BOOLEAN)) { writer.print("new Boolean( "); return true; } return false; }
/** Simply prints a JSNI reference to the exported function. */ private static void writeIdentityInvocation(FragmentGeneratorContext context, JMethod m) throws UnableToCompleteException { SourceWriter sw = context.sw; JParameter[] parameters = m.getParameters(); sw.print("@"); sw.print(m.getEnclosingType().getQualifiedSourceName()); sw.print("::"); sw.print(m.getName()); sw.print("("); // Argument list for the Java invocation for (int i = 0; i < parameters.length; i++) { sw.print(parameters[i].getType().getJNISignature()); } sw.print(")"); }
/** * Generate a class which can select between alternate implementations at runtime based on the * runtime locale. * * @param logger TreeLogger instance for log messages * @param context GeneratorContext for generating source files * @param targetClass class to generate * @param compileLocale the compile-time locale we are generating for * @param locales set of all locales to generate * @return fully-qualified class name that was generated */ private String generateRuntimeSelection( TreeLogger logger, GeneratorContext context, JClassType targetClass, GwtLocale compileLocale, Set<GwtLocale> locales) { String packageName = targetClass.getPackage().getName(); String className = targetClass.getName().replace('.', '_') + "_" + compileLocale.getAsString() + "_runtimeSelection"; PrintWriter pw = context.tryCreate(logger, packageName, className); if (pw != null) { ClassSourceFileComposerFactory factory = new ClassSourceFileComposerFactory(packageName, className); factory.setSuperclass(targetClass.getQualifiedSourceName()); factory.addImport(CURRENCY_DATA); factory.addImport(JAVASCRIPTOBJECT); factory.addImport(HASHMAP); factory.addImport("com.google.gwt.i18n.client.LocaleInfo"); SourceWriter writer = factory.createSourceWriter(context, pw); writer.println("private CurrencyList instance;"); writer.println(); writer.println("@Override"); writer.println("protected CurrencyData getDefaultJava() {"); writer.println(" ensureInstance();"); writer.println(" return instance.getDefaultJava();"); writer.println("}"); writer.println(); writer.println("@Override"); writer.println("protected CurrencyData getDefaultNative() {"); writer.println(" ensureInstance();"); writer.println(" return instance.getDefaultNative();"); writer.println("}"); writer.println(); writer.println("@Override"); writer.println("protected HashMap<String, CurrencyData> loadCurrencyMapJava() {"); writer.println(" ensureInstance();"); writer.println(" return instance.loadCurrencyMapJava();"); writer.println("}"); writer.println(); writer.println("@Override"); writer.println("protected JavaScriptObject loadCurrencyMapNative() {"); writer.println(" ensureInstance();"); writer.println(" return instance.loadCurrencyMapNative();"); writer.println("}"); writer.println(); writer.println("@Override"); writer.println("protected HashMap<String, String> loadNamesMapJava() {"); writer.println(" ensureInstance();"); writer.println(" return instance.loadNamesMapJava();"); writer.println("}"); writer.println(); writer.println("@Override"); writer.println("protected JavaScriptObject loadNamesMapNative() {"); writer.println(" ensureInstance();"); writer.println(" return instance.loadNamesMapNative();"); writer.println("}"); writer.println(); writer.println("private void ensureInstance() {"); writer.indent(); writer.println("if (instance != null) {"); writer.println(" return;"); writer.println("}"); boolean fetchedLocale = false; Map<String, Set<GwtLocale>> localeMap = new TreeMap<String, Set<GwtLocale>>(); String compileLocaleClass = processChildLocale(logger, context, targetClass, localeMap, compileLocale); if (compileLocaleClass == null) { // already gave warning, just use default implementation return null; } for (GwtLocale runtimeLocale : locales) { processChildLocale(logger, context, targetClass, localeMap, runtimeLocale); } for (Entry<String, Set<GwtLocale>> entry : localeMap.entrySet()) { if (!fetchedLocale) { writer.println("String runtimeLocale = LocaleInfo.getCurrentLocale().getLocaleName();"); fetchedLocale = true; } boolean firstLocale = true; String generatedClass = entry.getKey(); if (compileLocaleClass.equals(generatedClass)) { // The catch-all will handle this continue; } writer.print("if ("); for (GwtLocale locale : entry.getValue()) { if (firstLocale) { firstLocale = false; } else { writer.println(); writer.print(" || "); } writer.print("\"" + locale.toString() + "\".equals(runtimeLocale)"); } writer.println(") {"); writer.println(" instance = new " + generatedClass + "();"); writer.println(" return;"); writer.println("}"); } writer.println("instance = new " + compileLocaleClass + "();"); writer.outdent(); writer.println("}"); writer.commit(logger); } return packageName + "." + className; }
/** * Generates the client's asynchronous proxy method. * * @param serializableTypeOracle the type oracle */ protected void generateProxyMethod( SourceWriter w, SerializableTypeOracle serializableTypeOracle, TypeOracle typeOracle, JMethod syncMethod, JMethod asyncMethod) { w.println(); // Write the method signature JType asyncReturnType = asyncMethod.getReturnType().getErasedType(); w.print("public "); w.print(asyncReturnType.getQualifiedSourceName()); w.print(" "); w.print(asyncMethod.getName() + "("); boolean needsComma = false; NameFactory nameFactory = new NameFactory(); JParameter[] asyncParams = asyncMethod.getParameters(); for (int i = 0; i < asyncParams.length; ++i) { JParameter param = asyncParams[i]; if (needsComma) { w.print(", "); } else { needsComma = true; } /* * Ignoring the AsyncCallback parameter, if any method requires a call to * SerializationStreamWriter.writeObject we need a try catch block */ JType paramType = param.getType(); paramType = paramType.getErasedType(); w.print(paramType.getQualifiedSourceName()); w.print(" "); String paramName = param.getName(); nameFactory.addName(paramName); w.print(paramName); } w.println(") {"); w.indent(); String helperName = nameFactory.createName("helper"); String helperClassName = RemoteServiceProxy.ServiceHelper.class.getCanonicalName(); w.println( "%s %s = new %s(\"%s\", \"%s\");", helperClassName, helperName, helperClassName, getProxySimpleName(), syncMethod.getName()); w.println("try {"); w.indent(); // Write the parameter count followed by the parameter values JParameter[] syncParams = syncMethod.getParameters(); String streamWriterName = nameFactory.createName("streamWriter"); w.println( "%s %s = %s.start(REMOTE_SERVICE_INTERFACE_NAME, %s);", SerializationStreamWriter.class.getSimpleName(), streamWriterName, helperName, syncParams.length); for (JParameter param : syncParams) { JType paramType = param.getType().getErasedType(); String typeNameExpression = computeTypeNameExpression(paramType); assert typeNameExpression != null : "Could not compute a type name for " + paramType.getQualifiedSourceName(); w.println(streamWriterName + ".writeString(" + typeNameExpression + ");"); } // Encode all of the arguments to the asynchronous method, but exclude the // last argument which is the callback instance. // for (int i = 0; i < asyncParams.length - 1; ++i) { JParameter asyncParam = asyncParams[i]; w.print(streamWriterName + "."); w.print(Shared.getStreamWriteMethodNameFor(asyncParam.getType())); w.println("(" + asyncParam.getName() + ");"); } /* * Depending on the return type for the async method, return a * RequestBuilder, a Request, or nothing at all. */ JParameter callbackParam = asyncParams[asyncParams.length - 1]; JType returnType = syncMethod.getReturnType(); String callbackName = callbackParam.getName(); if (asyncReturnType == JPrimitiveType.VOID) { w.println( "%s.finish(%s, ResponseReader.%s);", helperName, callbackName, getResponseReaderFor(returnType).name()); } else if (asyncReturnType.getQualifiedSourceName().equals(RequestBuilder.class.getName())) { w.println( "return %s.finishForRequestBuilder(%s, ResponseReader.%s);", helperName, callbackName, getResponseReaderFor(returnType).name()); } else if (asyncReturnType.getQualifiedSourceName().equals(Request.class.getName())) { w.println( "return %s.finish(%s, ResponseReader.%s);", helperName, callbackName, getResponseReaderFor(returnType).name()); } else { // This method should have been caught by RemoteServiceAsyncValidator throw new RuntimeException( "Unhandled return type " + asyncReturnType.getQualifiedSourceName()); } w.outdent(); w.print("} catch (SerializationException "); String exceptionName = nameFactory.createName("ex"); w.println(exceptionName + ") {"); w.indent(); if (!asyncReturnType.getQualifiedSourceName().equals(RequestBuilder.class.getName())) { /* * If the method returns void or Request, signal the serialization error * immediately. If the method returns RequestBuilder, the error will be * signaled whenever RequestBuilder.send() is invoked. */ w.println(callbackName + ".onFailure(" + exceptionName + ");"); } if (asyncReturnType.getQualifiedSourceName().equals(RequestBuilder.class.getName())) { w.println( "return new " + FailingRequestBuilder.class.getName() + "(" + exceptionName + ", " + callbackName + ");"); } else if (asyncReturnType.getQualifiedSourceName().equals(Request.class.getName())) { w.println("return new " + FailedRequest.class.getName() + "();"); } else { assert asyncReturnType == JPrimitiveType.VOID; } w.outdent(); w.println("}"); w.outdent(); w.println("}"); }
private void writeMethods(TreeLogger logger, MethodWrapper[] methods, SourceWriter writer) { for (int i = 0; i < methods.length; i++) { writer.print("public static final Method METHOD_" + i + " = "); writeMethod(logger, methods[i], writer); } }
public String generate(TreeLogger logger, GeneratorContext context, String typeName) throws UnableToCompleteException { // .println("Introspector Generate."); try { this.objectType = context.getTypeOracle().getType("java.lang.Object"); } catch (NotFoundException ex) { logger.log(TreeLogger.ERROR, typeName, ex); return null; } List<BeanResolver> introspectables = this.getIntrospectableTypes(logger, context.getTypeOracle()); MethodWrapper[] methods = this.findMethods(logger, introspectables); ClassSourceFileComposerFactory mcf = new ClassSourceFileComposerFactory(this.packageName, this.methodsImplementationName); mcf.addImport(Method.class.getCanonicalName()); PrintWriter methodsPrintWriter = context.tryCreate(logger, this.packageName, this.methodsImplementationName); if (methodsPrintWriter != null) { SourceWriter methodsWriter = mcf.createSourceWriter(context, methodsPrintWriter); this.writeMethods(logger, methods, methodsWriter); methodsWriter.println("}"); context.commit(logger, methodsPrintWriter); } ClassSourceFileComposerFactory cfcf = new ClassSourceFileComposerFactory(this.packageName, this.implementationName); cfcf.addImplementedInterface(typeName); cfcf.addImport("java.util.HashMap"); cfcf.addImport(Method.class.getCanonicalName()); cfcf.addImport(com.totsp.gwittir.introspection.Property.class.getCanonicalName()); cfcf.addImport(com.totsp.gwittir.introspection.BeanDescriptor.class.getCanonicalName()); PrintWriter printWriter = context.tryCreate(logger, packageName, implementationName); if (printWriter == null) { // .println( "Introspector Generate skipped."); return packageName + "." + implementationName; } SourceWriter writer = cfcf.createSourceWriter(context, printWriter); this.writeIntrospectables(logger, introspectables, methods, writer); this.writeResolver(introspectables, writer); writer.println( "private HashMap<Class,BeanDescriptor> beanDescriptorLookup = new HashMap<Class,BeanDescriptor>();"); writer.println(); writer.println("public BeanDescriptor getDescriptor( Object object ){ "); writer.indent(); writer.println( "if( object == null ) throw new NullPointerException(\"Attempt to introspect null object\");"); writer.println( "if( object instanceof " + SelfDescribed.class.getCanonicalName() + " ) return ((SelfDescribed)object).__descriptor();"); writer.println("BeanDescriptor descriptor = beanDescriptorLookup.get(object.getClass());"); writer.println("if (descriptor!=null){"); writer.indentln("return descriptor;"); writer.outdent(); writer.println("}"); writer.println("descriptor=_getDescriptor(object);"); writer.println("beanDescriptorLookup.put(object.getClass(),descriptor);"); writer.println("return descriptor;"); writer.outdent(); writer.println("}"); writer.println("private BeanDescriptor _getDescriptor( Object object ){ "); writer.indent(); for (BeanResolver resolver : introspectables) { writer.println( "if( object instanceof " + resolver.getType().getQualifiedSourceName() + " ) {"); writer.indent(); String name = resolver.getType().getQualifiedSourceName().replaceAll("\\.", "_"); logger.log(TreeLogger.DEBUG, "Writing : " + name, null); writer.print("return " + name + " == null ? " + name + " = "); this.writeBeanDescriptor(logger, resolver, methods, writer); writer.print(": " + name + ";"); writer.outdent(); writer.println("}"); } writer.println(" throw new IllegalArgumentException(\"Unknown type\" + object.getClass() ); "); writer.outdent(); writer.println("}"); writer.println("public Object createInstance(Class clazz) {"); writer.indent(); for (BeanResolver resolver : introspectables) { boolean hasPNA = false; for (JConstructor constructor : resolver.getType().getConstructors()) { if (constructor.getParameters() == null || constructor.getParameters().length == 0 && constructor.isPublic()) { hasPNA = true; break; } if (hasPNA) { break; } } writer.println( "if(clazz.equals(" + resolver.getType().getQualifiedSourceName() + ".class)){"); writer.indent(); logger.log( TreeLogger.Type.TRACE, resolver.getType().getQualifiedSourceName() + " abstract " + resolver.getType().isAbstract() + " intf " + (resolver.getType().isInterface() != null) + " def " + resolver.getType().isDefaultInstantiable()); if (resolver.getType().isAbstract() || resolver.getType().isInterface() != null) { writer.println("throw new IllegalArgumentException(clazz+\" is abstract\");"); } else if (hasPNA) { writer.println("return new " + resolver.getType().getQualifiedSourceName() + "();"); } else { writer.println( "throw new IllegalArgumentException(clazz+\" has no public no args constructor\");"); } writer.outdent(); writer.println("}"); } writer.println(" throw new IllegalArgumentException(\"Unknown type\" +clazz ); "); writer.outdent(); writer.println("}"); writer.println("HashMap<String, Class> classes = new HashMap<String, Class>();"); writer.println("public Class forName(String className){"); writer.indent(); writer.println("Class clazz = classes.get(className);"); writer.println("if(clazz != null) return clazz;"); for (BeanResolver resolver : introspectables) { writer.println( "if(className.equals(\"" + resolver.getType().getQualifiedSourceName() + "\")){"); writer.indent(); writer.println("clazz = " + resolver.getType().getQualifiedSourceName() + ".class;"); writer.println("classes.put(className, clazz);"); writer.println("return clazz;"); writer.outdent(); writer.println("}"); } writer.println("throw new IllegalArgumentException(className+\" is not introspecable.\");"); writer.outdent(); writer.println("}"); writer.outdent(); writer.println("}"); context.commit(logger, printWriter); // .println( "Introspector Generate completed."); return packageName + "." + implementationName; }
/** Writes a linkage function object that will invoke the exported function. */ private static void writeLinkageInvocation(FragmentGeneratorContext context, JMethod m) throws UnableToCompleteException { TreeLogger logger = context.parentLogger.branch( TreeLogger.DEBUG, "Writing function() for " + m.getName(), null); SourceWriter sw = context.sw; JParameter[] parameters = m.getParameters(); FragmentGeneratorOracle fgo = context.fragmentGeneratorOracle; FragmentGenerator returnFragmentGenerator = fgo.findFragmentGenerator(logger, context.typeOracle, m.getReturnType()); sw.print("function("); for (int i = 0; i < parameters.length; i++) { sw.print("arg"); sw.print(String.valueOf(i)); if (i < parameters.length - 1) { sw.print(", "); } } sw.println(") {"); sw.indent(); if (returnFragmentGenerator.isIdentity()) { sw.print("return "); } else { sw.print("var javaReturn = "); } // Don't need to reference the instance on a static method if (!m.isStatic()) { sw.print(context.parameterName); sw.print("."); } sw.print("@"); sw.print(m.getEnclosingType().getQualifiedSourceName()); sw.print("::"); sw.print(m.getName()); sw.print("("); // Argument list for the Java invocation for (int i = 0; i < parameters.length; i++) { sw.print(parameters[i].getType().getJNISignature()); } sw.println(")("); // Indent the parameters, each on its own like to improve readability sw.indent(); sw.indent(); for (int i = 0; i < parameters.length; i++) { // Create a sub-context to generate the wrap/unwrap logic JType returnType = parameters[i].getType(); FragmentGeneratorContext subParams = new FragmentGeneratorContext(context); subParams.returnType = returnType; subParams.parameterName = "arg" + i; FragmentGenerator fragmentGenerator = fgo.findFragmentGenerator(logger, context.typeOracle, returnType); if (fragmentGenerator == null) { logger.log( TreeLogger.ERROR, "No fragment generator for " + returnType.getQualifiedSourceName(), null); throw new UnableToCompleteException(); } fragmentGenerator.fromJS(subParams); if (i < parameters.length - 1) { sw.println(", "); } } sw.outdent(); sw.outdent(); sw.println(");"); if (!returnFragmentGenerator.isIdentity()) { FragmentGeneratorContext returnContext = new FragmentGeneratorContext(context); returnContext.parameterName = "javaReturn"; returnContext.returnType = m.getReturnType(); sw.print("return "); returnFragmentGenerator.toJS(returnContext); sw.println(";"); } sw.outdent(); sw.print("}"); }
private void writeBeanDescriptor( TreeLogger logger, BeanResolver info, MethodWrapper[] methods, SourceWriter writer) { writer.println("new BeanDescriptor() { "); writer.indent(); writer.println("private HashMap lookup;"); writer.println("private Property[] properties;"); writer.println("public Property[] getProperties(){"); writer.indent(); { writer.println("if( this.properties != null ) "); writer.indentln("return this.properties;"); writer.println("this.properties = new Property[" + (info.getProperties().size()) + "];"); Collection pds = info.getProperties().values(); String[] propertyNames = new String[pds.size()]; logger.log(TreeLogger.SPAM, "" + (pds == null), null); if (pds != null) { int i = 0; for (Iterator it = pds.iterator(); it.hasNext(); i++) { RProperty p = (RProperty) it.next(); propertyNames[i] = p.getName(); writer.println("{"); writer.indent(); writer.print("Method readMethod = "); if (p.getReadMethod() == null) { writer.println("null;"); } else { writer.println( this.packageName + "." + this.methodsImplementationName + ".METHOD_" + +this.find(methods, p.getReadMethod()) + ";"); } writer.print("Method writeMethod = "); if (p.getWriteMethod() == null) { writer.println("null;"); } else { writer.println( this.packageName + "." + this.methodsImplementationName + ".METHOD_" + +this.find(methods, p.getWriteMethod()) + ";"); } logger.log( TreeLogger.DEBUG, p.getName() + " " + p.getType().getQualifiedSourceName(), null); JType ptype = this.resolveType(p.getType()); logger.log( TreeLogger.DEBUG, p.getName() + " (Erased) " + ptype.getQualifiedSourceName(), null); writer.println( "this.properties[" + (i) + "] = new Property( \"" + p.getName() + "\", " + ((p.getType() != null) ? ptype.getQualifiedSourceName() : "Object") + ".class, readMethod, writeMethod );"); writer.outdent(); writer.println("}"); } } writer.println("return this.properties;"); } writer.outdent(); writer.println("} //end getProperties()"); writer.println("public Property getProperty( String name ) {"); writer.indent(); // TODO Rewrite this to a nested if loop using the propertyNames parameter. writer.println("Property p = null;"); writer.println("if( this.lookup != null ) {"); writer.indentln("p = (Property) lookup.get(name); "); writer.println("} else {"); writer.indent(); writer.println("this.lookup = new HashMap();"); writer.println("Property[] props = this.getProperties(); "); writer.println("for( int i=0; i < props.length; i++ ) {"); writer.indent(); writer.println("this.lookup.put( props[i].getName(), props[i] );"); writer.outdent(); writer.println("}"); writer.println("p = (Property) this.lookup.get(name);"); writer.outdent(); writer.println("}"); writer.println( "if( p == null ) throw new RuntimeException(\"Couldn't find property \"+name+\" for " + info.getType().getQualifiedSourceName() + "\");"); writer.println("else return p;"); writer.outdent(); writer.println("}"); writer.outdent(); writer.print("}"); }
/** * Write an entry in the methodMapNative for one type. * * @param type type to generate entry for */ private void writeTypeMethodsNative(JType type) { srcWriter.indent(); String serializerName = SerializationUtils.getFieldSerializerName(typeOracle, type); JClassType customSerializer = SerializableTypeOracleBuilder.findCustomFieldSerializer(typeOracle, type); // First the initialization method if (deserializationOracle.maybeInstantiated(type)) { srcWriter.print("@"); if (customSerializer != null) { if (hasInstantiateMethod(customSerializer, type)) { srcWriter.print(serializerName); } else { srcWriter.print(SerializationUtils.getStandardSerializerName((JClassType) type)); } } else { srcWriter.print(serializerName); } srcWriter.print("::instantiate"); srcWriter.print("(L" + SerializationStreamReader.class.getName().replace('.', '/') + ";)"); } srcWriter.println(","); // Now the deserialization method if (deserializationOracle.isSerializable(type)) { // Assume param type is the concrete type of the serialized type. JType paramType = type; if (customSerializer != null) { // But a custom serializer may specify a looser type. JMethod deserializationMethod = CustomFieldSerializerValidator.getDeserializationMethod( customSerializer, (JClassType) type); paramType = deserializationMethod.getParameters()[1].getType(); } srcWriter.print("@" + serializerName); srcWriter.print( "::deserialize(L" + SerializationStreamReader.class.getName().replace('.', '/') + ";" + paramType.getJNISignature() + ")"); } srcWriter.println(","); // Now the serialization method if (serializationOracle.isSerializable(type)) { // Assume param type is the concrete type of the serialized type. JType paramType = type; if (customSerializer != null) { // But a custom serializer may specify a looser type. JMethod serializationMethod = CustomFieldSerializerValidator.getSerializationMethod( customSerializer, (JClassType) type); paramType = serializationMethod.getParameters()[1].getType(); } srcWriter.print("@" + serializerName); srcWriter.print( "::serialize(L" + SerializationStreamWriter.class.getName().replace('.', '/') + ";" + paramType.getJNISignature() + ")"); srcWriter.println(); } srcWriter.outdent(); }
private String buildRpcInterfaces( TreeLogger logger, GeneratorContext context, RequestQueueModel model) { String rqType = model.getRequestQueueInterfaceName(); int lastDot = rqType.lastIndexOf('.'); String packageName = rqType.substring(0, lastDot - 1); String serviceSourceName = rqType.substring(lastDot).replace('.', '_') + "_ImplRPC"; String asyncSourceName = serviceSourceName + "Async"; PrintWriter pw = context.tryCreate(logger, packageName, asyncSourceName); if (pw == null) { return packageName + "." + serviceSourceName; } // Create async class ClassSourceFileComposerFactory factory = new ClassSourceFileComposerFactory(packageName, asyncSourceName); factory.addImplementedInterface(ServiceQueueBaseAsync.class.getName()); factory.makeInterface(); SourceWriter asyncSw = factory.createSourceWriter(context, pw); // Create service class pw = context.tryCreate(logger, packageName, serviceSourceName); assert pw != null; factory = new ClassSourceFileComposerFactory(packageName, serviceSourceName); factory.addImplementedInterface(ServiceQueueBase.class.getName()); factory.makeInterface(); SourceWriter serviceSw = factory.createSourceWriter(context, pw); // write out service and async int i = 0; for (AsyncServiceModel service : model.getServices()) { for (AsyncServiceMethodModel method : service.getMethods()) { String methodName = "a" + ++i; asyncSw.println("void %1$s(", methodName); serviceSw.println("%2$s %1$s(", methodName, method.getReturnTypeName()); asyncSw.indent(); serviceSw.indent(); boolean firstArgument = true; int argIndex = 0; for (JType arg : method.getArgTypes()) { if (!firstArgument) { asyncSw.println(","); serviceSw.println(","); } firstArgument = false; if (arg.isPrimitive() != null) { JPrimitiveType t = arg.isPrimitive(); asyncSw.println("%2$s arg%1$d", argIndex, t.getQualifiedBoxedSourceName()); serviceSw.println("%2$s arg%1$d", argIndex, t.getQualifiedBoxedSourceName()); } else { asyncSw.println("%2$s arg%1$d", argIndex, arg.getParameterizedQualifiedSourceName()); serviceSw.println("%2$s arg%1$d", argIndex, arg.getParameterizedQualifiedSourceName()); } argIndex++; } if (!firstArgument) { asyncSw.print(", "); } // TODO return type boxing asyncSw.println( "%1$s<%2$s>callback);", AsyncCallback.class.getName(), method.getReturnTypeName()); serviceSw.print(")"); if (!method.getThrowables().isEmpty()) { serviceSw.print(" throws "); boolean firstThrowable = true; for (JClassType throwable : method.getThrowables()) { if (!firstThrowable) { serviceSw.print(", "); } firstThrowable = false; serviceSw.print(throwable.getQualifiedSourceName()); } } serviceSw.println(";"); asyncSw.outdent(); serviceSw.outdent(); } } asyncSw.commit(logger); serviceSw.commit(logger); return factory.getCreatedClassName(); }
public static InjectionCallbackArtifact ensureAsyncInjected( TreeLogger logger, String packageName, String className, String outputClass, GeneratorContext ctx) throws UnableToCompleteException { GwtInjectionMap gwtInjectionMap = getInjectionMap(logger, ctx); InjectionCallbackArtifact artifact = gwtInjectionMap.getOrCreateArtifact(ctx, packageName, className); if (artifact.isTargetUnbound()) { artifact.bindTo(outputClass); ensureProviderClass( logger, packageName, artifact.getSimpleName(), artifact.getCanonicalName(), artifact.getBoundTarget(), ctx); logger = logger.branch( Type.TRACE, "Creating asynchronous callback for " + artifact.getCanonicalName() + " -> " + outputClass); String generatedName = InjectionUtils.generatedAsyncProviderName(artifact.getGeneratedName()); String implPackage = artifact.getImplementationPackage(); PrintWriter printWriter = ctx.tryCreate(logger, implPackage, generatedName); if (printWriter == null) { logger.log( Type.WARN, "Could not create the source writer for " + implPackage + "." + generatedName); return artifact; } artifact.addCallback(implPackage + "." + generatedName + ".Deproxy"); ctx.commitArtifact(logger, artifact); ClassSourceFileComposerFactory composer = new ClassSourceFileComposerFactory(implPackage, generatedName); composer.setPrivacy("public final"); composer.addImport(com.google.gwt.core.client.GWT.class.getName()); composer.addImport(RunAsyncCallback.class.getName()); composer.addImport(Fifo.class.getName()); composer.addImport(JsFifo.class.getName()); composer.addImport(AsyncProxy.class.getName()); composer.addImport(ApplyMethod.class.getName()); composer.addImport(ReceivesValue.class.getName()); composer.addImport(ReceiverAdapter.class.getCanonicalName()); composer.addImport(artifact.getCanonicalName()); String simpleName = artifact.getSimpleName(); SourceWriter sw = composer.createSourceWriter(ctx, printWriter); sw.println(); sw.println("static final class Callbacks implements ApplyMethod{"); sw.indent(); sw.println("public void apply(Object ... args){"); sw.println("}"); sw.outdent(); sw.println("}"); sw.println(); sw.println("static final class Deproxy implements ReceivesValue<" + simpleName + ">{"); sw.indent(); sw.println("public final void set(final " + simpleName + " value){"); sw.indentln("getter = new ReceiverAdapter<" + simpleName + ">(value);"); sw.println("}"); sw.outdent(); sw.println("}"); sw.println(); sw.println( "private static final class Proxy implements ReceivesValue<ReceivesValue<" + simpleName + ">>{"); sw.indent(); sw.println("public final void set(final ReceivesValue<" + simpleName + "> receiver){"); sw.indent(); sw.print("GWT.runAsync("); sw.println(artifact.getCanonicalName() + ".class,new Request(receiver));"); sw.outdent(); sw.println("}"); sw.outdent(); sw.println("}"); sw.println(); sw.println("private static final class Request"); sw.indent(); sw.println("extends AsyncProxy<" + simpleName + "> "); sw.println("implements RunAsyncCallback{"); DefermentWriter defer = new DefermentWriter(sw); defer.setStrategy(DefermentStrategy.NONE); sw.println("private static final Fifo<ReceivesValue<" + simpleName + ">> pending ="); sw.indentln("JsFifo.newFifo();"); sw.println(); sw.println("protected Request(ReceivesValue<" + simpleName + "> receiver){"); sw.indentln("accept(receiver);"); sw.println("}"); sw.println(); sw.println("@Override"); sw.println("protected final Fifo<ReceivesValue<" + simpleName + ">> pending(){"); sw.indentln("return pending;"); sw.println("}"); sw.println(); sw.println("protected final void dispatch(){"); sw.indentln("go();"); sw.println("}"); sw.println(); sw.println("public final void onSuccess(){"); sw.indent(); defer.printStart(); sw.println("final " + simpleName + " value = "); sw.print(packageName + "." + InjectionUtils.generatedProviderName(simpleName)); sw.println(".theProvider.get();"); sw.println(); sw.print("final ApplyMethod callbacks = GWT.create("); sw.print(packageName + ".impl." + generatedName + ".Callbacks.class"); sw.println(");"); sw.println("callbacks.apply(value);"); sw.println(); sw.println("apply(value);"); sw.outdent(); sw.println("}"); sw.outdent(); defer.printFinish(); sw.println("}"); sw.println(); sw.println( "private static ReceivesValue<ReceivesValue<" + simpleName + ">> getter = new Proxy();"); sw.println(); sw.println("static void request(final ReceivesValue<" + simpleName + "> request){"); sw.indentln("getter.set(request);"); sw.println("}"); sw.println(); sw.println("static void go(){"); sw.indentln("request(null);"); sw.println("}"); sw.println(); sw.println("private " + generatedName + "(){}"); sw.commit(logger); } else { assert artifact.getBoundTarget().equals(outputClass) : "The injection target " + artifact.getCanonicalName() + " was bound " + "to " + artifact.getBoundTarget() + ", but you tried to bind it again, " + "to a different class: " + outputClass; } return artifact; }
private void emitBody(SourceWriter w) throws NotFoundException { JClassType baseClass = context_.getTypeOracle().getType("org.rstudio.core.client.js.JsObjectInjector"); JClassType c = baseType_.asParameterizationOf(baseClass.isGenericType()); JType typeToInject = c.isParameterized().getTypeArgs()[0]; w.print("public native final void injectObject("); w.print(typeToInject.getQualifiedSourceName()); w.println(" value) /*-{"); w.indent(); w.println(baseExpression_ + " = {"); w.indent(); JMethod[] methods = typeToInject.isClassOrInterface().getMethods(); for (int i = 0; i < methods.length; i++) { JMethod method = methods[i]; final JParameter[] jParameters = method.getParameters(); StringBuilder argString = new StringBuilder(); for (int j = 0; j < jParameters.length; j++) { argString.append("_").append(j); if (j < jParameters.length - 1) argString.append(", "); } w.println(method.getName() + ": function(" + argString + ") {"); w.indent(); if (!method.getReturnType().getQualifiedSourceName().equals("void")) w.print("return "); w.print("value.@"); w.print(typeToInject.getQualifiedSourceName()); w.print("::"); w.print(method.getName()); w.print("("); for (JParameter param : jParameters) w.print(param.getType().getJNISignature()); w.print(")("); w.print(argString.toString()); w.println(");"); w.outdent(); w.print("}"); w.println((i < methods.length - 1) ? "," : ""); } w.outdent(); w.println("};"); w.outdent(); w.println("}-*/;"); }
@Override public String generate(TreeLogger logger, GeneratorContext context, String typeName) throws UnableToCompleteException { TypeOracle oracle = context.getTypeOracle(); // JClassType requestQueue = oracle.findType(RequestQueue.class.getName()); JClassType toGenerate = oracle.findType(typeName); if (toGenerate == null) { logger.log(TreeLogger.ERROR, typeName + " is not an interface type"); throw new UnableToCompleteException(); } String packageName = toGenerate.getPackage().getName(); String simpleSourceName = toGenerate.getName().replace('.', '_') + "_Impl"; PrintWriter pw = context.tryCreate(logger, packageName, simpleSourceName); if (pw == null) { return packageName + "." + simpleSourceName; } ClassSourceFileComposerFactory factory = new ClassSourceFileComposerFactory(packageName, simpleSourceName); factory.setSuperclass(AbstractRequestQueueImpl.class.getName()); factory.addImplementedInterface(typeName); SourceWriter sw = factory.createSourceWriter(context, pw); // Collect async services we need to provide access to, and the rpc calls they'll make RequestQueueModel model = collectModel(logger.branch(Type.DEBUG, "Collecting service info"), context, toGenerate); // Build a pair of RPC interfaces for serialization String realRpcInterfaceName = buildRpcInterfaces(logger.branch(Type.DEBUG, "Writing RPC interfaces"), context, model); // Build the getRealService() method String serviceQueueAsync = ServiceQueueBaseAsync.class.getName(); sw.println("public %1$s getRealService() {", serviceQueueAsync); sw.indentln( "return %3$s.<%1$s>create(%2$s.class);", serviceQueueAsync, realRpcInterfaceName, GWT.class.getName()); sw.println("}"); // Build the methods (and maybe types?) that call addRequest() for (AsyncServiceModel service : model.getServices()) { sw.println( "public %1$s %2$s() {", service.getAsyncServiceInterfaceName(), service.getDeclaredMethodName()); sw.indent(); sw.println("return new %1$s() {", service.getAsyncServiceInterfaceName()); sw.indent(); for (AsyncServiceMethodModel method : service.getMethods()) { sw.println("public void %1$s(", method.getMethodName()); StringBuilder argList = new StringBuilder(); StringBuilder types = new StringBuilder("new String[]{"); for (int i = 0; i < method.getArgTypes().size(); i++) { if (i != 0) { sw.print(", "); argList.append(", "); types.append(", "); } JType arg = method.getArgTypes().get(i); sw.print("%1$s arg%2$d", arg.getParameterizedQualifiedSourceName(), i); argList.append("arg").append(i); types.append("\"").append(escape(SerializationUtils.getRpcTypeName(arg))).append("\""); } types.append("}"); if (method.hasCallback()) { if (method.getArgTypes().size() != 0) { sw.print(", "); } sw.print( "%1$s<%2$s> callback", AsyncCallback.class.getName(), method.getReturnTypeName()); } sw.println(") {"); sw.indent(); sw.println( "addRequest(\"%1$s\", \"%2$s\",\n%3$s,\n", escape(service.getServiceName()), escape(method.getMethodName()), types.toString()); if (method.hasCallback()) { sw.indentln("callback,"); } else { sw.indentln("null,"); } sw.indentln("new Object[]{%1$s});", argList.toString()); sw.outdent(); sw.println("}"); } sw.outdent(); sw.println("};"); sw.outdent(); sw.println("}"); } sw.commit(logger); return factory.getCreatedClassName(); }