Example usage for com.google.gwt.core.ext.typeinfo JPrimitiveType BOOLEAN

List of usage examples for com.google.gwt.core.ext.typeinfo JPrimitiveType BOOLEAN

Introduction

In this page you can find the example usage for com.google.gwt.core.ext.typeinfo JPrimitiveType BOOLEAN.

Prototype

JPrimitiveType BOOLEAN

To view the source code for com.google.gwt.core.ext.typeinfo JPrimitiveType BOOLEAN.

Click Source Link

Usage

From source file:com.colinalworth.celltable.columns.rebind.ColumnsGenerator.java

License:Apache License

/**
 * @return/*  ww  w.  j a v a 2s . c  o  m*/
 */
private boolean supportsSortable() {
    return context.getTypeOracle().findType(Name.getSourceNameForClass(Column.class)).findMethod("setSortable",
            new JType[] { JPrimitiveType.BOOLEAN }) != null;
}

From source file:com.ekuefler.supereventbus.rebind.EventRegistrationWriter.java

License:Apache License

private String getFirstParameterType(JMethod method) {
    // If the parameter type is primitive, box it
    JType type = method.getParameterTypes()[0];
    if (type.isPrimitive() != null) {
        if (type.isPrimitive() == JPrimitiveType.BOOLEAN) {
            return Boolean.class.getName();
        } else if (type.isPrimitive() == JPrimitiveType.BYTE) {
            return Byte.class.getName();
        } else if (type.isPrimitive() == JPrimitiveType.CHAR) {
            return Character.class.getName();
        } else if (type.isPrimitive() == JPrimitiveType.DOUBLE) {
            return Double.class.getName();
        } else if (type.isPrimitive() == JPrimitiveType.FLOAT) {
            return Float.class.getName();
        } else if (type.isPrimitive() == JPrimitiveType.INT) {
            return Integer.class.getName();
        } else if (type.isPrimitive() == JPrimitiveType.LONG) {
            return Long.class.getName();
        } else if (type.isPrimitive() == JPrimitiveType.SHORT) {
            return Short.class.getName();
        }// w  w w. ja  v  a2s .c o  m
    }

    // Otherwise return the fully-qualified type name
    return type.getQualifiedSourceName();
}

From source file:com.github.nmorel.gwtjackson.rebind.property.PropertyProcessor.java

License:Apache License

private static boolean isGetterAutoDetected(RebindConfiguration configuration,
        PropertyAccessors propertyAccessors, BeanInfo info) {
    if (!propertyAccessors.getGetter().isPresent()) {
        return false;
    }/*from  w  w  w  .j  a v a  2 s  . com*/

    for (Class<? extends Annotation> annotation : AUTO_DISCOVERY_ANNOTATIONS) {
        if (propertyAccessors.isAnnotationPresentOnGetter(annotation)) {
            return true;
        }
    }

    JMethod getter = propertyAccessors.getGetter().get();

    String methodName = getter.getName();
    JsonAutoDetect.Visibility visibility;
    if (methodName.startsWith("is") && methodName.length() > 2
            && JPrimitiveType.BOOLEAN.equals(getter.getReturnType().isPrimitive())) {

        // getter method for a boolean
        visibility = info.getIsGetterVisibility();
        if (Visibility.DEFAULT == visibility) {
            visibility = configuration.getDefaultIsGetterVisibility();
        }

    } else if (methodName.startsWith("get") && methodName.length() > 3) {

        visibility = info.getGetterVisibility();
        if (Visibility.DEFAULT == visibility) {
            visibility = configuration.getDefaultGetterVisibility();
        }

    } else {
        // no annotation on method and the method does not follow naming convention
        return false;
    }
    return isAutoDetected(visibility, getter.isPrivate(), getter.isProtected(), getter.isPublic(),
            getter.isDefaultAccess());
}

From source file:com.guit.rebind.binder.GuitBinderGenerator.java

License:Apache License

/**
 * Finds the valid methods and check all the conventions.
 *///from  ww w  . j  a  v a  2  s .  c  o  m
