Example usage for com.google.gwt.user.rebind SourceWriter outdent

List of usage examples for com.google.gwt.user.rebind SourceWriter outdent

  1. HOME
  2. Java
  3. com.google.gwt
  4. com.google.gwt.user.rebind.*
  5. SourceWriter
  6. outdent

Introduction

In this page you can find the example usage for com.google.gwt.user.rebind SourceWriter outdent.

Prototype

void outdent();

Source Link

Usage

From source file:com.google.web.bindery.autobean.gwt.rebind.AutoBeanFactoryGenerator.java

License:Apache License

private void writeReturnWrapper(SourceWriter sw, AutoBeanType type, AutoBeanMethod method)
        throws UnableToCompleteException {
    if (!method.isValueType() && !method.isNoWrap()) {
        JMethod jmethod = method.getMethod();
        JClassType returnClass = jmethod.getReturnType().isClassOrInterface();
        AutoBeanType peer = model.getPeer(returnClass);

        sw.println("if (toReturn != null) {");
        sw.indent();//  ww  w  .  ja va 2 s  . co  m
        sw.println("if (%s.this.isWrapped(toReturn)) {", type.getSimpleSourceName());
        sw.indentln("toReturn = %s.this.getFromWrapper(toReturn);", type.getSimpleSourceName());
        sw.println("} else {");
        sw.indent();
        if (peer != null) {
            // toReturn = new FooAutoBean(getFactory(), toReturn).as();
            sw.println("toReturn = new %s(getFactory(), toReturn).as();", peer.getQualifiedSourceName());
        }
        sw.outdent();
        sw.println("}");

        sw.outdent();
        sw.println("}");
    }
    // Allow return values to be intercepted
    JMethod interceptor = type.getInterceptor();
    if (interceptor != null) {
        // toReturn = FooCategory.__intercept(FooAutoBean.this, toReturn);
        sw.println("toReturn = %s.%s(%s.this, toReturn);",
                interceptor.getEnclosingType().getQualifiedSourceName(), interceptor.getName(),
                type.getSimpleSourceName());
    }
}

From source file:com.google.web.bindery.autobean.gwt.rebind.AutoBeanFactoryGenerator.java

License:Apache License

/**
 * Create the shim instance of the AutoBean's peer type that lets us hijack
 * the method calls. Using a shim type, as opposed to making the AutoBean
 * implement the peer type directly, means that there can't be any conflicts
 * between methods in the peer type and methods declared in the AutoBean
 * implementation./*  ww w. j  av a  2s . c o  m*/
 */
