Java JsPlainObj类代码示例

import gwt.interop.utils.client.plainobjects.JsPlainObj; //导入依赖的package包/类
public void testInitPlainObjectAllPrimitiveTypes() {
    JsPlainObj o1 = $jsPlainObj(
            "a", 1,
            "a1", Integer.valueOf(1),
            "b", 10.1,
            "b1", Double.valueOf(10.1),
            "c", true,
            "c1", Boolean.valueOf(true),
            "d","stringvalue"
            );
    assertEquals(o1.toJSONString(), "{\"a\":1,\"a1\":1,\"b\":10.1,\"b1\":10.1,\"c\":true,\"c1\":true,\"d\":\"stringvalue\"}");
}
 

import gwt.interop.utils.client.plainobjects.JsPlainObj; //导入依赖的package包/类
public void testConstructPlainObject() {
    JsPlainObj o2 = new JsPlainObj();
    o2.set("b", 2);
    o2.set("d", 3);

    assertEquals(o2.toJSONString(), "{\"b\":2,\"d\":3}");
}
 

import gwt.interop.utils.client.plainobjects.JsPlainObj; //导入依赖的package包/类
public void testMerge() {
    JsPlainObj o1 = $jsPlainObj("a", 1, "b", 10, "c", 20);
    JsPlainObj o2 = $jsPlainObj("b", 2, "d", 3);
    JsPlainObj o3 = o1.merge(o2);

    assertEquals(o3.toJSONString(), "{\"a\":1,\"b\":2,\"c\":20,\"d\":3}");
}
 

import gwt.interop.utils.client.plainobjects.JsPlainObj; //导入依赖的package包/类
public void testInitPlainObject() {
    JsPlainObj o1 = $jsPlainObj("a", 1, "b", 10, "c", 20);
    assertEquals(o1.toJSONString(), "{\"a\":1,\"b\":10,\"c\":20}");
}
 

import gwt.interop.utils.client.plainobjects.JsPlainObj; //导入依赖的package包/类
public void testInitPlainObjectWithSuppliedObject() {
    JsPlainObj o1 = $(new JsPlainObj(), "a", 2, "b", 20, "c", 30);

    assertEquals(o1.toJSONString(), "{\"a\":2,\"b\":20,\"c\":30}");
}
 

import gwt.interop.utils.client.plainobjects.JsPlainObj; //导入依赖的package包/类
public void testExcept() {
    JsPlainObj o1 = $jsPlainObj("a", 1, "b", 10, "c", 20);

    JsPlainObj o2 = o1.except("a","c");
    assertEquals(o2.toJSONString(), "{\"b\":10}");
}
 

import gwt.interop.utils.client.plainobjects.JsPlainObj; //导入依赖的package包/类
@JsOverlay public final void setDangerouslyInnerHTML(String __html) {
    JsPlainObj o = new JsPlainObj();
    o.set("__html", __html);
    setDangerouslySetInnerHTML(o);
}
 

import gwt.interop.utils.client.plainobjects.JsPlainObj; //导入依赖的package包/类
@JsOverlay
public static <P extends BaseProps, S extends JsPlainObj, T extends Component<P, S>> ReactElement<P, T> createElement(Class<T> type, P props, String value) {
    return createElement(ComponentUtils.getCtorFn(type), props, value);
}
 

import gwt.interop.utils.client.plainobjects.JsPlainObj; //导入依赖的package包/类
/**
 * <p>Clone and return a new ReactElement using element as the starting point. The resulting
 * element will have the original element's props with the new props merged in shallowly.
 * New children will replace existing children. Unlike React.addons.cloneWithProps, key and
 * ref from the original element will be preserved. There is no special behavior for merging
 * any props (unlike cloneWithProps). See the v0.13 RC2 blog post for additional details.</p>
 *
 * @param element the element to clone
 * @param props the props to merge
 * @return the cloned element
 */
public static native <P extends BaseProps, T> ReactElement<P, T> cloneElement(ReactElement<P, T> element, JsPlainObj props);
 

import gwt.interop.utils.client.plainobjects.JsPlainObj; //导入依赖的package包/类
/**
 * Given the Class of a JsType annotated {@link Component} class, return the constructor function to use in Javascript
 * @param cls The Class
 * @param <P> The type of props the {@link Component} supports
 * @param <S> The type of state the {@link Component} supports
 * @param <T> The type of {@link Component}
 * @return The constructor function
 */
public static native <P extends BaseProps, S extends JsPlainObj, T extends Component<P, S>> ComponentConstructorFn<P> getCtorFn(Class<T> cls) /*-{
    return [email protected]::jsConstructor;
}-*/;
 

import gwt.interop.utils.client.plainobjects.JsPlainObj; //导入依赖的package包/类
/**
 * The observer function can be used to turn ReactJS components into reactive components. It
 * wraps the component's render function in mobx.autorun to make sure that any data that is
 * used during the rendering of a component forces a re-rendering upon change.
 *
 * <p>Tip: when observer needs to be combined with other higher-order-components, make sure
 * that observer is the innermost (first applied) function; otherwise it might do nothing
 * at all.</p>
 *
 * @param type The react Component class to make an observer
 * @param <P> The prop types
 * @return A wrapped Component class
 */
@JsOverlay
public static <P extends BaseProps, S extends JsPlainObj, T extends Component<P, S>> ComponentConstructorFn<P> observer(Class<T> type) {
    return observer(ComponentUtils.getCtorFn(type));
}
 

import gwt.interop.utils.client.plainobjects.JsPlainObj; //导入依赖的package包/类
/**
 * Makes the supplied Object Literal observable.
 *
 * MobX will recursively pass all the supplied object literal values through observable.
 * This way the complete object (tree) is in-place instrumented to make it observable
 *
 * @param jsPlainObj The object to make observable
 * @param <O> A subclass of JsPlainObj
 * @return An augmented version of the supplied object that will update any views that depend
 *         on it.
 */
public static native <O extends JsPlainObj> O observable(O jsPlainObj);
 

import gwt.interop.utils.client.plainobjects.JsPlainObj; //导入依赖的package包/类
/**
 * Recursively converts an ObservableArray object to a JSON structure. Supports observable
 * arrays, objects, maps and primitives. Computed values and other non-enumerable
 * properties won't be part of the result. Cycles are supported by default, but this
 * can be disabled to improve performance.
 *
 * @param array         The ObservableArray to convert
 * @param supportCycles True to support cyclic structures
 * @param <O> The JSON literal
 * @return A JSON structure
 */
public static native <O extends JsPlainObj> O toJSON(ObservableArray<?> array, boolean supportCycles);
 

import gwt.interop.utils.client.plainobjects.JsPlainObj; //导入依赖的package包/类
public native static <STATE, A extends Action> Reducer<STATE, A> combineReducers(JsPlainObj reducersLiteral); 

import gwt.interop.utils.client.plainobjects.JsPlainObj; //导入依赖的package包/类
JsPlainObj mapProps(S state, P ownProps);