protected void printEventBusBindingMethods(SourceWriter writer, JClassType presenterType)
        throws UnableToCompleteException {
    JPackage contextEventsPackage = getPackage(presenterType.getPackage().getName() + ".event");
    for (JMethod m : presenterType.getMethods()) {
        if (m.isAnnotationPresent(EventBusHandler.class)) {

            EventBusHandler eventBusHandler = m.getAnnotation(EventBusHandler.class);

            String name = m.getName();
            String presenterName = presenterType.getQualifiedSourceName();

            validateHandler(m, name, presenterName);

            // Find the event type
            JParameter[] parameters = m.getParameters();

            if (!name.startsWith("$") && !name.startsWith("eventBus$")) {
                error("Bad method name: %s on class: %s, the method should start with '$' or 'eventBus$'", name,
                        presenterName);
            }

            // Clean the name
            if (name.startsWith("$")) {
                name = name.substring(1); // Cut off the $
            } else {
                name = name.substring(9); // Cut off the eventBus$
            }

            JClassType eventType = getType(eventBusHandler.value().getCanonicalName());
            if (eventType.equals(gwtEventType)) {
                eventType = getEventByName(name, contextEventsPackage);
                if (eventType == null) {
                    error("There is no context, dom or shared event with the name '%s'. Binding method: '%s' in class: '%s'",
                            name, m.getName(), presenterType.getQualifiedSourceName());
                }
            }

            StringBuilder bindingParameters = new StringBuilder();
            ArrayList<String> parameterStrings = new ArrayList<String>();
            for (JParameter p : parameters) {
                String parameter = p.getName();

                if (bindingParameters.length() > 0) {
                    bindingParameters.append(", ");
                }

                int initlenght = bindingParameters.length();

                // Implicit cast
                bindingParameters
                        .append("(" + p.getType().getErasedType().getParameterizedQualifiedSourceName() + ")");

                String getter = "get";

                // Check if it is a boolean then the getter is 'is' not
                // 'get'
                JPrimitiveType parameterTypeIsPrimitive = p.getType().isPrimitive();
                if (parameterTypeIsPrimitive != null
                        && parameterTypeIsPrimitive.equals(JPrimitiveType.BOOLEAN)) {
                    getter = "is";
                }

                // Event getter binding
                if (parameter.indexOf("$") == -1) {
                    // Event binding
                    bindingParameters.append("event.");
                    bindingParameters.append(getter);
                    bindingParameters.append(capitalize(parameter));
                    bindingParameters.append("()");
                } else {
                    // Event binding nested binding
                    String[] parameterParts = parameter.split("[$]");

                    bindingParameters.append("event");
                    for (int n = 0; n < parameterParts.length - 1; n++) {
                        bindingParameters.append(".get");
                        bindingParameters.append(capitalize(parameterParts[n]));
                        bindingParameters.append("()");
                    }

                    bindingParameters.append(".");
                    bindingParameters.append(getter);
                    bindingParameters.append(capitalize(parameterParts[parameterParts.length - 1]));
                    bindingParameters.append("()");
                }

                parameterStrings.add(bindingParameters.substring(initlenght, bindingParameters.length()));
            }

            // Find the event name
            String simpleName = eventType.getSimpleSourceName();
            if (!simpleName.endsWith("Event")) {
                error("The event %s does not use the event convention. It should end with 'Event'",
                        eventType.getQualifiedSourceName());
            }
            String eventName = eventClassNameToEventName(simpleName);

            // Check that the name of the event correspond to the method
            // name convention
            if (!eventName.equals(name)) {
                error("The method %s on class %s does not use the event bus handler method convention. "
                        + "It should start with '$' or 'eventBus$' "
                        + "and end with the event name. i.e ValueChangeEvent -> $valueChange. Solve it renaming it to '$%s'",
                        m.getName(), presenterName, eventName);
            }

            // Get event handler name
            JClassType handlerType = getHandlerForEvent(eventType);
            if (handlerType == null) {
                error("Parameter '%s' is not an event (subclass of GwtEvent).", eventType.getName());
            }

            // Retrieves the single method (usually 'onSomething') related
            // to all
            // handlers. Ex: onClick in ClickHandler, onBlur in BlurHandler
            // ...
            JMethod[] methods = handlerType.getMethods();
            if (methods.length != 1) {
                error("'%s' has more than one method defined.", handlerType.getName());
            }

            // 'onSomething' method
            JMethod handlerOnMethod = methods[0];

            // Checks if the method has an Event as parameter. Ex:
            // ClickEvent in onClick, BlurEvent in onBlur ...
            parameters = handlerOnMethod.getParameters();
            if (parameters.length != 1) {
                error("Method '%s' needs '%s' as parameter", handlerOnMethod.getName(), eventType.getName());
            }

            writer.println("eventBusBindings.add(eventBus.addHandler(");

            writer.println(eventType.getQualifiedSourceName() + ".");

            // getType or TYPE ?
            JField typeField = eventType.getField("TYPE");
            if (typeField != null && typeField.isStatic() && typeField.isPublic()) {
                writer.println("TYPE");
            } else {
                writer.println("getType()");
            }
            writer.println(", ");

            writer.println("new " + handlerType.getQualifiedSourceName() + "() {");
            writer.indent();
            writer.println("public void " + handlerOnMethod.getName() + "(final "
                    + eventType.getQualifiedSourceName() + " event) {");
            writer.indent();

            // Process contributors
            String bindingParametersString = bindingParameters.toString();
            BinderContextImpl binderContext = processMethodContributors(presenterType, null, null, null, m,
                    eventType, parameterStrings.toArray(new String[parameterStrings.size()]));

            StringSourceWriter handlerWriter = new StringSourceWriter();

            handlerWriter
                    .println("if (" + LogConfiguration.class.getCanonicalName() + ".loggingIsEnabled()) {");
            handlerWriter.println(Logger.class.getCanonicalName() + ".getLogger(\"Binder\").info(\""
                    + binderContext.getLog() + "\");");
            handlerWriter.println("}");

            handlerWriter.println("presenter." + m.getName() + "(" + bindingParametersString + ");");

            writer.println(binderContext.build(handlerWriter));

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

From source file:com.guit.rebind.binder.GuitBinderGenerator.java

License:Apache License

private void printViewBindingMethods(SourceWriter writer, JClassType presenterType, String viewTypeName,
        HashMap<String, JType> validBindingFieldsTypes) throws UnableToCompleteException {

    Set<String> validBindingFields = validBindingFieldsTypes.keySet();

    JPackage contextEventsPackage = getPackage(presenterType.getPackage().getName() + ".event");

    ArrayList<JMethod> methods = new ArrayList<JMethod>();
    findAllMethods(presenterType, methods);

    for (JMethod m : methods) {
        String name = m.getName();
        if (m.isAnnotationPresent(ViewHandler.class)) {
            validateHandler(m, name, presenterType.getQualifiedSourceName());

            String eventName;/*  w  w  w . j a v a 2s. c  om*/
            ViewHandler viewHandlerAnnotation = m.getAnnotation(ViewHandler.class);
            JClassType eventType = getType(viewHandlerAnnotation.event().getCanonicalName());

            boolean fieldsAreElements = false;
            Set<String> bindingFields = null;
            boolean addHandlerToView = false;
            if (viewHandlerAnnotation.fields().length == 0) {
                if (name.startsWith("$")) {
                    // Direct view binding
                    eventName = name.substring(1);

                    addHandlerToView = true;
                } else {
                    // View fields binding
                    String[] nameParts = name.split("[$]");

                    // Check the name format
                    if (nameParts.length < 2) {
                        error("The method %s on the class %s have a bad binding format. It should be: "
                                + "'{viewField}${eventName}' or for binding multiple fields: '{viewField1}${viewField2}${eventName}'",
                                name, presenterType.getQualifiedSourceName());
                    }

                    // Check that the binding fields are valid
                    bindingFields = new HashSet<String>();
                    for (int n = 0; n < nameParts.length - 1; n++) {
                        if (!validBindingFields.contains(nameParts[n])) {
                            error("The field %s on the class %s is not a valid binding field. It must be public or protected and not static",
                                    nameParts[n], presenterType);
                        }
                        bindingFields.add(nameParts[n]);
                    }

                    eventName = nameParts[nameParts.length - 1]; // last
                    // token
                }

                // Check the event type and name convention
                if (eventType.equals(gwtEventType)) {
                    eventType = getEventByName(eventName, contextEventsPackage);
                    if (eventType == null) {
                        error("There is no context, dom or shared event with the name '%s'. Binding method: '%s' in class: '%s'",
                                eventName, name, presenterType.getQualifiedSourceName());
                    }
                } else {
                    // Check that the method name correspond to the event
                    // type
                    String eventNameToEventClassName = eventNameToEventClassName(eventName);
                    if (!eventNameToEventClassName.equals(eventType.getSimpleSourceName())) {
                        error("The method '%s' in the class '%s' have a typo in the name. The last token should be : ..$%s() {.. ",
                                name, presenterType.getQualifiedSourceName(), eventName);
                    }
                }
            } else {
                String[] fields = viewHandlerAnnotation.fields();
                bindingFields = new HashSet<String>();
                for (String f : fields) {
                    if (f.isEmpty()) {
                        addHandlerToView = true;
                    } else {
                        if (!validBindingFields.contains(f)) {
                            error("The field %s on the class %s is not a valid binding field. It must be public or protected and not static",
                                    f, presenterType);
                        }
                        bindingFields.add(f);
                    }
                }

                if (eventType.equals(gwtEventType)) {
                    error("When using ViewFields you must specify the event class in the Handler annotation. Found: %s.%s",
                            presenterType.getQualifiedSourceName(), name);
                }

                eventName = eventClassNameToEventName(eventType.getSimpleSourceName());
            }

            // If any field is an element all of them should be otherwise none
            // of them
            int widgetCount = 0;
            JClassType widgetJType = getType(Widget.class.getCanonicalName());
            JClassType isWidgetJType = getType(IsWidget.class.getCanonicalName());
            for (String f : bindingFields) {
                JClassType classOrInterface = validBindingFieldsTypes.get(f).isClassOrInterface();
                if (classOrInterface.isAssignableTo(widgetJType)
                        || classOrInterface.isAssignableTo(isWidgetJType)) {
                    widgetCount++;
                }
            }

            if (widgetCount != bindingFields.size() && widgetCount != 0) {
                error("Not all fields on the class %s.%s are either all elements or all widgets. You cannot bind elements and widgets on the same handler",
                        presenterType, name);
            }
            fieldsAreElements = widgetCount == 0;

            /**
             * Find parameters bindings. The binding can be with the event(cannot have anidation of
             * getters):'getter'->'getGetter()' or with the view:'$getter'->'view.getGetter()' or with a
             * view field '{viewField$getter}'->'view.viewField.getGetter();', this last two ones will
             * support anidation: '{viewField$getter$another}'->'view.viewField.getGetter().getAnother (
             * ) ; '
             **/
            StringBuilder bindingParameters = new StringBuilder();
            JParameter[] parameters = m.getParameters();
            ArrayList<String> parameterStrings = new ArrayList<String>();
            for (JParameter p : parameters) {
                String parameter = p.getName();
                JType parameterType = p.getType();
                if (bindingParameters.length() > 0) {
                    bindingParameters.append(", ");
                }

                int initlenght = bindingParameters.length();

                // Implicit cast
                bindingParameters.append(
                        "(" + parameterType.getErasedType().getParameterizedQualifiedSourceName() + ")");

                String getter = "get";

                // Check if it is a boolean then the getter is 'is' not
                // 'get'
                JPrimitiveType parameterTypeIsPrimitive = parameterType.isPrimitive();
                if (parameterTypeIsPrimitive != null
                        && parameterTypeIsPrimitive.equals(JPrimitiveType.BOOLEAN)) {
                    getter = "is";
                }

                if (p.getName().equals("event")) {
                    bindingParameters.append("event");
                } else if (p.isAnnotationPresent(Attribute.class)) {
                    // Only valid for domEvents
                    if (!eventType.isAssignableTo(hasNativeEventType)) {
                        error("Attributes binding are only valid for DomEvents. Found: %s.%s in parameter: %s",
                                presenterType.getQualifiedSourceName(), name, parameter);
                    }

                    String parameterTypeQualifiedSourceName = parameterType.getQualifiedSourceName();
                    boolean isString = parameterTypeQualifiedSourceName.equals(STRINGCANONICALNAME);
                    if (!isString) {
                        bindingParameters.append(parameterTypeQualifiedSourceName + ".valueOf(");
                    }
                    bindingParameters.append("((" + Element.class.getCanonicalName()
                            + ")event.getNativeEvent().getEventTarget().cast()).getAttribute(\"" + parameter
                            + "\")");
                    if (!isString) {
                        bindingParameters.append(")");
                    }
                } else if (parameter.indexOf("$") == -1) {
                    // Event binding
                    bindingParameters.append("event.");
                    bindingParameters.append(getter);
                    bindingParameters.append(capitalize(parameter));
                    bindingParameters.append("()");
                } else {
                    // Event binding nested binding
                    String[] parameterParts = parameter.split("[$]");

                    bindingParameters.append("event");
                    for (int n = 0; n < parameterParts.length - 1; n++) {
                        bindingParameters.append(".get");
                        bindingParameters.append(capitalize(parameterParts[n]));
                        bindingParameters.append("()");
                    }

                    bindingParameters.append(".");
                    bindingParameters.append(getter);
                    bindingParameters.append(capitalize(parameterParts[parameterParts.length - 1]));
                    bindingParameters.append("()");
                }

                parameterStrings.add(bindingParameters.substring(initlenght, bindingParameters.length()));
            }

            // Get event handler name
            JClassType handlerType = getHandlerForEvent(eventType);
            if (handlerType == null) {
                error("Parameter '%s' is not an event (subclass of GwtEvent).", eventType.getName());
            }

            // Retrieves the single method (usually 'onSomething') related
            // to all
            // handlers. Ex: onClick in ClickHandler, onBlur in BlurHandler
            // ...
            JMethod[] handlerMethods = handlerType.getMethods();
            if (handlerMethods.length != 1) {
                error("'%s' has more than one method defined.", handlerType.getName());
            }

            // 'onSomething' method
            JMethod handlerOnMethod = handlerMethods[0];

            String methodName = name;
            String handlerTypeName = handlerType.getQualifiedSourceName();

            GwtPresenter presenterAnnotation = presenterType.getAnnotation(GwtPresenter.class);
            boolean isElemental = presenterAnnotation != null && presenterAnnotation.elemental();

            // Write handler
            SourceWriter eventHandlerWriter = new StringSourceWriter();
            if (!fieldsAreElements) {
                eventHandlerWriter.println("new " + handlerTypeName + "() {");
                eventHandlerWriter.indent();
                eventHandlerWriter.println("public void " + handlerOnMethod.getName() + "(final "
                        + eventType.getQualifiedSourceName() + " event) {");
                eventHandlerWriter.indent();
            } else if (isElemental) {
                eventHandlerWriter.println("new elemental.events.EventListener() {");
                eventHandlerWriter.println("  @Override");
                eventHandlerWriter.println("  public void handleEvent(elemental.events.Event event) {");
            } else {
                eventHandlerWriter
                        .println("new " + com.guit.client.dom.EventHandler.class.getCanonicalName() + "() {");
                eventHandlerWriter.indent();
                eventHandlerWriter
                        .println("public void onEvent(" + Event.class.getCanonicalName() + " event_) {");
                eventHandlerWriter.println("  " + EventImpl.class.getCanonicalName() + " event = ("
                        + EventImpl.class.getCanonicalName() + ") event_;");
                eventHandlerWriter.indent();
            }

            String bindingParametersString = bindingParameters.toString();

            // Process contributors
            BinderContextImpl binderContext = processMethodContributors(presenterType, null, null, viewTypeName,
                    m, eventType, parameterStrings.toArray(new String[parameterStrings.size()]));

            StringSourceWriter handlerWriter = new StringSourceWriter();

            handlerWriter
                    .println("if (" + LogConfiguration.class.getCanonicalName() + ".loggingIsEnabled()) {");
            handlerWriter.println(Logger.class.getCanonicalName() + ".getLogger(\"Binder\").info(\""
                    + binderContext.getLog() + "\");");
            handlerWriter.println("}");

            handlerWriter.print("presenter." + methodName + "(");
            handlerWriter.print(bindingParametersString);
            handlerWriter.println(");");

            eventHandlerWriter.println(binderContext.build(handlerWriter));

            eventHandlerWriter.outdent();
            eventHandlerWriter.println("}");
            eventHandlerWriter.outdent();
            eventHandlerWriter.print("}");

            if (fieldsAreElements) {
                if (bindingFields != null) {
                    writer.print("final "
                            + (isElemental ? EventListener.class.getCanonicalName()
                                    : com.guit.client.dom.EventHandler.class.getCanonicalName())
                            + " " + methodName + "$" + eventName + " =");
                    writer.print(eventHandlerWriter.toString());
                    writer.println(";");

                    for (String f : bindingFields) {
                        String eventNameLower = eventName.toLowerCase();
                        boolean isTouchStart = eventNameLower.equals("touchstart");
                        boolean isTouchEnd = eventNameLower.equals("touchend");
                        if (isTouchStart || isTouchEnd) {
                            writer.println("if (com.google.gwt.event.dom.client.TouchEvent.isSupported()) {");
                        }
                        if (isElemental) {
                            writer.println("presenter." + f + ".setOn" + eventNameLower + "(" + methodName + "$"
                                    + eventName + ");");
                        } else {
                            writer.println("bindings.add(new " + ElementImpl.class.getCanonicalName() + "(view."
                                    + f + ")." + eventNameLower + "(" + methodName + "$" + eventName + "));");
                        }
                        if (isTouchStart || isTouchEnd) {
                            writer.println("} else {");

                            if (isElemental) {
                                writer.println("presenter." + f + ".setOnmouse" + (isTouchStart ? "down" : "up")
                                        + "(" + methodName + "$" + eventName + ");");
                            } else {
                                writer.println("bindings.add(new " + ElementImpl.class.getCanonicalName()
                                        + "(view." + f + ")." + (isTouchStart ? "mousedown" : "mouseup") + "("
                                        + methodName + "$" + eventName + "));");
                            }

                            writer.print("}");
                        }
                    }
                }
            } else if (viewHandlerAnnotation.force()) {
                String addMethodName = "addDomHandler";
                String eventTypeGetter = eventType.getQualifiedSourceName() + ".";
                JField typeField = eventType.getField("TYPE");
                if (typeField != null && typeField.isStatic() && typeField.isPublic()) {
                    eventTypeGetter += "TYPE";
                } else {
                    eventTypeGetter += "getType()";
                }
                if (bindingFields != null) {
                    writer.print("final " + handlerTypeName + " " + methodName + " =");
                    writer.print(eventHandlerWriter.toString());
                    writer.println(";");

                    for (String f : bindingFields) {
                        writer.println("bindings.add(view." + f + "." + addMethodName + "(" + methodName + ", "
                                + eventTypeGetter + "));");
                    }
                }

                if (addHandlerToView) {
                    writer.print("bindings.add(view." + addMethodName + "(" + eventHandlerWriter.toString()
                            + ", " + eventTypeGetter + "));");
                }
            } else {
                String addMethodName = "add" + eventName.substring(0, 1).toUpperCase() + eventName.substring(1)
                        + "Handler";
                if (bindingFields != null) {
                    writer.print("final " + handlerTypeName + " " + methodName + " =");
                    writer.print(eventHandlerWriter.toString());
                    writer.println(";");

                    for (String f : bindingFields) {

                        // Small patch for touch events
                        if (addMethodName.equals("addTouchStartHandler") && parameters.length == 0) {
                            writer.println("if (!com.google.gwt.event.dom.client.TouchEvent.isSupported()) {");
                            writer.println("bindings.add(view." + f + ".addMouseDownHandler(new "
                                    + MouseDownHandler.class.getCanonicalName() + "(){public void onMouseDown("
                                    + MouseDownEvent.class.getCanonicalName() + " event){presenter."
                                    + methodName + "();} }" + "));");
                            writer.println("}");
                        }

                        if (addMethodName.equals("addTouchEndHandler") && parameters.length == 0) {
                            writer.println("if (!com.google.gwt.event.dom.client.TouchEvent.isSupported()) {");
                            writer.println("bindings.add(view." + f + ".addMouseUpHandler(new "
                                    + MouseUpHandler.class.getCanonicalName() + "(){public void onMouseUp("
                                    + MouseUpEvent.class.getCanonicalName() + " event){presenter." + methodName
                                    + "();} }" + "));");
                            writer.println("}");
                        }
                        writer.println(
                                "bindings.add(view." + f + "." + addMethodName + "(" + methodName + "));");
                    }
                }

                if (addHandlerToView) {
                    writer.print(
                            "bindings.add(view." + addMethodName + "(" + eventHandlerWriter.toString() + "));");
                }
            }
        } else {
            for (Annotation a : m.getAnnotations()) {
                Class<? extends Annotation> annotationType = a.annotationType();
                if (annotationType.isAnnotationPresent(Plugin.class)) {
                    String[] nameParts = name.split("[$]");

                    // Check that the binding fields are valid
                    StringBuilder fields = new StringBuilder();
                    for (int n = 0; n < nameParts.length - 1; n++) {
                        if (!validBindingFields.contains(nameParts[n])) {
                            error("The field %s on the class %s is not a valid binding field. It must be public or protected and not static",
                                    nameParts[n], presenterType);
                        }
                        if (fields.length() > 0) {
                            fields.append(",");
                        }
                        fields.append("view." + nameParts[n]);
                    }

                    Class<?> handler = annotationType.getAnnotation(Plugin.class).value();
                    writer.println("new " + handler.getCanonicalName()
                            + "().install(new com.google.gwt.user.client.Command() {");
                    writer.println("@Override");
                    writer.println("public void execute() {");
                    writer.println("  presenter." + m.getName() + "();");
                    writer.println("}");
                    writer.println("}, new Object[]{");
                    writer.println(fields.toString() + "});");
                }
            }
        }
    }
}

From source file:com.guit.rebind.jsorm.JsonSerializerUtil.java

License:Apache License

private static void printPrimitiveDeserialized(String typeName, SourceWriter writer, String fieldName,
        JPrimitiveType primitive) throws UnableToCompleteException {
    if (primitive.equals(JPrimitiveType.BOOLEAN)) {
        writer.println(fieldName + ".isBoolean().booleanValue()");
    } else if (primitive.equals(JPrimitiveType.DOUBLE)) {
        writer.println(fieldName + ".isNumber().doubleValue()");
    } else if (primitive.equals(JPrimitiveType.FLOAT)) {
        writer.println("(float)" + fieldName + ".isNumber().doubleValue()");
    } else if (primitive.equals(JPrimitiveType.LONG)) {
        writer.println("(long)" + fieldName + ".isNumber().doubleValue()");
    } else if (primitive.equals(JPrimitiveType.INT)) {
        writer.println("(int)" + fieldName + ".isNumber().doubleValue()");
    } else {/*from   www .  ja v  a2  s .  c  o  m*/
        error("The type %s is not a valid type for the place data. Found %s", primitive.getSimpleSourceName(),
                typeName);
    }
}

From source file:com.guit.rebind.jsorm.JsonSerializerUtil.java

License:Apache License

private static void printPrimitiveSerialized(String typeName, SourceWriter writer, String fieldName,
        JPrimitiveType primitive) throws UnableToCompleteException {
    if (primitive.equals(JPrimitiveType.BOOLEAN)) {
        writer.print(JSONBoolean.class.getCanonicalName() + ".getInstance(" + fieldName + ")");
    } else if (primitive.equals(JPrimitiveType.DOUBLE)) {
        writer.print("new " + JSONNumber.class.getCanonicalName() + "(" + fieldName + ")");
    } else if (primitive.equals(JPrimitiveType.FLOAT)) {
        writer.print("new " + JSONNumber.class.getCanonicalName() + "(" + fieldName + ")");
    } else if (primitive.equals(JPrimitiveType.LONG)) {
        writer.print("new " + JSONNumber.class.getCanonicalName() + "(" + fieldName + ")");
    } else if (primitive.equals(JPrimitiveType.INT)) {
        writer.print("new " + JSONNumber.class.getCanonicalName() + "(" + fieldName + ")");
    } else {//from w  ww  . j  a v a  2s .  co m
        error("The type %s is not a valid type for the place data. Found %s", primitive.getSimpleSourceName(),
                typeName);
    }
}

From source file:com.gwtmobile.persistence.rebind.GenUtils.java

License:Apache License

public String getSQLiteType(JType returnType) {
    String sqliteType = null;/*  w w  w .j  a v a  2 s . c  om*/
    JPrimitiveType primitiveReturnType = returnType.isPrimitive();
    if (primitiveReturnType != null) {
        if (primitiveReturnType == JPrimitiveType.INT) {
            sqliteType = "INTEGER";
        } else if (primitiveReturnType == JPrimitiveType.BOOLEAN) {
            sqliteType = "BOOL";
        } else {
            sqliteType = primitiveReturnType.getSimpleSourceName().toUpperCase();
        }
    } else {
        String returnTypeName = returnType.getSimpleSourceName();
        if (returnTypeName.equals("String")) {
            sqliteType = "TEXT";
        } else if (isSubclassOf(returnType, "JSONValue")) {
            sqliteType = "JSON";
        } else {
            sqliteType = returnTypeName.toUpperCase();
        }
    }
    return sqliteType;
}

From source file:com.hiramchirino.restygwt.rebind.JsonEncoderDecoderClassCreator.java

License:Apache License

/**
 * //from www  .  j  ava 2 s .c  o  m
 * @param field
 * @return the name for the getter for the specified field or null if a getter can't be found.
 */
private String getGetterName(JField field) {
    String fieldName = field.getName();
    JType booleanType = null;
    try {
        booleanType = find(Boolean.class);
    } catch (UnableToCompleteException e) {
        //do nothing
    }
    if (field.getType().equals(JPrimitiveType.BOOLEAN) || field.getType().equals(booleanType)) {
        fieldName = "is" + upperCaseFirstChar(fieldName);
    } else {
        fieldName = "get" + upperCaseFirstChar(fieldName);
    }
    JClassType type = field.getEnclosingType();
    if (exists(type, field, fieldName, false)) {
        return fieldName;
    } else {
        return null;
    }
}

From source file:com.hiramchirino.restygwt.rebind.JsonEncoderDecoderInstanceLocator.java

License:Apache License

public JsonEncoderDecoderInstanceLocator(GeneratorContext context, TreeLogger logger)
        throws UnableToCompleteException {
    this.context = context;
    this.logger = logger;

    this.STRING_TYPE = find(String.class);
    this.JSON_VALUE_TYPE = find(JSONValue.class);
    this.DOCUMENT_TYPE = find(Document.class);
    this.MAP_TYPE = find(Map.class);
    this.SET_TYPE = find(Set.class);
    this.LIST_TYPE = find(List.class);

    builtInEncoderDecoders.put(JPrimitiveType.BOOLEAN, JSON_ENCODER_DECODER_CLASS + ".BOOLEAN");
    builtInEncoderDecoders.put(JPrimitiveType.BYTE, JSON_ENCODER_DECODER_CLASS + ".BYTE");
    builtInEncoderDecoders.put(JPrimitiveType.CHAR, JSON_ENCODER_DECODER_CLASS + ".CHAR");
    builtInEncoderDecoders.put(JPrimitiveType.SHORT, JSON_ENCODER_DECODER_CLASS + ".SHORT");
    builtInEncoderDecoders.put(JPrimitiveType.INT, JSON_ENCODER_DECODER_CLASS + ".INT");
    builtInEncoderDecoders.put(JPrimitiveType.LONG, JSON_ENCODER_DECODER_CLASS + ".LONG");
    builtInEncoderDecoders.put(JPrimitiveType.FLOAT, JSON_ENCODER_DECODER_CLASS + ".FLOAT");
    builtInEncoderDecoders.put(JPrimitiveType.DOUBLE, JSON_ENCODER_DECODER_CLASS + ".DOUBLE");
    builtInEncoderDecoders.put(find(Boolean.class), JSON_ENCODER_DECODER_CLASS + ".BOOLEAN");
    builtInEncoderDecoders.put(find(Byte.class), JSON_ENCODER_DECODER_CLASS + ".BYTE");
    builtInEncoderDecoders.put(find(Character.class), JSON_ENCODER_DECODER_CLASS + ".CHAR");
    builtInEncoderDecoders.put(find(Short.class), JSON_ENCODER_DECODER_CLASS + ".SHORT");
    builtInEncoderDecoders.put(find(Integer.class), JSON_ENCODER_DECODER_CLASS + ".INT");
    builtInEncoderDecoders.put(find(Long.class), JSON_ENCODER_DECODER_CLASS + ".LONG");
    builtInEncoderDecoders.put(find(Float.class), JSON_ENCODER_DECODER_CLASS + ".FLOAT");
    builtInEncoderDecoders.put(find(Double.class), JSON_ENCODER_DECODER_CLASS + ".DOUBLE");

    builtInEncoderDecoders.put(STRING_TYPE, JSON_ENCODER_DECODER_CLASS + ".STRING");
    builtInEncoderDecoders.put(DOCUMENT_TYPE, JSON_ENCODER_DECODER_CLASS + ".DOCUMENT");
    builtInEncoderDecoders.put(JSON_VALUE_TYPE, JSON_ENCODER_DECODER_CLASS + ".JSON_VALUE");

    builtInEncoderDecoders.put(find(Date.class), JSON_ENCODER_DECODER_CLASS + ".DATE");

}