private void writeShim(SourceWriter sw, AutoBeanType type) throws UnableToCompleteException {
    // private final FooImpl shim = new FooImpl() {
    sw.println("private final %1$s shim = new %1$s() {", type.getPeerType().getQualifiedSourceName());
    sw.indent();
    for (AutoBeanMethod method : type.getMethods()) {
        JMethod jmethod = method.getMethod();
        String methodName = jmethod.getName();
        JParameter[] parameters = jmethod.getParameters();
        if (isObjectMethodImplementedByShim(jmethod)) {
            // Skip any methods declared on Object, since we have special handling
            continue;
        }

        // foo, bar, baz
        StringBuilder arguments = new StringBuilder();
        {
            for (JParameter param : parameters) {
                arguments.append(",").append(param.getName());
            }
            if (arguments.length() > 0) {
                arguments = arguments.deleteCharAt(0);
            }
        }

        sw.println("public %s {", getBaseMethodDeclaration(jmethod));
        sw.indent();

        switch (method.getAction()) {
        case GET:
            /*
             * The getter call will ensure that any non-value return type is
             * definitely wrapped by an AutoBean instance.
             */
            sw.println("%s toReturn = %s.this.getWrapped().%s();",
                    ModelUtils.getQualifiedBaseSourceName(jmethod.getReturnType()), type.getSimpleSourceName(),
                    methodName);

            // Non-value types might need to be wrapped
            writeReturnWrapper(sw, type, method);
            sw.println("return toReturn;");
            break;
        case SET:
        case SET_BUILDER:
            // getWrapped().setFoo(foo);
            sw.println("%s.this.getWrapped().%s(%s);", type.getSimpleSourceName(), methodName,
                    parameters[0].getName());
            // FooAutoBean.this.set("setFoo", foo);
            sw.println("%s.this.set(\"%s\", %s);", type.getSimpleSourceName(), methodName,
                    parameters[0].getName());
            if (JBeanMethod.SET_BUILDER.equals(method.getAction())) {
                sw.println("return this;");
            }
            break;
        case CALL:
            // XXX How should freezing and calls work together?
            // sw.println("checkFrozen();");
            if (JPrimitiveType.VOID.equals(jmethod.getReturnType())) {
                // getWrapped().doFoo(params);
                sw.println("%s.this.getWrapped().%s(%s);", type.getSimpleSourceName(), methodName, arguments);
                // call("doFoo", null, params);
                sw.println("%s.this.call(\"%s\", null%s %s);", type.getSimpleSourceName(), methodName,
                        arguments.length() > 0 ? "," : "", arguments);
            } else {
                // Type toReturn = getWrapped().doFoo(params);
                sw.println("%s toReturn = %s.this.getWrapped().%s(%s);",
                        ModelUtils.ensureBaseType(jmethod.getReturnType()).getQualifiedSourceName(),
                        type.getSimpleSourceName(), methodName, arguments);
                // Non-value types might need to be wrapped
                writeReturnWrapper(sw, type, method);
                // call("doFoo", toReturn, params);
                sw.println("%s.this.call(\"%s\", toReturn%s %s);", type.getSimpleSourceName(), methodName,
                        arguments.length() > 0 ? "," : "", arguments);
                sw.println("return toReturn;");
            }
            break;
        default:
            throw new RuntimeException();
        }
        sw.outdent();
        sw.println("}");
    }

    // Delegate equals(), hashCode(), and toString() to wrapped object
    sw.println("@Override public boolean equals(Object o) {");
    sw.indentln("return this == o || getWrapped().equals(o);");
    sw.println("}");
    sw.println("@Override public int hashCode() {");
    sw.indentln("return getWrapped().hashCode();");
    sw.println("}");
    sw.println("@Override public String toString() {");
    sw.indentln("return getWrapped().toString();");
    sw.println("}");

    // End of shim field declaration and assignment
    sw.outdent();
    sw.println("};");
}

From source file:com.google.web.bindery.autobean.gwt.rebind.AutoBeanFactoryGenerator.java

License:Apache License

/**
 * Generate traversal logic.//from  ww  w.java2s.  c  o  m
 */
private void writeTraversal(SourceWriter sw, AutoBeanType type) {
    List<AutoBeanMethod> referencedSetters = new ArrayList<AutoBeanMethod>();
    sw.println("@Override protected void traverseProperties(%s visitor, %s ctx) {",
            AutoBeanVisitor.class.getCanonicalName(), OneShotContext.class.getCanonicalName());
    sw.indent();
    sw.println("%s bean;", AbstractAutoBean.class.getCanonicalName());
    sw.println("Object value;");
    sw.println("%s propertyContext;", ClientPropertyContext.class.getCanonicalName());
    // Local variable ref cleans up emitted js
    sw.println("%1$s as = as();", type.getPeerType().getQualifiedSourceName());

    for (AutoBeanMethod method : type.getMethods()) {
        if (!method.getAction().equals(JBeanMethod.GET)) {
            continue;
        }

        AutoBeanMethod setter = null;
        // If it's not a simple bean type, try to find a real setter method
        if (!type.isSimpleBean()) {
            for (AutoBeanMethod maybeSetter : type.getMethods()) {
                boolean isASetter = maybeSetter.getAction().equals(JBeanMethod.SET)
                        || maybeSetter.getAction().equals(JBeanMethod.SET_BUILDER);
                if (isASetter && maybeSetter.getPropertyName().equals(method.getPropertyName())) {
                    setter = maybeSetter;
                    break;
                }
            }
        }

        // The type of property influences the visitation
        String valueExpression = String.format("bean = (%1$s) %2$s.getAutoBean(as.%3$s());",
                AbstractAutoBean.class.getCanonicalName(), AutoBeanUtils.class.getCanonicalName(),
                method.getMethod().getName());
        String visitMethod;
        String visitVariable = "bean";
        if (method.isCollection()) {
            visitMethod = "Collection";
        } else if (method.isMap()) {
            visitMethod = "Map";
        } else if (method.isValueType()) {
            valueExpression = String.format("value = as.%s();", method.getMethod().getName());
            visitMethod = "Value";
            visitVariable = "value";
        } else {
            visitMethod = "Reference";
        }
        sw.println(valueExpression);

        // Map<List<Foo>, Bar> --> Map, List, Foo, Bar
        List<JType> typeList = new ArrayList<JType>();
        createTypeList(typeList, method.getMethod().getReturnType());
        assert typeList.size() > 0;

        /*
         * Make the PropertyContext that lets us call the setter. We allow
         * multiple methods to be bound to the same property (e.g. to allow JSON
         * payloads to be interpreted as different types). The leading underscore
         * allows purely numeric property names, which are valid JSON map keys.
         */
        // propertyContext = new CPContext(.....);
        sw.println("propertyContext = new %s(", ClientPropertyContext.class.getCanonicalName());
        sw.indent();
        // The instance on which the context is nominally operating
        sw.println("as,");
        // Produce a JSNI reference to a setter function to call
        {
            if (setter != null) {
                // Call a method that returns a JSNI reference to the method to call
                // setFooMethodReference(),
                sw.println("%sMethodReference(as),", setter.getMethod().getName());
                referencedSetters.add(setter);
            } else {
                // Create a function that will update the values map
                // CPContext.beanSetter(FooBeanImpl.this, "foo");
                sw.println("%s.beanSetter(%s.this, \"%s\"),",
                        ClientPropertyContext.Setter.class.getCanonicalName(), type.getSimpleSourceName(),
                        method.getPropertyName());
            }
        }
        if (typeList.size() == 1) {
            sw.println("%s.class", ModelUtils.ensureBaseType(typeList.get(0)).getQualifiedSourceName());
        } else {
            // Produce the array of parameter types
            sw.print("new Class<?>[] {");
            boolean first = true;
            for (JType lit : typeList) {
                if (first) {
                    first = false;
                } else {
                    sw.print(", ");
                }
                sw.print("%s.class", ModelUtils.ensureBaseType(lit).getQualifiedSourceName());
            }
            sw.println("},");

            // Produce the array of parameter counts
            sw.print("new int[] {");
            first = true;
            for (JType lit : typeList) {
                if (first) {
                    first = false;
                } else {
                    sw.print(", ");
                }
                JParameterizedType hasParam = lit.isParameterized();
                if (hasParam == null) {
                    sw.print("0");
                } else {
                    sw.print(String.valueOf(hasParam.getTypeArgs().length));
                }
            }
            sw.println("}");
        }
        sw.outdent();
        sw.println(");");

        // if (visitor.visitReferenceProperty("foo", value, ctx))
        sw.println("if (visitor.visit%sProperty(\"%s\", %s, propertyContext)) {", visitMethod,
                method.getPropertyName(), visitVariable);
        if (!method.isValueType()) {
            // Cycle-detection in AbstractAutoBean.traverse
            sw.indentln("if (bean != null) { bean.traverse(visitor, ctx); }");
        }
        sw.println("}");
        // visitor.endVisitorReferenceProperty("foo", value, ctx);
        sw.println("visitor.endVisit%sProperty(\"%s\", %s, propertyContext);", visitMethod,
                method.getPropertyName(), visitVariable);
    }
    sw.outdent();
    sw.println("}");

    for (AutoBeanMethod method : referencedSetters) {
        JMethod jmethod = method.getMethod();
        assert jmethod.getParameters().length == 1;

        /*-
         * Setter setFooMethodReference(Object instance) {
         *   return instance.@com.example.Blah::setFoo(Lcom/example/Foo;);
         * }
         */
        sw.println("public static native %s %sMethodReference(Object instance) /*-{",
                ClientPropertyContext.Setter.class.getCanonicalName(), jmethod.getName());
        sw.indentln("return instance.@%s::%s(%s);", jmethod.getEnclosingType().getQualifiedSourceName(),
                jmethod.getName(), jmethod.getParameters()[0].getType().getJNISignature());
        sw.println("}-*/;");
    }
}

From source file:com.google.web.bindery.event.gwt.rebind.binder.EventBinderWriter.java

License:Apache License

private void writeBindMethodFooter(SourceWriter writer) {
    writer.println("return registrations;");
    writer.outdent();
    writer.println("}");
}

From source file:com.google.web.bindery.requestfactory.gwt.rebind.RequestFactoryGenerator.java

License:Apache License

private void writeAutoBeanFactory(SourceWriter sw, Collection<EntityProxyModel> models,
        Collection<JEnumType> extraEnums) {
    if (!extraEnums.isEmpty()) {
        StringBuilder extraClasses = new StringBuilder();
        for (JEnumType enumType : extraEnums) {
            if (extraClasses.length() > 0) {
                extraClasses.append(",");
            }//w w w .j  a v a2  s. c o  m
            extraClasses.append(enumType.getQualifiedSourceName()).append(".class");
        }
        sw.println("@%s({%s})", ExtraEnums.class.getCanonicalName(), extraClasses);
    }
    // Map in static implementations of EntityProxy methods
    sw.println("@%s({%s.class, %s.class, %s.class})", Category.class.getCanonicalName(),
            EntityProxyCategory.class.getCanonicalName(), ValueProxyCategory.class.getCanonicalName(),
            BaseProxyCategory.class.getCanonicalName());
    // Don't wrap our id type, because it makes code grungy
    sw.println("@%s(%s.class)", NoWrap.class.getCanonicalName(), EntityProxyId.class.getCanonicalName());
    sw.println("interface Factory extends %s {", AutoBeanFactory.class.getCanonicalName());
    sw.indent();

    for (EntityProxyModel proxy : models) {
        // AutoBean<FooProxy> com_google_FooProxy();
        sw.println("%s<%s> %s();", AutoBean.class.getCanonicalName(), proxy.getQualifiedSourceName(),
                proxy.getQualifiedSourceName().replace('.', '_'));
    }
    sw.outdent();
    sw.println("}");

    // public static final Factory FACTORY = GWT.create(Factory.class);
    sw.println("public static Factory FACTORY;", GWT.class.getCanonicalName());

    // Write public accessor
    sw.println("@Override public Factory getAutoBeanFactory() {");
    sw.indent();
    sw.println("if (FACTORY == null) {");
    sw.indentln("FACTORY = %s.create(Factory.class);", GWT.class.getCanonicalName());
    sw.println("}");
    sw.println("return FACTORY;");
    sw.outdent();
    sw.println("}");
}

From source file:com.google.web.bindery.requestfactory.gwt.rebind.RequestFactoryGenerator.java

License:Apache License

private void writeContextImplementations() {
    for (ContextMethod method : model.getMethods()) {
        PrintWriter pw = context.tryCreate(logger, method.getPackageName(), method.getSimpleSourceName());
        if (pw == null) {
            // Already generated
            continue;
        }/*from   w  w w.ja  v a2  s  . c om*/

        ClassSourceFileComposerFactory factory = new ClassSourceFileComposerFactory(method.getPackageName(),
                method.getSimpleSourceName());
        factory.setSuperclass(AbstractRequestContext.class.getCanonicalName());
        factory.addImplementedInterface(method.getImplementedInterfaceQualifiedSourceName());
        SourceWriter sw = factory.createSourceWriter(context, pw);

        // Constructor that accepts the parent RequestFactory
        sw.println("public %s(%s requestFactory) {super(requestFactory, %s.%s);}", method.getSimpleSourceName(),
                AbstractRequestFactory.class.getCanonicalName(), Dialect.class.getCanonicalName(),
                method.getDialect().name());

        Set<EntityProxyModel> models = findReferencedEntities(method);
        Set<JEnumType> extraEnumTypes = findExtraEnums(method);
        writeAutoBeanFactory(sw, models, extraEnumTypes);

        // Write each Request method
        for (RequestMethod request : method.getRequestMethods()) {
            JMethod jmethod = request.getDeclarationMethod();
            String operation = request.getOperation();

            // foo, bar, baz
            StringBuilder parameterArray = new StringBuilder();
            // final Foo foo, final Bar bar, final Baz baz
            StringBuilder parameterDeclaration = new StringBuilder();
            // <P extends Blah>
            StringBuilder typeParameterDeclaration = new StringBuilder();

            if (request.isInstance()) {
                // Leave a spot for the using() method to fill in later
                parameterArray.append(",null");
            }
            for (JTypeParameter param : jmethod.getTypeParameters()) {
                typeParameterDeclaration.append(",").append(param.getQualifiedSourceName());
            }
            for (JParameter param : jmethod.getParameters()) {
                parameterArray.append(",").append(param.getName());
                parameterDeclaration.append(",final ")
                        .append(param.getType().getParameterizedQualifiedSourceName()).append(" ")
                        .append(param.getName());
            }
            if (parameterArray.length() > 0) {
                parameterArray.deleteCharAt(0);
            }
            if (parameterDeclaration.length() > 0) {
                parameterDeclaration.deleteCharAt(0);
            }
            if (typeParameterDeclaration.length() > 0) {
                typeParameterDeclaration.deleteCharAt(0).insert(0, "<").append(">");
            }

            // public Request<Foo> doFoo(final Foo foo) {
            sw.println("public %s %s %s(%s) {", typeParameterDeclaration,
                    jmethod.getReturnType().getParameterizedQualifiedSourceName(), jmethod.getName(),
                    parameterDeclaration);
            sw.indent();
            // The implements clause covers InstanceRequest
            // class X extends AbstractRequest<Return> implements Request<Return> {
            sw.println("class X extends %s<%s> implements %s {", AbstractRequest.class.getCanonicalName(),
                    request.getDataType().getParameterizedQualifiedSourceName(),
                    jmethod.getReturnType().getParameterizedQualifiedSourceName());
            sw.indent();

            // public X() { super(FooRequestContext.this); }
            sw.println("public X() { super(%s.this);}", method.getSimpleSourceName());

            // This could also be gotten rid of by having only Request /
            // InstanceRequest
            sw.println("@Override public X with(String... paths) {super.with(paths); return this;}");

            // makeRequestData()
            sw.println("@Override protected %s makeRequestData() {", RequestData.class.getCanonicalName());
            String elementType = request.isCollectionType()
                    ? request.getCollectionElementType().getQualifiedSourceName() + ".class"
                    : "null";
            String returnTypeBaseQualifiedName = ModelUtils.ensureBaseType(request.getDataType())
                    .getQualifiedSourceName();
            // return new RequestData("ABC123", {parameters}, propertyRefs,
            // List.class, FooProxy.class);
            sw.indentln("return new %s(\"%s\", new Object[] {%s}, propertyRefs, %s.class, %s);",
                    RequestData.class.getCanonicalName(), operation, parameterArray,
                    returnTypeBaseQualifiedName, elementType);
            sw.println("}");

            /*
             * Only support extra properties in JSON-RPC payloads. Could add this to
             * standard requests to provide out-of-band data.
             */
            if (method.getDialect().equals(Dialect.JSON_RPC)) {
                for (JMethod setter : request.getExtraSetters()) {
                    PropertyName propertyNameAnnotation = setter.getAnnotation(PropertyName.class);
                    String propertyName = propertyNameAnnotation == null ? JBeanMethod.SET.inferName(setter)
                            : propertyNameAnnotation.value();
                    String maybeReturn = JBeanMethod.SET_BUILDER.matches(setter) ? "return this;" : "";
                    sw.println("%s { getRequestData().setNamedParameter(\"%s\", %s); %s}",
                            setter.getReadableDeclaration(false, false, false, false, true), propertyName,
                            setter.getParameters()[0].getName(), maybeReturn);
                }
            }

            // end class X{}
            sw.outdent();
            sw.println("}");

            // Instantiate, enqueue, and return
            sw.println("X x = new X();");

            if (request.getApiVersion() != null) {
                sw.println("x.getRequestData().setApiVersion(\"%s\");",
                        Generator.escape(request.getApiVersion()));
            }

            // JSON-RPC payloads send their parameters in a by-name fashion
            if (method.getDialect().equals(Dialect.JSON_RPC)) {
                for (JParameter param : jmethod.getParameters()) {
                    PropertyName annotation = param.getAnnotation(PropertyName.class);
                    String propertyName = annotation == null ? param.getName() : annotation.value();
                    boolean isContent = param.isAnnotationPresent(JsonRpcContent.class);
                    if (isContent) {
                        sw.println("x.getRequestData().setRequestContent(%s);", param.getName());
                    } else {
                        sw.println("x.getRequestData().setNamedParameter(\"%s\", %s);", propertyName,
                                param.getName());
                    }
                }
            }

            // See comment in AbstractRequest.using(EntityProxy)
            if (!request.isInstance()) {
                sw.println("addInvocation(x);");
            }
            sw.println("return x;");
            sw.outdent();
            sw.println("}");
        }

        sw.commit(logger);
    }
}

From source file:com.google.web.bindery.requestfactory.gwt.rebind.RequestFactoryGenerator.java

License:Apache License

private void writeTypeMap(SourceWriter sw) {
    sw.println("private static final %1$s<String, Class<?>> tokensToTypes" + " = new %1$s<String, Class<?>>();",
            HashMap.class.getCanonicalName());
    sw.println("private static final %1$s<Class<?>, String> typesToTokens" + " = new %1$s<Class<?>, String>();",
            HashMap.class.getCanonicalName());
    sw.println("private static final %1$s<Class<?>> entityProxyTypes = new %1$s<Class<?>>();",
            HashSet.class.getCanonicalName());
    sw.println("private static final %1$s<Class<?>> valueProxyTypes = new %1$s<Class<?>>();",
            HashSet.class.getCanonicalName());
    sw.println("static {");
    sw.indent();/*from  ww w .  j av  a  2 s.  c om*/
    for (EntityProxyModel type : model.getAllProxyModels()) {
        // tokensToTypes.put("Foo", Foo.class);
        sw.println("tokensToTypes.put(\"%s\", %s.class);", OperationKey.hash(type.getQualifiedBinaryName()),
                type.getQualifiedSourceName());
        // typesToTokens.put(Foo.class, Foo);
        sw.println("typesToTokens.put(%s.class, \"%s\");", type.getQualifiedSourceName(),
                OperationKey.hash(type.getQualifiedBinaryName()));
        // fooProxyTypes.add(MyFooProxy.class);
        sw.println("%s.add(%s.class);",
                type.getType().equals(Type.ENTITY) ? "entityProxyTypes" : "valueProxyTypes",
                type.getQualifiedSourceName());
    }
    sw.outdent();
    sw.println("}");

    // Write instance methods
    sw.println("@Override public String getFactoryTypeToken() {");
    sw.indentln("return \"%s\";", model.getFactoryType().getQualifiedBinaryName());
    sw.println("}");
    sw.println("@Override protected Class getTypeFromToken(String typeToken) {");
    sw.indentln("return tokensToTypes.get(typeToken);");
    sw.println("}");
    sw.println("@Override protected String getTypeToken(Class type) {");
    sw.indentln("return typesToTokens.get(type);");
    sw.println("}");
    sw.println("@Override public boolean isEntityType(Class<?> type) {");
    sw.indentln("return entityProxyTypes.contains(type);");
    sw.println("}");
    sw.println("@Override public boolean isValueType(Class<?> type) {");
    sw.indentln("return valueProxyTypes.contains(type);");
    sw.println("}");
}

From source file:com.googlecode.gwtx.rebind.PropertyDescriptorsGenerator.java

License:Apache License

/**
 * @param logger/*from  w  w  w  . j a  v  a2s.co m*/
 * @param w
 * @param typeOracle
 */
private void write(TreeLogger logger, SourceWriter w, JClassType type) {
    Collection<Property> properties = lookupJavaBeanPropertyAccessors(logger, type);

    w.println("// automatically register BeanInfos for bean properties");
    w.println("static {");
    w.indent();
    w.println("GwtBeanInfo beanInfo = new GwtBeanInfo();");
    for (Property property : properties) {
        w.println("try {");
        w.indent();
        w.print("beanInfo.addPropertyDescriptor( ");
        writePropertyDescriptor(w, type, property.name, property.propertyType, property.getter,
                property.setter);
        w.println(" );");
        w.outdent();
        w.println("} catch (Exception e) {}");
    }
    w.println("GwtIntrospector.setBeanInfo( " + type.getName() + ".class, beanInfo );");
    w.outdent();
    w.println("}");
}

From source file:com.googlecode.gwtx.rebind.PropertyDescriptorsGenerator.java

License:Apache License

/**
 * @param sw/*from w  w w  . j  av a2s.  c o  m*/
 * @param type
 * @param propertyName
 * @param getter
 * @param setter
 */
private void writePropertyDescriptor(SourceWriter sw, JClassType type, String propertyName, String propertyType,
        JMethod getter, JMethod setter) {
    sw.print("new PropertyDescriptor( \"" + propertyName + "\", " + propertyType + ".class, ");
    if (getter != null) {
        sw.println("new Method() ");
        sw.println("{");
        sw.indent();
        sw.println("public Object invoke( Object bean, Object... args )");
        sw.println("{");
        sw.indent();
        sw.println("return ( (" + type.getName() + ") bean)." + getter.getName() + "();");
        sw.outdent();
        sw.println("}");
        sw.outdent();
        sw.print("}, ");
    } else {
        sw.print("null, ");
    }
    if (setter != null) {
        sw.println("new Method() ");
        sw.println("{");
        sw.indent();
        sw.println("public Object invoke( Object bean, Object... args )");
        sw.println("{");
        sw.indent();
        JType argType = setter.getParameters()[0].getType().getErasedType();
        String argTypeName;
        if (argType.isPrimitive() != null) {
            argTypeName = argType.isPrimitive().getQualifiedBoxedSourceName();
        } else {
            argTypeName = argType.getQualifiedSourceName();
        }
        sw.println(
                "( (" + type.getName() + ") bean)." + setter.getName() + "( (" + argTypeName + ") args[0] );");
        sw.println("return null;");
        sw.outdent();
        sw.println("}");
        sw.outdent();
        sw.print("} )");
    } else {
        sw.print("null )");
    }
}

From source file:com.googlecode.mgwt.ui.server.util.MGWTCssResourceGenerator.java

License:Apache License

@Override
protected void writeEnsureInjected(SourceWriter sw) {
    if (!injectAtStart) {
        super.writeEnsureInjected(sw);
    } else {//from w ww  . j  ava  2 s  . c om
        sw.println("private boolean injected;");
        sw.println("public boolean ensureInjected() {");
        sw.indent();
        sw.println("if (!injected) {");
        sw.indentln("injected = true;");
        sw.indentln(StyleInjector.class.getName() + ".injectAtStart(getText());");
        sw.indentln("return true;");
        sw.println("}");
        sw.println("return false;");
        sw.outdent();
        sw.println("}");
    }
}