Change-Id: I4809fbbdb48f3e36c8e1da8552ff3fa734714105tags/7.4.0.beta1
@@ -31,9 +31,10 @@ import java.util.Locale; | |||
import java.util.ResourceBundle; | |||
import java.util.prefs.Preferences; | |||
import elemental.json.JsonException; | |||
import elemental.json.JsonObject; | |||
import elemental.json.impl.JsonUtil; | |||
import org.apache.commons.io.IOUtils; | |||
import org.json.JSONException; | |||
import org.json.JSONObject; | |||
/** | |||
* This class is able to validate the vaadin CVAL license. | |||
@@ -58,9 +59,9 @@ public final class CvalChecker { | |||
public static class CvalInfo { | |||
public static class Product { | |||
private JSONObject o; | |||
private JsonObject o; | |||
public Product(JSONObject o) { | |||
public Product(JsonObject o) { | |||
this.o = o; | |||
} | |||
@@ -74,40 +75,32 @@ public final class CvalChecker { | |||
} | |||
@SuppressWarnings("unchecked") | |||
private static <T> T get(JSONObject o, String k, Class<T> clz) { | |||
private static <T> T get(JsonObject o, String k, Class<T> clz) { | |||
Object ret = null; | |||
try { | |||
if (clz == String.class) { | |||
ret = o.getString(k); | |||
} else if (clz == JSONObject.class) { | |||
ret = o.getJSONObject(k); | |||
} else if (clz == JsonObject.class) { | |||
ret = o.getObject(k); | |||
} else if (clz == Integer.class) { | |||
ret = o.getInt(k); | |||
ret = Integer.valueOf((int) o.getNumber(k)); | |||
} else if (clz == Date.class) { | |||
ret = new Date(o.getLong(k)); | |||
ret = new Date((long) o.getNumber(k)); | |||
} else if (clz == Boolean.class) { | |||
ret = o.getBoolean(k); | |||
} | |||
} catch (JSONException e) { | |||
} catch (JsonException e) { | |||
} | |||
return (T) ret; | |||
} | |||
private static <T> T put(JSONObject o, String k, Object v) { | |||
try { | |||
o.put(k, v); | |||
} catch (JSONException e) { | |||
} | |||
return null; | |||
} | |||
private JSONObject o; | |||
private JsonObject o; | |||
private Product product; | |||
public CvalInfo(JSONObject o) { | |||
public CvalInfo(JsonObject o) { | |||
this.o = o; | |||
product = new Product(get(o, "product", JSONObject.class)); | |||
product = new Product(get(o, "product", JsonObject.class)); | |||
} | |||
public Boolean getExpired() { | |||
@@ -139,11 +132,11 @@ public final class CvalChecker { | |||
} | |||
public void setExpiredEpoch(Date expiredEpoch) { | |||
put(o, "expiredEpoch", expiredEpoch.getTime()); | |||
o.put("expiredEpoch", expiredEpoch.getTime()); | |||
} | |||
public void setMessage(String msg) { | |||
put(o, "message", msg); | |||
o.put("message", msg); | |||
} | |||
@Override | |||
@@ -327,9 +320,9 @@ public final class CvalChecker { | |||
return null; | |||
} | |||
try { | |||
JSONObject o = new JSONObject(json); | |||
JsonObject o = JsonUtil.parse(json); | |||
return new CvalInfo(o); | |||
} catch (JSONException e) { | |||
} catch (JsonException e) { | |||
return null; | |||
} | |||
} |
@@ -182,6 +182,13 @@ | |||
<include name="com/google/gwt/user/client/rpc/IsSerializable.*" /> | |||
</fileset> | |||
<!-- GWT Elemental --> | |||
<fileset dir="${gwt.elemental.jar.files}"> | |||
<include name="elemental/util/Array*" /> | |||
<include name="elemental/util/Can*" /> | |||
<include name="elemental/util/Map*" /> | |||
<include name="elemental/json/**" /> | |||
</fileset> | |||
</union> | |||
<union id="server.gwt.includes"> | |||
@@ -189,5 +196,10 @@ | |||
<!-- Server files from gwt-user --> | |||
<include name="com/google/gwt/*/server/**" /> | |||
</fileset> | |||
<!-- GWT Elemental --> | |||
<fileset dir="${gwt.elemental.jar.files}"> | |||
<exclude name="META-INF/**" /> | |||
<exclude name="super/**" /> | |||
</fileset> | |||
</union> | |||
</project> |
@@ -25,6 +25,6 @@ | |||
<dependency org="com.vaadin.external.gwt" name="gwt-dev" rev="${gwt.version}" conf="gwt-dev,ide->default" /> | |||
<dependency org="com.vaadin.external.gwt" name="gwt-user" rev="${gwt.version}" conf="gwt-user,ide->default" /> | |||
<dependency org="com.vaadin.external.gwt" name="gwt-codeserver" rev="${gwt.version}" conf="gwt-codeserver,ide->default" /> | |||
<dependency org="com.vaadin.external.gwt" name="gwt-elemental" rev="${gwt.version}" conf="gwt-elemental->default" /> | |||
<dependency org="com.vaadin.external.gwt" name="gwt-elemental" rev="${gwt.version}" conf="gwt-elemental,ide->default" /> | |||
</dependencies> | |||
</ivy-module> |
@@ -32,9 +32,6 @@ import java.util.Map; | |||
import java.util.NoSuchElementException; | |||
import java.util.logging.Logger; | |||
import org.json.JSONException; | |||
import org.json.JSONObject; | |||
import com.vaadin.event.EventRouter; | |||
import com.vaadin.event.MethodEventSource; | |||
import com.vaadin.shared.communication.ClientRpc; | |||
@@ -46,6 +43,7 @@ import com.vaadin.ui.Component.Event; | |||
import com.vaadin.ui.HasComponents; | |||
import com.vaadin.ui.LegacyComponent; | |||
import com.vaadin.ui.UI; | |||
import elemental.json.JsonObject; | |||
/** | |||
* An abstract base class for ClientConnector implementations. This class | |||
@@ -243,7 +241,7 @@ public abstract class AbstractClientConnector implements ClientConnector, | |||
} | |||
@Override | |||
public JSONObject encodeState() throws JSONException { | |||
public JsonObject encodeState() { | |||
return LegacyCommunicationManager.encodeState(this, getState(false)); | |||
} | |||
@@ -30,8 +30,6 @@ import java.util.Set; | |||
import javax.servlet.http.HttpServletResponse; | |||
import org.json.JSONException; | |||
import org.json.JSONObject; | |||
import org.jsoup.nodes.DataNode; | |||
import org.jsoup.nodes.Document; | |||
import org.jsoup.nodes.DocumentType; | |||
@@ -44,6 +42,11 @@ import com.vaadin.shared.Version; | |||
import com.vaadin.shared.communication.PushMode; | |||
import com.vaadin.ui.UI; | |||
import elemental.json.Json; | |||
import elemental.json.JsonException; | |||
import elemental.json.JsonObject; | |||
import elemental.json.impl.JsonUtil; | |||
/** | |||
* | |||
* @author Vaadin Ltd | |||
@@ -191,7 +194,7 @@ public abstract class BootstrapHandler extends SynchronizedRequestHandler { | |||
String html = getBootstrapHtml(context); | |||
writeBootstrapPage(response, html); | |||
} catch (JSONException e) { | |||
} catch (JsonException e) { | |||
writeError(response, e); | |||
} | |||
@@ -340,10 +343,8 @@ public abstract class BootstrapHandler extends SynchronizedRequestHandler { | |||
* @param context | |||
* | |||
* @throws IOException | |||
* @throws JSONException | |||
*/ | |||
private void setupMainDiv(BootstrapContext context) throws IOException, | |||
JSONException { | |||
private void setupMainDiv(BootstrapContext context) throws IOException { | |||
String style = getMainDivStyle(context); | |||
/*- Add classnames; | |||
@@ -399,8 +400,8 @@ public abstract class BootstrapHandler extends SynchronizedRequestHandler { | |||
StringBuilder builder = new StringBuilder(); | |||
builder.append("//<![CDATA[\n"); | |||
builder.append("if (!window.vaadin) alert(" | |||
+ JSONObject.quote("Failed to load the bootstrap javascript: " | |||
+ bootstrapLocation) + ");\n"); | |||
+ JsonUtil.quote("Failed to load the bootstrap javascript: " | |||
+ bootstrapLocation) + ");\n"); | |||
appendMainScriptTagContents(context, builder); | |||
@@ -412,8 +413,8 @@ public abstract class BootstrapHandler extends SynchronizedRequestHandler { | |||
} | |||
protected void appendMainScriptTagContents(BootstrapContext context, | |||
StringBuilder builder) throws JSONException, IOException { | |||
JSONObject appConfig = getApplicationParameters(context); | |||
StringBuilder builder) throws IOException { | |||
JsonObject appConfig = getApplicationParameters(context); | |||
boolean isDebug = !context.getSession().getConfiguration() | |||
.isProductionMode(); | |||
@@ -438,21 +439,21 @@ public abstract class BootstrapHandler extends SynchronizedRequestHandler { | |||
} | |||
private static void appendJsonObject(StringBuilder builder, | |||
JSONObject jsonObject, boolean isDebug) throws JSONException { | |||
JsonObject jsonObject, boolean isDebug) { | |||
if (isDebug) { | |||
builder.append(jsonObject.toString(4)); | |||
builder.append(JsonUtil.stringify(jsonObject, 4)); | |||
} else { | |||
builder.append(jsonObject.toString()); | |||
builder.append(JsonUtil.stringify(jsonObject)); | |||
} | |||
} | |||
protected JSONObject getApplicationParameters(BootstrapContext context) | |||
throws JSONException, PaintException { | |||
protected JsonObject getApplicationParameters(BootstrapContext context) | |||
throws PaintException { | |||
VaadinRequest request = context.getRequest(); | |||
VaadinSession session = context.getSession(); | |||
VaadinService vaadinService = request.getService(); | |||
JSONObject appConfig = new JSONObject(); | |||
JsonObject appConfig = Json.createObject(); | |||
String themeName = context.getThemeName(); | |||
if (themeName != null) { | |||
@@ -465,7 +466,7 @@ public abstract class BootstrapHandler extends SynchronizedRequestHandler { | |||
appConfig.put("extraParams", "&" + IGNORE_RESTART_PARAM + "=1"); | |||
} | |||
JSONObject versionInfo = new JSONObject(); | |||
JsonObject versionInfo = Json.createObject(); | |||
versionInfo.put("vaadinVersion", Version.getFullVersion()); | |||
appConfig.put("versionInfo", versionInfo); | |||
@@ -479,30 +480,42 @@ public abstract class BootstrapHandler extends SynchronizedRequestHandler { | |||
request); | |||
if (systemMessages != null) { | |||
// Write the CommunicationError -message to client | |||
JSONObject comErrMsg = new JSONObject(); | |||
JsonObject comErrMsg = Json.createObject(); | |||
comErrMsg.put("caption", | |||
systemMessages.getCommunicationErrorCaption()); | |||
comErrMsg.put("message", | |||
systemMessages.getCommunicationErrorMessage()); | |||
comErrMsg.put("url", systemMessages.getCommunicationErrorURL()); | |||
if (systemMessages.getCommunicationErrorURL() == null) { | |||
comErrMsg.put("url", Json.createNull()); | |||
} else { | |||
comErrMsg.put("url", systemMessages.getCommunicationErrorURL()); | |||
} | |||
appConfig.put("comErrMsg", comErrMsg); | |||
JSONObject authErrMsg = new JSONObject(); | |||
JsonObject authErrMsg = Json.createObject(); | |||
authErrMsg.put("caption", | |||
systemMessages.getAuthenticationErrorCaption()); | |||
authErrMsg.put("message", | |||
systemMessages.getAuthenticationErrorMessage()); | |||
authErrMsg.put("url", systemMessages.getAuthenticationErrorURL()); | |||
if (systemMessages.getAuthenticationErrorURL() == null) { | |||
authErrMsg.put("url", Json.createNull()); | |||
} else { | |||
authErrMsg.put("url", systemMessages.getAuthenticationErrorURL()); | |||
} | |||
appConfig.put("authErrMsg", authErrMsg); | |||
JSONObject sessExpMsg = new JSONObject(); | |||
JsonObject sessExpMsg = Json.createObject(); | |||
sessExpMsg | |||
.put("caption", systemMessages.getSessionExpiredCaption()); | |||
sessExpMsg | |||
.put("message", systemMessages.getSessionExpiredMessage()); | |||
sessExpMsg.put("url", systemMessages.getSessionExpiredURL()); | |||
if (systemMessages.getSessionExpiredURL() == null) { | |||
sessExpMsg.put("url", Json.createNull()); | |||
} else { | |||
sessExpMsg.put("url", systemMessages.getSessionExpiredURL()); | |||
} | |||
appConfig.put("sessExpMsg", sessExpMsg); | |||
} |
@@ -20,15 +20,13 @@ import java.lang.reflect.Method; | |||
import java.util.Collection; | |||
import java.util.List; | |||
import org.json.JSONException; | |||
import org.json.JSONObject; | |||
import com.vaadin.event.ConnectorEvent; | |||
import com.vaadin.event.ConnectorEventListener; | |||
import com.vaadin.shared.Connector; | |||
import com.vaadin.shared.communication.SharedState; | |||
import com.vaadin.ui.UI; | |||
import com.vaadin.util.ReflectTools; | |||
import elemental.json.JsonObject; | |||
/** | |||
* Interface implemented by all connectors that are capable of communicating | |||
@@ -279,10 +277,9 @@ public interface ClientConnector extends Connector { | |||
* . | |||
* | |||
* @return a JSON object with the encoded connector state | |||
* @throws JSONException | |||
* if the state can not be encoded | |||
*/ | |||
public JSONObject encodeState() throws JSONException; | |||
public JsonObject encodeState() ; | |||
/** | |||
* Handle a request directed to this connector. This can be used by |
@@ -23,8 +23,9 @@ import java.io.Serializable; | |||
import java.lang.reflect.Method; | |||
import java.lang.reflect.Type; | |||
import org.json.JSONArray; | |||
import org.json.JSONException; | |||
import elemental.json.JsonArray; | |||
import elemental.json.JsonException; | |||
import elemental.json.impl.JsonUtil; | |||
/** | |||
* Internal class for keeping track of pending server to client method | |||
@@ -107,8 +108,8 @@ public class ClientMethodInvocation implements Serializable, | |||
Type type = parameterTypes[i]; | |||
if (type instanceof Class<?>) { | |||
Class<?> clazz = (Class<?>) type; | |||
if (JSONArray.class.isAssignableFrom(clazz)) { | |||
parameters[i] = ((JSONArray) parameters[i]).toString(); | |||
if (JsonArray.class.isAssignableFrom(clazz)) { | |||
parameters[i] = JsonUtil.stringify((JsonArray) parameters[i]); | |||
} | |||
} | |||
} | |||
@@ -124,10 +125,10 @@ public class ClientMethodInvocation implements Serializable, | |||
Type type = parameterTypes[i]; | |||
if (type instanceof Class<?>) { | |||
Class<?> clazz = (Class<?>) type; | |||
if (JSONArray.class.isAssignableFrom(clazz)) { | |||
if (JsonArray.class.isAssignableFrom(clazz)) { | |||
try { | |||
parameters[i] = new JSONArray(((String) parameters[i])); | |||
} catch (JSONException e) { | |||
parameters[i] = JsonUtil.<JsonArray>parse((String) parameters[i]); | |||
} catch (JsonException e) { | |||
throw new IOException(e); | |||
} | |||
} |
@@ -24,9 +24,6 @@ import java.util.Map; | |||
import java.util.logging.Level; | |||
import java.util.logging.Logger; | |||
import org.json.JSONException; | |||
import org.json.JSONObject; | |||
import com.vaadin.event.Transferable; | |||
import com.vaadin.event.TransferableImpl; | |||
import com.vaadin.event.dd.DragAndDropEvent; | |||
@@ -41,6 +38,7 @@ import com.vaadin.shared.communication.SharedState; | |||
import com.vaadin.shared.ui.dd.DragEventType; | |||
import com.vaadin.ui.Component; | |||
import com.vaadin.ui.UI; | |||
import elemental.json.JsonObject; | |||
public class DragAndDropService implements VariableOwner, ClientConnector { | |||
@@ -352,7 +350,7 @@ public class DragAndDropService implements VariableOwner, ClientConnector { | |||
} | |||
@Override | |||
public JSONObject encodeState() throws JSONException { | |||
public JsonObject encodeState() { | |||
// TODO Auto-generated method stub | |||
return null; | |||
} |
@@ -18,29 +18,31 @@ package com.vaadin.server; | |||
import java.io.Serializable; | |||
import elemental.json.JsonValue; | |||
public class EncodeResult implements Serializable { | |||
private final Object encodedValue; | |||
private final Object diff; | |||
private final JsonValue encodedValue; | |||
private final JsonValue diff; | |||
public EncodeResult(Object encodedValue) { | |||
public EncodeResult(JsonValue encodedValue) { | |||
this(encodedValue, null); | |||
} | |||
public EncodeResult(Object encodedValue, Object diff) { | |||
public EncodeResult(JsonValue encodedValue, JsonValue diff) { | |||
this.encodedValue = encodedValue; | |||
this.diff = diff; | |||
} | |||
public Object getEncodedValue() { | |||
public JsonValue getEncodedValue() { | |||
return encodedValue; | |||
} | |||
public Object getDiff() { | |||
public JsonValue getDiff() { | |||
return diff; | |||
} | |||
public Object getDiffOrValue() { | |||
Object diff = getDiff(); | |||
public JsonValue getDiffOrValue() { | |||
JsonValue diff = getDiff(); | |||
if (diff != null) { | |||
return diff; | |||
} else { |
@@ -18,21 +18,20 @@ package com.vaadin.server; | |||
import java.io.Serializable; | |||
import java.lang.reflect.Method; | |||
import java.util.Arrays; | |||
import java.util.HashMap; | |||
import java.util.HashSet; | |||
import java.util.Map; | |||
import java.util.Set; | |||
import org.json.JSONArray; | |||
import org.json.JSONException; | |||
import com.vaadin.shared.JavaScriptConnectorState; | |||
import com.vaadin.ui.AbstractJavaScriptComponent; | |||
import com.vaadin.ui.JavaScript.JavaScriptCallbackRpc; | |||
import com.vaadin.ui.JavaScriptFunction; | |||
import com.vaadin.util.ReflectTools; | |||
import elemental.json.JsonArray; | |||
import elemental.json.JsonException; | |||
/** | |||
* Internal helper class used to implement functionality common to | |||
* {@link AbstractJavaScriptComponent} and {@link AbstractJavaScriptExtension}. | |||
@@ -47,7 +46,7 @@ import com.vaadin.util.ReflectTools; | |||
public class JavaScriptCallbackHelper implements Serializable { | |||
private static final Method CALL_METHOD = ReflectTools.findMethod( | |||
JavaScriptCallbackRpc.class, "call", String.class, JSONArray.class); | |||
JavaScriptCallbackRpc.class, "call", String.class, JsonArray.class); | |||
private AbstractClientConnector connector; | |||
private Map<String, JavaScriptFunction> callbacks = new HashMap<String, JavaScriptFunction>(); | |||
@@ -75,11 +74,11 @@ public class JavaScriptCallbackHelper implements Serializable { | |||
if (javascriptCallbackRpc == null) { | |||
javascriptCallbackRpc = new JavaScriptCallbackRpc() { | |||
@Override | |||
public void call(String name, JSONArray arguments) { | |||
public void call(String name, JsonArray arguments) { | |||
JavaScriptFunction callback = callbacks.get(name); | |||
try { | |||
callback.call(arguments); | |||
} catch (JSONException e) { | |||
} catch (JsonException e) { | |||
throw new IllegalArgumentException(e); | |||
} | |||
} | |||
@@ -95,7 +94,7 @@ public class JavaScriptCallbackHelper implements Serializable { | |||
+ name | |||
+ " on the client because a callback with the same name is registered on the server."); | |||
} | |||
JSONArray args = new JSONArray(Arrays.asList(arguments)); | |||
JsonArray args = (JsonArray) JsonCodec.encode(arguments, null, Object[].class, null).getEncodedValue(); | |||
connector.addMethodInvocationToQueue( | |||
JavaScriptCallbackRpc.class.getName(), CALL_METHOD, | |||
new Object[] { name, args }); |
@@ -28,12 +28,10 @@ import java.lang.reflect.Modifier; | |||
import java.lang.reflect.ParameterizedType; | |||
import java.lang.reflect.Type; | |||
import java.util.ArrayList; | |||
import java.util.Arrays; | |||
import java.util.Collection; | |||
import java.util.Date; | |||
import java.util.HashMap; | |||
import java.util.HashSet; | |||
import java.util.Iterator; | |||
import java.util.List; | |||
import java.util.Map; | |||
import java.util.Map.Entry; | |||
@@ -41,18 +39,24 @@ import java.util.Set; | |||
import java.util.concurrent.ConcurrentHashMap; | |||
import java.util.concurrent.ConcurrentMap; | |||
import org.json.JSONArray; | |||
import org.json.JSONException; | |||
import org.json.JSONObject; | |||
import com.vaadin.server.communication.DateSerializer; | |||
import com.vaadin.server.communication.JSONSerializer; | |||
import com.vaadin.server.communication.JsonSerializer; | |||
import com.vaadin.shared.Connector; | |||
import com.vaadin.shared.JsonConstants; | |||
import com.vaadin.shared.communication.UidlValue; | |||
import com.vaadin.ui.Component; | |||
import com.vaadin.ui.ConnectorTracker; | |||
import elemental.json.Json; | |||
import elemental.json.JsonArray; | |||
import elemental.json.JsonException; | |||
import elemental.json.JsonNull; | |||
import elemental.json.JsonObject; | |||
import elemental.json.JsonString; | |||
import elemental.json.JsonType; | |||
import elemental.json.JsonValue; | |||
import elemental.json.impl.JreJsonArray; | |||
/** | |||
* Decoder for converting RPC parameters and other values from JSON in transfer | |||
* between the client and the server and vice versa. | |||
@@ -62,21 +66,32 @@ import com.vaadin.ui.ConnectorTracker; | |||
public class JsonCodec implements Serializable { | |||
/* Immutable Encode Result representing null */ | |||
private static final EncodeResult ENCODE_RESULT_NULL = new EncodeResult( | |||
JSONObject.NULL); | |||
private static final EncodeResult ENCODE_RESULT_NULL = new EncodeResult(Json.createNull()); | |||
/* Immutable empty JSONArray */ | |||
private static final JSONArray EMPTY_JSON_ARRAY = new JSONArray() { | |||
private static final JsonArray EMPTY_JSON_ARRAY = new JreJsonArray(Json.instance()) { | |||
@Override | |||
public JSONArray put(Object value) { | |||
public void set(int index, JsonValue value) { | |||
throw new UnsupportedOperationException( | |||
"Immutable empty JSONArray."); | |||
"Immutable empty JsonArray."); | |||
} | |||
@Override | |||
public JSONArray put(int index, Object value) { | |||
public void set(int index, String string) { | |||
throw new UnsupportedOperationException( | |||
"Immutable empty JSONArray."); | |||
"Immutable empty JsonArray."); | |||
} | |||
@Override | |||
public void set(int index, double number) { | |||
throw new UnsupportedOperationException( | |||
"Immutable empty JsonArray."); | |||
} | |||
@Override | |||
public void set(int index, boolean bool) { | |||
throw new UnsupportedOperationException( | |||
"Immutable empty JsonArray."); | |||
} | |||
}; | |||
@@ -197,7 +212,7 @@ public class JsonCodec implements Serializable { | |||
*/ | |||
private static Map<String, Class<?>> transportTypeToType = new HashMap<String, Class<?>>(); | |||
private static Map<Class<?>, JSONSerializer<?>> customSerializers = new HashMap<Class<?>, JSONSerializer<?>>(); | |||
private static Map<Class<?>, JsonSerializer<?>> customSerializers = new HashMap<Class<?>, JsonSerializer<?>>(); | |||
static { | |||
customSerializers.put(Date.class, new DateSerializer()); | |||
} | |||
@@ -266,8 +281,7 @@ public class JsonCodec implements Serializable { | |||
} | |||
public static Object decodeInternalOrCustomType(Type targetType, | |||
Object value, ConnectorTracker connectorTracker) | |||
throws JSONException { | |||
JsonValue value, ConnectorTracker connectorTracker) { | |||
if (isInternalType(targetType)) { | |||
return decodeInternalType(targetType, false, value, | |||
connectorTracker); | |||
@@ -276,50 +290,49 @@ public class JsonCodec implements Serializable { | |||
} | |||
} | |||
public static Object decodeCustomType(Type targetType, Object value, | |||
ConnectorTracker connectorTracker) throws JSONException { | |||
public static Object decodeCustomType(Type targetType, JsonValue value, | |||
ConnectorTracker connectorTracker) { | |||
if (isInternalType(targetType)) { | |||
throw new JSONException("decodeCustomType cannot be used for " | |||
throw new JsonException("decodeCustomType cannot be used for " | |||
+ targetType + ", which is an internal type"); | |||
} | |||
// Try to decode object using fields | |||
if (value == JSONObject.NULL) { | |||
if (value.getType() == JsonType.NULL) { | |||
return null; | |||
} else if (targetType == byte.class || targetType == Byte.class) { | |||
return Byte.valueOf(String.valueOf(value)); | |||
return Byte.valueOf((byte) value.asNumber()); | |||
} else if (targetType == char.class || targetType == Character.class) { | |||
return Character.valueOf(String.valueOf(value).charAt(0)); | |||
return Character.valueOf(value.asString().charAt(0)); | |||
} else if (targetType instanceof Class<?> | |||
&& ((Class<?>) targetType).isArray()) { | |||
// Legacy Object[] and String[] handled elsewhere, this takes care | |||
// of generic arrays | |||
Class<?> componentType = ((Class<?>) targetType).getComponentType(); | |||
return decodeArray(componentType, (JSONArray) value, | |||
return decodeArray(componentType, (JsonArray) value, | |||
connectorTracker); | |||
} else if (targetType instanceof GenericArrayType) { | |||
Type componentType = ((GenericArrayType) targetType) | |||
.getGenericComponentType(); | |||
return decodeArray(componentType, (JSONArray) value, | |||
return decodeArray(componentType, (JsonArray) value, | |||
connectorTracker); | |||
} else if (targetType == JSONObject.class | |||
|| targetType == JSONArray.class) { | |||
} else if (JsonValue.class.isAssignableFrom(getClassForType(targetType))) { | |||
return value; | |||
} else if (Enum.class.isAssignableFrom(getClassForType(targetType))) { | |||
Class<?> classForType = getClassForType(targetType); | |||
return decodeEnum(classForType.asSubclass(Enum.class), | |||
(String) value); | |||
(JsonString) value); | |||
} else if (customSerializers.containsKey(getClassForType(targetType))) { | |||
return customSerializers.get(getClassForType(targetType)) | |||
.deserialize(targetType, value, connectorTracker); | |||
} else { | |||
return decodeObject(targetType, (JSONObject) value, | |||
return decodeObject(targetType, (JsonObject) value, | |||
connectorTracker); | |||
} | |||
} | |||
private static Object decodeArray(Type componentType, JSONArray value, | |||
ConnectorTracker connectorTracker) throws JSONException { | |||
private static Object decodeArray(Type componentType, JsonArray value, | |||
ConnectorTracker connectorTracker) { | |||
Class<?> componentClass = getClassForType(componentType); | |||
Object array = Array.newInstance(componentClass, value.length()); | |||
for (int i = 0; i < value.length(); i++) { | |||
@@ -352,37 +365,36 @@ public class JsonCodec implements Serializable { | |||
* true if generics should be enforce, false to only allow | |||
* internal types in collections | |||
* @return | |||
* @throws JSONException | |||
*/ | |||
public static Object decodeInternalType(Type targetType, | |||
boolean restrictToInternalTypes, Object encodedJsonValue, | |||
ConnectorTracker connectorTracker) throws JSONException { | |||
boolean restrictToInternalTypes, JsonValue encodedJsonValue, | |||
ConnectorTracker connectorTracker) { | |||
if (!isInternalType(targetType)) { | |||
throw new JSONException("Type " + targetType | |||
throw new JsonException("Type " + targetType | |||
+ " is not a supported internal type."); | |||
} | |||
String transportType = getInternalTransportType(targetType); | |||
if (encodedJsonValue == JSONObject.NULL) { | |||
if (encodedJsonValue.getType() == JsonType.NULL) { | |||
return null; | |||
} else if (targetType == Void.class) { | |||
throw new JSONException( | |||
throw new JsonException( | |||
"Something other than null was encoded for a null type"); | |||
} | |||
// UidlValue | |||
if (targetType == UidlValue.class) { | |||
return decodeUidlValue((JSONArray) encodedJsonValue, | |||
return decodeUidlValue((JsonArray) encodedJsonValue, | |||
connectorTracker); | |||
} | |||
// Collections | |||
if (JsonConstants.VTYPE_LIST.equals(transportType)) { | |||
return decodeList(targetType, restrictToInternalTypes, | |||
(JSONArray) encodedJsonValue, connectorTracker); | |||
(JsonArray) encodedJsonValue, connectorTracker); | |||
} else if (JsonConstants.VTYPE_SET.equals(transportType)) { | |||
return decodeSet(targetType, restrictToInternalTypes, | |||
(JSONArray) encodedJsonValue, connectorTracker); | |||
(JsonArray) encodedJsonValue, connectorTracker); | |||
} else if (JsonConstants.VTYPE_MAP.equals(transportType)) { | |||
return decodeMap(targetType, restrictToInternalTypes, | |||
encodedJsonValue, connectorTracker); | |||
@@ -391,42 +403,40 @@ public class JsonCodec implements Serializable { | |||
// Arrays | |||
if (JsonConstants.VTYPE_ARRAY.equals(transportType)) { | |||
return decodeObjectArray(targetType, (JSONArray) encodedJsonValue, | |||
return decodeObjectArray(targetType, (JsonArray) encodedJsonValue, | |||
connectorTracker); | |||
} else if (JsonConstants.VTYPE_STRINGARRAY.equals(transportType)) { | |||
return decodeStringArray((JSONArray) encodedJsonValue); | |||
return decodeStringArray((JsonArray) encodedJsonValue); | |||
} | |||
// Special Vaadin types | |||
String stringValue = String.valueOf(encodedJsonValue); | |||
if (JsonConstants.VTYPE_CONNECTOR.equals(transportType)) { | |||
return connectorTracker.getConnector(stringValue); | |||
return connectorTracker.getConnector(encodedJsonValue.asString()); | |||
} | |||
// Legacy types | |||
if (JsonConstants.VTYPE_STRING.equals(transportType)) { | |||
return stringValue; | |||
return encodedJsonValue.asString(); | |||
} else if (JsonConstants.VTYPE_INTEGER.equals(transportType)) { | |||
return Integer.valueOf(stringValue); | |||
return (int) encodedJsonValue.asNumber(); | |||
} else if (JsonConstants.VTYPE_LONG.equals(transportType)) { | |||
return Long.valueOf(stringValue); | |||
return (long) encodedJsonValue.asNumber(); | |||
} else if (JsonConstants.VTYPE_FLOAT.equals(transportType)) { | |||
return Float.valueOf(stringValue); | |||
return (float) encodedJsonValue.asNumber(); | |||
} else if (JsonConstants.VTYPE_DOUBLE.equals(transportType)) { | |||
return Double.valueOf(stringValue); | |||
return encodedJsonValue.asNumber(); | |||
} else if (JsonConstants.VTYPE_BOOLEAN.equals(transportType)) { | |||
return Boolean.valueOf(stringValue); | |||
return encodedJsonValue.asBoolean(); | |||
} | |||
throw new JSONException("Unknown type " + transportType); | |||
throw new JsonException("Unknown type " + transportType); | |||
} | |||
private static UidlValue decodeUidlValue(JSONArray encodedJsonValue, | |||
ConnectorTracker connectorTracker) throws JSONException { | |||
private static UidlValue decodeUidlValue(JsonArray encodedJsonValue, | |||
ConnectorTracker connectorTracker) { | |||
String type = encodedJsonValue.getString(0); | |||
Object decodedValue = decodeInternalType(getType(type), true, | |||
@@ -435,13 +445,13 @@ public class JsonCodec implements Serializable { | |||
} | |||
private static Map<Object, Object> decodeMap(Type targetType, | |||
boolean restrictToInternalTypes, Object jsonMap, | |||
ConnectorTracker connectorTracker) throws JSONException { | |||
if (jsonMap instanceof JSONArray) { | |||
boolean restrictToInternalTypes, JsonValue jsonMap, | |||
ConnectorTracker connectorTracker) { | |||
if (jsonMap.getType() == JsonType.ARRAY) { | |||
// Client-side has no declared type information to determine | |||
// encoding method for empty maps, so these are handled separately. | |||
// See #8906. | |||
JSONArray jsonArray = (JSONArray) jsonMap; | |||
JsonArray jsonArray = (JsonArray) jsonMap; | |||
if (jsonArray.length() == 0) { | |||
return new HashMap<Object, Object>(); | |||
} | |||
@@ -453,27 +463,27 @@ public class JsonCodec implements Serializable { | |||
Type valueType = ((ParameterizedType) targetType) | |||
.getActualTypeArguments()[1]; | |||
if (keyType == String.class) { | |||
return decodeStringMap(valueType, (JSONObject) jsonMap, | |||
return decodeStringMap(valueType, (JsonObject) jsonMap, | |||
connectorTracker); | |||
} else if (keyType == Connector.class) { | |||
return decodeConnectorMap(valueType, (JSONObject) jsonMap, | |||
return decodeConnectorMap(valueType, (JsonObject) jsonMap, | |||
connectorTracker); | |||
} else { | |||
return decodeObjectMap(keyType, valueType, (JSONArray) jsonMap, | |||
return decodeObjectMap(keyType, valueType, (JsonArray) jsonMap, | |||
connectorTracker); | |||
} | |||
} else { | |||
return decodeStringMap(UidlValue.class, (JSONObject) jsonMap, | |||
return decodeStringMap(UidlValue.class, (JsonObject) jsonMap, | |||
connectorTracker); | |||
} | |||
} | |||
private static Map<Object, Object> decodeObjectMap(Type keyType, | |||
Type valueType, JSONArray jsonMap, ConnectorTracker connectorTracker) | |||
throws JSONException { | |||
Type valueType, JsonArray jsonMap, ConnectorTracker connectorTracker) | |||
{ | |||
JSONArray keys = jsonMap.getJSONArray(0); | |||
JSONArray values = jsonMap.getJSONArray(1); | |||
JsonArray keys = jsonMap.getArray(0); | |||
JsonArray values = jsonMap.getArray(1); | |||
assert (keys.length() == values.length()); | |||
@@ -491,12 +501,10 @@ public class JsonCodec implements Serializable { | |||
} | |||
private static Map<Object, Object> decodeConnectorMap(Type valueType, | |||
JSONObject jsonMap, ConnectorTracker connectorTracker) | |||
throws JSONException { | |||
JsonObject jsonMap, ConnectorTracker connectorTracker) { | |||
Map<Object, Object> map = new HashMap<Object, Object>(); | |||
for (Iterator<?> iter = jsonMap.keys(); iter.hasNext();) { | |||
String key = (String) iter.next(); | |||
for (String key : jsonMap.keys()) { | |||
Object value = decodeInternalOrCustomType(valueType, | |||
jsonMap.get(key), connectorTracker); | |||
if (valueType == UidlValue.class) { | |||
@@ -509,12 +517,10 @@ public class JsonCodec implements Serializable { | |||
} | |||
private static Map<Object, Object> decodeStringMap(Type valueType, | |||
JSONObject jsonMap, ConnectorTracker connectorTracker) | |||
throws JSONException { | |||
JsonObject jsonMap, ConnectorTracker connectorTracker) { | |||
Map<Object, Object> map = new HashMap<Object, Object>(); | |||
for (Iterator<?> iter = jsonMap.keys(); iter.hasNext();) { | |||
String key = (String) iter.next(); | |||
for (String key : jsonMap.keys()) { | |||
Object value = decodeInternalOrCustomType(valueType, | |||
jsonMap.get(key), connectorTracker); | |||
if (valueType == UidlValue.class) { | |||
@@ -535,11 +541,10 @@ public class JsonCodec implements Serializable { | |||
* @param encodedValueAndType | |||
* @param application | |||
* @return | |||
* @throws JSONException | |||
*/ | |||
private static Object decodeParametrizedType(Type targetType, | |||
boolean restrictToInternalTypes, int typeIndex, Object value, | |||
ConnectorTracker connectorTracker) throws JSONException { | |||
boolean restrictToInternalTypes, int typeIndex, JsonValue value, | |||
ConnectorTracker connectorTracker) { | |||
if (!restrictToInternalTypes && targetType instanceof ParameterizedType) { | |||
Type childType = ((ParameterizedType) targetType) | |||
.getActualTypeArguments()[typeIndex]; | |||
@@ -555,12 +560,11 @@ public class JsonCodec implements Serializable { | |||
} | |||
} | |||
private static Object decodeEnum(Class<? extends Enum> cls, String value) { | |||
return Enum.valueOf(cls, value); | |||
private static Object decodeEnum(Class<? extends Enum> cls, JsonString value) { | |||
return Enum.valueOf(cls, value.getString()); | |||
} | |||
private static String[] decodeStringArray(JSONArray jsonArray) | |||
throws JSONException { | |||
private static String[] decodeStringArray(JsonArray jsonArray) { | |||
int length = jsonArray.length(); | |||
List<String> tokens = new ArrayList<String>(length); | |||
for (int i = 0; i < length; ++i) { | |||
@@ -570,21 +574,20 @@ public class JsonCodec implements Serializable { | |||
} | |||
private static Object[] decodeObjectArray(Type targetType, | |||
JSONArray jsonArray, ConnectorTracker connectorTracker) | |||
throws JSONException { | |||
JsonArray jsonArray, ConnectorTracker connectorTracker) { | |||
List<Object> list = decodeList(List.class, true, jsonArray, | |||
connectorTracker); | |||
return list.toArray(new Object[list.size()]); | |||
} | |||
private static List<Object> decodeList(Type targetType, | |||
boolean restrictToInternalTypes, JSONArray jsonArray, | |||
ConnectorTracker connectorTracker) throws JSONException { | |||
boolean restrictToInternalTypes, JsonArray jsonArray, | |||
ConnectorTracker connectorTracker) { | |||
int arrayLength = jsonArray.length(); | |||
List<Object> list = new ArrayList<Object>(arrayLength); | |||
for (int i = 0; i < arrayLength; ++i) { | |||
// each entry always has two elements: type and value | |||
Object encodedValue = jsonArray.get(i); | |||
JsonValue encodedValue = jsonArray.get(i); | |||
Object decodedChild = decodeParametrizedType(targetType, | |||
restrictToInternalTypes, 0, encodedValue, connectorTracker); | |||
list.add(decodedChild); | |||
@@ -593,8 +596,8 @@ public class JsonCodec implements Serializable { | |||
} | |||
private static Set<Object> decodeSet(Type targetType, | |||
boolean restrictToInternalTypes, JSONArray jsonArray, | |||
ConnectorTracker connectorTracker) throws JSONException { | |||
boolean restrictToInternalTypes, JsonArray jsonArray, | |||
ConnectorTracker connectorTracker) { | |||
HashSet<Object> set = new HashSet<Object>(); | |||
set.addAll(decodeList(targetType, restrictToInternalTypes, jsonArray, | |||
connectorTracker)); | |||
@@ -602,8 +605,7 @@ public class JsonCodec implements Serializable { | |||
} | |||
private static Object decodeObject(Type targetType, | |||
JSONObject serializedObject, ConnectorTracker connectorTracker) | |||
throws JSONException { | |||
JsonObject serializedObject, ConnectorTracker connectorTracker) { | |||
Class<?> targetClass = getClassForType(targetType); | |||
@@ -612,7 +614,7 @@ public class JsonCodec implements Serializable { | |||
for (BeanProperty property : getProperties(targetClass)) { | |||
String fieldName = property.getName(); | |||
Object encodedFieldValue = serializedObject.get(fieldName); | |||
JsonValue encodedFieldValue = serializedObject.get(fieldName); | |||
Type fieldType = property.getType(); | |||
Object decodedFieldValue = decodeInternalOrCustomType( | |||
fieldType, encodedFieldValue, connectorTracker); | |||
@@ -622,13 +624,12 @@ public class JsonCodec implements Serializable { | |||
return decodedObject; | |||
} catch (Exception e) { | |||
throw new JSONException(e.getMessage()); | |||
throw new RuntimeException(e); | |||
} | |||
} | |||
public static EncodeResult encode(Object value, Object diffState, | |||
Type valueType, ConnectorTracker connectorTracker) | |||
throws JSONException { | |||
public static EncodeResult encode(Object value, JsonValue diffState, | |||
Type valueType, ConnectorTracker connectorTracker) { | |||
if (null == value) { | |||
return ENCODE_RESULT_NULL; | |||
@@ -636,13 +637,19 @@ public class JsonCodec implements Serializable { | |||
// Storing a single reference and only returning the EncodeResult at the | |||
// end the method is much shorter in bytecode which allows inlining | |||
Object toReturn; | |||
JsonValue toReturn; | |||
if (value instanceof String || value instanceof Boolean | |||
|| value instanceof Number || value instanceof Character | |||
|| value instanceof JSONArray || value instanceof JSONObject) { | |||
if (value instanceof JsonValue) { | |||
// all JSON compatible types are returned as is. | |||
toReturn = value; | |||
toReturn = (JsonValue) value; | |||
} else if (value instanceof String) { | |||
toReturn = Json.create((String) value); | |||
} else if (value instanceof Boolean) { | |||
toReturn = Json.create((Boolean) value); | |||
} else if (value instanceof Number) { | |||
toReturn = Json.create(((Number) value).doubleValue()); | |||
} else if (value instanceof Character) { | |||
toReturn = Json.create(Character.toString((Character) value)); | |||
} else if (value instanceof String[]) { | |||
toReturn = toJsonArray((String[]) value); | |||
} else if (value instanceof Collection) { | |||
@@ -658,9 +665,9 @@ public class JsonCodec implements Serializable { | |||
return ENCODE_RESULT_NULL; | |||
} | |||
// Connectors are simply serialized as ID. | |||
toReturn = ((Connector) value).getConnectorId(); | |||
toReturn = Json.create(((Connector) value).getConnectorId()); | |||
} else if (value instanceof Enum) { | |||
toReturn = ((Enum<?>) value).name(); | |||
toReturn = Json.create(((Enum<?>) value).name()); | |||
} else if (customSerializers.containsKey(value.getClass())) { | |||
toReturn = serializeJson(value, connectorTracker); | |||
} else if (valueType instanceof GenericArrayType) { | |||
@@ -677,10 +684,10 @@ public class JsonCodec implements Serializable { | |||
// needs to return it directly rather than assigning it to | |||
// toReturn. | |||
return encodeObject(value, (Class<?>) valueType, | |||
(JSONObject) diffState, connectorTracker); | |||
(JsonObject) diffState, connectorTracker); | |||
} | |||
} else { | |||
throw new JSONException("Can not encode type " + valueType); | |||
throw new JsonException("Can not encode type " + valueType); | |||
} | |||
return new EncodeResult(toReturn); | |||
} | |||
@@ -706,10 +713,9 @@ public class JsonCodec implements Serializable { | |||
* Loops through the fields of value and encodes them. | |||
*/ | |||
private static EncodeResult encodeObject(Object value, Class<?> valueType, | |||
JSONObject referenceValue, ConnectorTracker connectorTracker) | |||
throws JSONException { | |||
JSONObject encoded = new JSONObject(); | |||
JSONObject diff = new JSONObject(); | |||
JsonObject referenceValue, ConnectorTracker connectorTracker) { | |||
JsonObject encoded = Json.createObject(); | |||
JsonObject diff = Json.createObject(); | |||
try { | |||
for (BeanProperty property : getProperties(valueType)) { | |||
@@ -719,7 +725,7 @@ public class JsonCodec implements Serializable { | |||
Type fieldType = property.getType(); | |||
Object fieldValue = property.getValue(value); | |||
if (encoded.has(fieldName)) { | |||
if (encoded.hasKey(fieldName)) { | |||
throw new RuntimeException( | |||
"Can't encode " | |||
+ valueType.getName() | |||
@@ -728,10 +734,10 @@ public class JsonCodec implements Serializable { | |||
+ ". This can happen if there are getters and setters for a public field (the framework can't know which to ignore) or if there are properties with only casing distinguishing between the names (e.g. getFoo() and getFOO())"); | |||
} | |||
Object fieldReference; | |||
JsonValue fieldReference; | |||
if (referenceValue != null) { | |||
fieldReference = referenceValue.get(fieldName); | |||
if (JSONObject.NULL.equals(fieldReference)) { | |||
if (fieldReference instanceof JsonNull) { | |||
fieldReference = null; | |||
} | |||
} else { | |||
@@ -748,7 +754,7 @@ public class JsonCodec implements Serializable { | |||
} | |||
} catch (Exception e) { | |||
// TODO: Should exceptions be handled in a different way? | |||
throw new JSONException(e.getMessage()); | |||
throw new RuntimeException(e); | |||
} | |||
return new EncodeResult(encoded, diff); | |||
} | |||
@@ -760,8 +766,8 @@ public class JsonCodec implements Serializable { | |||
* @param referenceValue | |||
* @return | |||
*/ | |||
private static boolean jsonEquals(Object fieldValue, Object referenceValue) { | |||
if (fieldValue == JSONObject.NULL) { | |||
private static boolean jsonEquals(JsonValue fieldValue, JsonValue referenceValue) { | |||
if (fieldValue instanceof JsonNull) { | |||
fieldValue = null; | |||
} | |||
@@ -769,41 +775,33 @@ public class JsonCodec implements Serializable { | |||
return true; | |||
} else if (fieldValue == null || referenceValue == null) { | |||
return false; | |||
} else if (fieldValue instanceof Integer | |||
&& referenceValue instanceof Integer) { | |||
return ((Integer) fieldValue).equals(referenceValue); | |||
} else if (fieldValue instanceof Boolean | |||
&& referenceValue instanceof Boolean) { | |||
return ((Boolean) fieldValue).equals(referenceValue); | |||
} else { | |||
return fieldValue.toString().equals(referenceValue.toString()); | |||
return fieldValue.jsEquals(referenceValue); | |||
} | |||
} | |||
private static JSONArray encodeArrayContents(Type componentType, | |||
Object array, ConnectorTracker connectorTracker) | |||
throws JSONException { | |||
JSONArray jsonArray = new JSONArray(); | |||
private static JsonArray encodeArrayContents(Type componentType, | |||
Object array, ConnectorTracker connectorTracker) { | |||
JsonArray jsonArray = Json.createArray(); | |||
for (int i = 0; i < Array.getLength(array); i++) { | |||
EncodeResult encodeResult = encode(Array.get(array, i), null, | |||
componentType, connectorTracker); | |||
jsonArray.put(encodeResult.getEncodedValue()); | |||
jsonArray.set(i, encodeResult.getEncodedValue()); | |||
} | |||
return jsonArray; | |||
} | |||
private static JSONArray encodeCollection(Type targetType, | |||
Collection<?> collection, ConnectorTracker connectorTracker) | |||
throws JSONException { | |||
JSONArray jsonArray = new JSONArray(); | |||
private static JsonArray encodeCollection(Type targetType, | |||
Collection<?> collection, ConnectorTracker connectorTracker) { | |||
JsonArray jsonArray = Json.createArray(); | |||
for (Object o : collection) { | |||
jsonArray.put(encodeChild(targetType, 0, o, connectorTracker)); | |||
jsonArray.set(jsonArray.length(), encodeChild(targetType, 0, o, connectorTracker)); | |||
} | |||
return jsonArray; | |||
} | |||
private static Object encodeChild(Type targetType, int typeIndex, Object o, | |||
ConnectorTracker connectorTracker) throws JSONException { | |||
private static JsonValue encodeChild(Type targetType, int typeIndex, Object o, | |||
ConnectorTracker connectorTracker) { | |||
if (targetType instanceof ParameterizedType) { | |||
Type childType = ((ParameterizedType) targetType) | |||
.getActualTypeArguments()[typeIndex]; | |||
@@ -812,19 +810,19 @@ public class JsonCodec implements Serializable { | |||
connectorTracker); | |||
return encodeResult.getEncodedValue(); | |||
} else { | |||
throw new JSONException("Collection is missing generics"); | |||
throw new JsonException("Collection is missing generics"); | |||
} | |||
} | |||
private static Object encodeMap(Type mapType, Map<?, ?> map, | |||
ConnectorTracker connectorTracker) throws JSONException { | |||
private static JsonValue encodeMap(Type mapType, Map<?, ?> map, | |||
ConnectorTracker connectorTracker) { | |||
Type keyType, valueType; | |||
if (mapType instanceof ParameterizedType) { | |||
keyType = ((ParameterizedType) mapType).getActualTypeArguments()[0]; | |||
valueType = ((ParameterizedType) mapType).getActualTypeArguments()[1]; | |||
} else { | |||
throw new JSONException("Map is missing generics"); | |||
throw new JsonException("Map is missing generics"); | |||
} | |||
if (map.isEmpty()) { | |||
@@ -842,11 +840,10 @@ public class JsonCodec implements Serializable { | |||
} | |||
} | |||
private static JSONArray encodeObjectMap(Type keyType, Type valueType, | |||
Map<?, ?> map, ConnectorTracker connectorTracker) | |||
throws JSONException { | |||
JSONArray keys = new JSONArray(); | |||
JSONArray values = new JSONArray(); | |||
private static JsonArray encodeObjectMap(Type keyType, Type valueType, | |||
Map<?, ?> map, ConnectorTracker connectorTracker) { | |||
JsonArray keys = Json.createArray(); | |||
JsonArray values = Json.createArray(); | |||
for (Entry<?, ?> entry : map.entrySet()) { | |||
EncodeResult encodedKey = encode(entry.getKey(), null, keyType, | |||
@@ -854,19 +851,23 @@ public class JsonCodec implements Serializable { | |||
EncodeResult encodedValue = encode(entry.getValue(), null, | |||
valueType, connectorTracker); | |||
keys.put(encodedKey.getEncodedValue()); | |||
values.put(encodedValue.getEncodedValue()); | |||
keys.set(keys.length(), encodedKey.getEncodedValue()); | |||
values.set(values.length(), encodedValue.getEncodedValue()); | |||
} | |||
return new JSONArray(Arrays.asList(keys, values)); | |||
JsonArray jsonMap = Json.createArray(); | |||
jsonMap.set(0, keys); | |||
jsonMap.set(1, values); | |||
return jsonMap; | |||
} | |||
/* | |||
* Encodes a connector map. Invisible connectors are skipped. | |||
*/ | |||
private static JSONObject encodeConnectorMap(Type valueType, Map<?, ?> map, | |||
ConnectorTracker connectorTracker) throws JSONException { | |||
JSONObject jsonMap = new JSONObject(); | |||
private static JsonObject encodeConnectorMap(Type valueType, Map<?, ?> map, | |||
ConnectorTracker connectorTracker) { | |||
JsonObject jsonMap = Json.createObject(); | |||
for (Entry<?, ?> entry : map.entrySet()) { | |||
ClientConnector key = (ClientConnector) entry.getKey(); | |||
@@ -881,9 +882,9 @@ public class JsonCodec implements Serializable { | |||
return jsonMap; | |||
} | |||
private static JSONObject encodeStringMap(Type valueType, Map<?, ?> map, | |||
ConnectorTracker connectorTracker) throws JSONException { | |||
JSONObject jsonMap = new JSONObject(); | |||
private static JsonObject encodeStringMap(Type valueType, Map<?, ?> map, | |||
ConnectorTracker connectorTracker) { | |||
JsonObject jsonMap = Json.createObject(); | |||
for (Entry<?, ?> entry : map.entrySet()) { | |||
String key = (String) entry.getKey(); | |||
@@ -904,16 +905,16 @@ public class JsonCodec implements Serializable { | |||
return typeToTransportType.get(getClassForType(valueType)); | |||
} | |||
private static Object serializeJson(Object value, | |||
private static JsonValue serializeJson(Object value, | |||
ConnectorTracker connectorTracker) { | |||
JSONSerializer serializer = customSerializers.get(value.getClass()); | |||
JsonSerializer serializer = customSerializers.get(value.getClass()); | |||
return serializer.serialize(value, connectorTracker); | |||
} | |||
private static JSONArray toJsonArray(String[] array) { | |||
JSONArray jsonArray = new JSONArray(); | |||
private static JsonArray toJsonArray(String[] array) { | |||
JsonArray jsonArray = Json.createArray(); | |||
for (int i = 0; i < array.length; ++i) { | |||
jsonArray.put(array[i]); | |||
jsonArray.set(i, array[i]); | |||
} | |||
return jsonArray; | |||
} |
@@ -27,9 +27,6 @@ import java.util.Set; | |||
import java.util.logging.Level; | |||
import java.util.logging.Logger; | |||
import org.json.JSONException; | |||
import org.json.JSONObject; | |||
import com.vaadin.server.ClientConnector.ConnectorErrorEvent; | |||
import com.vaadin.shared.ApplicationConstants; | |||
import com.vaadin.shared.JavaScriptConnectorState; | |||
@@ -40,6 +37,9 @@ import com.vaadin.ui.HasComponents; | |||
import com.vaadin.ui.SelectiveRenderer; | |||
import com.vaadin.ui.UI; | |||
import elemental.json.JsonObject; | |||
import elemental.json.JsonValue; | |||
/** | |||
* This is a common base class for the server-side implementations of the | |||
* communication system between the client code (compiled with GWT into | |||
@@ -85,12 +85,11 @@ public class LegacyCommunicationManager implements Serializable { | |||
* @deprecated As of 7.1. See #11411. | |||
*/ | |||
@Deprecated | |||
public static JSONObject encodeState(ClientConnector connector, | |||
SharedState state) throws JSONException { | |||
public static JsonObject encodeState(ClientConnector connector, SharedState state) { | |||
UI uI = connector.getUI(); | |||
ConnectorTracker connectorTracker = uI.getConnectorTracker(); | |||
Class<? extends SharedState> stateType = connector.getStateType(); | |||
Object diffState = connectorTracker.getDiffState(connector); | |||
JsonValue diffState = connectorTracker.getDiffState(connector); | |||
boolean supportsDiffState = !JavaScriptConnectorState.class | |||
.isAssignableFrom(stateType); | |||
if (diffState == null && supportsDiffState) { | |||
@@ -113,9 +112,9 @@ public class LegacyCommunicationManager implements Serializable { | |||
stateType, uI.getConnectorTracker()); | |||
if (supportsDiffState) { | |||
connectorTracker.setDiffState(connector, | |||
(JSONObject) encodeResult.getEncodedValue()); | |||
(JsonObject) encodeResult.getEncodedValue()); | |||
} | |||
return (JSONObject) encodeResult.getDiff(); | |||
return (JsonObject) encodeResult.getDiff(); | |||
} | |||
/** |
@@ -48,9 +48,6 @@ import javax.servlet.Servlet; | |||
import javax.servlet.ServletContext; | |||
import javax.servlet.http.HttpServletResponse; | |||
import org.json.JSONException; | |||
import org.json.JSONObject; | |||
import com.vaadin.annotations.PreserveOnRefresh; | |||
import com.vaadin.event.EventRouter; | |||
import com.vaadin.server.VaadinSession.FutureAccess; | |||
@@ -67,6 +64,11 @@ import com.vaadin.ui.UI; | |||
import com.vaadin.util.CurrentInstance; | |||
import com.vaadin.util.ReflectTools; | |||
import elemental.json.Json; | |||
import elemental.json.JsonException; | |||
import elemental.json.JsonObject; | |||
import elemental.json.impl.JsonUtil; | |||
/** | |||
* Provide deployment specific settings that are required outside terminal | |||
* specific code. | |||
@@ -1574,22 +1576,22 @@ public abstract class VaadinService implements Serializable { | |||
message += "<br/><br/>" + details; | |||
} | |||
JSONObject appError = new JSONObject(); | |||
JsonObject appError = Json.createObject(); | |||
appError.put("caption", caption); | |||
appError.put("message", message); | |||
appError.put("url", url); | |||
JSONObject meta = new JSONObject(); | |||
JsonObject meta = Json.createObject(); | |||
meta.put("appError", appError); | |||
JSONObject json = new JSONObject(); | |||
json.put("changes", new JSONObject()); | |||
json.put("resources", new JSONObject()); | |||
json.put("locales", new JSONObject()); | |||
JsonObject json = Json.createObject(); | |||
json.put("changes", Json.createObject()); | |||
json.put("resources", Json.createObject()); | |||
json.put("locales", Json.createObject()); | |||
json.put("meta", meta); | |||
json.put(ApplicationConstants.SERVER_SYNC_ID, -1); | |||
returnString = json.toString(); | |||
} catch (JSONException e) { | |||
returnString = JsonUtil.stringify(json); | |||
} catch (JsonException e) { | |||
getLogger().log(Level.WARNING, | |||
"Error creating critical notification JSON message", e); | |||
} |
@@ -24,9 +24,6 @@ import java.util.ArrayList; | |||
import java.util.Collection; | |||
import java.util.List; | |||
import org.json.JSONArray; | |||
import org.json.JSONException; | |||
import com.vaadin.server.ClientConnector; | |||
import com.vaadin.server.ClientMethodInvocation; | |||
import com.vaadin.server.EncodeResult; | |||
@@ -35,6 +32,12 @@ import com.vaadin.server.PaintException; | |||
import com.vaadin.shared.communication.ClientRpc; | |||
import com.vaadin.ui.UI; | |||
import elemental.json.Json; | |||
import elemental.json.JsonArray; | |||
import elemental.json.JsonException; | |||
import elemental.json.JsonValue; | |||
import elemental.json.impl.JsonUtil; | |||
/** | |||
* Serializes {@link ClientRpc client RPC} invocations to JSON. | |||
* | |||
@@ -59,18 +62,18 @@ public class ClientRpcWriter implements Serializable { | |||
Collection<ClientMethodInvocation> pendingInvocations = collectPendingRpcCalls(ui | |||
.getConnectorTracker().getDirtyVisibleConnectors()); | |||
JSONArray rpcCalls = new JSONArray(); | |||
JsonArray rpcCalls = Json.createArray(); | |||
for (ClientMethodInvocation invocation : pendingInvocations) { | |||
// add invocation to rpcCalls | |||
try { | |||
JSONArray invocationJson = new JSONArray(); | |||
invocationJson.put(invocation.getConnector().getConnectorId()); | |||
invocationJson.put(invocation.getInterfaceName()); | |||
invocationJson.put(invocation.getMethodName()); | |||
JSONArray paramJson = new JSONArray(); | |||
JsonArray invocationJson = Json.createArray(); | |||
invocationJson.set(0, invocation.getConnector().getConnectorId()); | |||
invocationJson.set(1, invocation.getInterfaceName()); | |||
invocationJson.set(2, invocation.getMethodName()); | |||
JsonArray paramJson = Json.createArray(); | |||
for (int i = 0; i < invocation.getParameterTypes().length; ++i) { | |||
Type parameterType = invocation.getParameterTypes()[i]; | |||
Object referenceParameter = null; | |||
JsonValue referenceParameter = null; | |||
// TODO Use default values for RPC parameter types | |||
// if (!JsonCodec.isInternalType(parameterType)) { | |||
// try { | |||
@@ -84,11 +87,11 @@ public class ClientRpcWriter implements Serializable { | |||
EncodeResult encodeResult = JsonCodec.encode( | |||
invocation.getParameters()[i], referenceParameter, | |||
parameterType, ui.getConnectorTracker()); | |||
paramJson.put(encodeResult.getEncodedValue()); | |||
paramJson.set(i, encodeResult.getEncodedValue()); | |||
} | |||
invocationJson.put(paramJson); | |||
rpcCalls.put(invocationJson); | |||
} catch (JSONException e) { | |||
invocationJson.set(3, paramJson); | |||
rpcCalls.set(rpcCalls.length(), invocationJson); | |||
} catch (JsonException e) { | |||
throw new PaintException( | |||
"Failed to serialize RPC method call parameters for connector " | |||
+ invocation.getConnector().getConnectorId() | |||
@@ -97,7 +100,7 @@ public class ClientRpcWriter implements Serializable { | |||
+ e.getMessage(), e); | |||
} | |||
} | |||
writer.write(rpcCalls.toString()); | |||
writer.write(JsonUtil.stringify(rpcCalls)); | |||
} | |||
/** |
@@ -21,16 +21,18 @@ import java.io.Serializable; | |||
import java.io.Writer; | |||
import java.util.Collection; | |||
import org.json.JSONArray; | |||
import org.json.JSONException; | |||
import org.json.JSONObject; | |||
import com.vaadin.server.AbstractClientConnector; | |||
import com.vaadin.server.ClientConnector; | |||
import com.vaadin.server.LegacyCommunicationManager; | |||
import com.vaadin.server.PaintException; | |||
import com.vaadin.ui.UI; | |||
import elemental.json.Json; | |||
import elemental.json.JsonArray; | |||
import elemental.json.JsonException; | |||
import elemental.json.JsonObject; | |||
import elemental.json.impl.JsonUtil; | |||
/** | |||
* Serializes a connector hierarchy to JSON. | |||
* | |||
@@ -55,27 +57,27 @@ public class ConnectorHierarchyWriter implements Serializable { | |||
Collection<ClientConnector> dirtyVisibleConnectors = ui | |||
.getConnectorTracker().getDirtyVisibleConnectors(); | |||
JSONObject hierarchyInfo = new JSONObject(); | |||
JsonObject hierarchyInfo = Json.createObject(); | |||
for (ClientConnector connector : dirtyVisibleConnectors) { | |||
String connectorId = connector.getConnectorId(); | |||
JSONArray children = new JSONArray(); | |||
JsonArray children = Json.createArray(); | |||
for (ClientConnector child : AbstractClientConnector | |||
.getAllChildrenIterable(connector)) { | |||
if (LegacyCommunicationManager | |||
.isConnectorVisibleToClient(child)) { | |||
children.put(child.getConnectorId()); | |||
children.set(children.length(), child.getConnectorId()); | |||
} | |||
} | |||
try { | |||
hierarchyInfo.put(connectorId, children); | |||
} catch (JSONException e) { | |||
} catch (JsonException e) { | |||
throw new PaintException( | |||
"Failed to send hierarchy information about " | |||
+ connectorId + " to the client: " | |||
+ e.getMessage(), e); | |||
} | |||
} | |||
writer.write(hierarchyInfo.toString()); | |||
writer.write(JsonUtil.stringify(hierarchyInfo)); | |||
} | |||
} |
@@ -21,14 +21,16 @@ import java.io.Serializable; | |||
import java.io.Writer; | |||
import java.util.Collection; | |||
import org.json.JSONException; | |||
import org.json.JSONObject; | |||
import com.vaadin.server.ClientConnector; | |||
import com.vaadin.server.PaintException; | |||
import com.vaadin.server.PaintTarget; | |||
import com.vaadin.ui.UI; | |||
import elemental.json.Json; | |||
import elemental.json.JsonException; | |||
import elemental.json.JsonObject; | |||
import elemental.json.impl.JsonUtil; | |||
/** | |||
* Serializes connector type mappings to JSON. | |||
* | |||
@@ -56,18 +58,18 @@ public class ConnectorTypeWriter implements Serializable { | |||
Collection<ClientConnector> dirtyVisibleConnectors = ui | |||
.getConnectorTracker().getDirtyVisibleConnectors(); | |||
JSONObject connectorTypes = new JSONObject(); | |||
JsonObject connectorTypes = Json.createObject(); | |||
for (ClientConnector connector : dirtyVisibleConnectors) { | |||
String connectorType = target.getTag(connector); | |||
try { | |||
connectorTypes.put(connector.getConnectorId(), connectorType); | |||
} catch (JSONException e) { | |||
} catch (JsonException e) { | |||
throw new PaintException( | |||
"Failed to send connector type for connector " | |||
+ connector.getConnectorId() + ": " | |||
+ e.getMessage(), e); | |||
} | |||
} | |||
writer.write(connectorTypes.toString()); | |||
writer.write(JsonUtil.stringify(connectorTypes)); | |||
} | |||
} |
@@ -19,6 +19,8 @@ import java.lang.reflect.Type; | |||
import java.util.Date; | |||
import com.vaadin.ui.ConnectorTracker; | |||
import elemental.json.Json; | |||
import elemental.json.JsonValue; | |||
/** | |||
* Server side serializer/deserializer for java.util.Date | |||
@@ -26,17 +28,17 @@ import com.vaadin.ui.ConnectorTracker; | |||
* @since 7.2 | |||
* @author Vaadin Ltd | |||
*/ | |||
public class DateSerializer implements JSONSerializer<Date> { | |||
public class DateSerializer implements JsonSerializer<Date> { | |||
@Override | |||
public Date deserialize(Type type, Object jsonValue, | |||
public Date deserialize(Type type, JsonValue jsonValue, | |||
ConnectorTracker connectorTracker) { | |||
return new Date(Long.valueOf(String.valueOf(jsonValue))); | |||
return new Date((long) jsonValue.asNumber()); | |||
} | |||
@Override | |||
public Object serialize(Date value, ConnectorTracker connectorTracker) { | |||
return value.getTime(); | |||
public JsonValue serialize(Date value, ConnectorTracker connectorTracker) { | |||
return Json.create(value.getTime()); | |||
} | |||
} |
@@ -18,17 +18,18 @@ package com.vaadin.server.communication; | |||
import java.lang.reflect.Type; | |||
import com.vaadin.ui.ConnectorTracker; | |||
import elemental.json.JsonValue; | |||
/** | |||
* Implementors of this interface knows how to serialize an Object of a given | |||
* type to JSON and how to deserialize the JSON back into an object. | |||
* <p> | |||
* The {@link #serialize(Object, ConnectorTracker)} and | |||
* {@link #deserialize(Type, Object, ConnectorTracker)} methods must be | |||
* {@link #deserialize(Type, JsonValue, ConnectorTracker)} methods must be | |||
* symmetric so they can be chained and produce the original result (or an equal | |||
* result). | |||
* <p> | |||
* Each {@link JSONSerializer} implementation can handle an object of a single | |||
* Each {@link JsonSerializer} implementation can handle an object of a single | |||
* type. | |||
* <p> | |||
* This is the server side interface, see | |||
@@ -37,15 +38,12 @@ import com.vaadin.ui.ConnectorTracker; | |||
* @since 7.2 | |||
* @author Vaadin Ltd | |||
*/ | |||
public interface JSONSerializer<T> { | |||
public interface JsonSerializer<T> { | |||
/** | |||
* Creates and deserializes an object received from the client. Must be | |||
* compatible with {@link #serialize(Object, ConnectorTracker)} and also | |||
* with the client side com.vaadin.client.communication.JSONSerializer. | |||
* <p> | |||
* The json parameter is of type Object as org.json JSON classes have no | |||
* other common super class | |||
* | |||
* | |||
* @param type | |||
* The expected return type | |||
* @param jsonValue | |||
@@ -54,11 +52,11 @@ public interface JSONSerializer<T> { | |||
* the connector tracker instance for the UI | |||
* @return A deserialized object | |||
*/ | |||
T deserialize(Type type, Object jsonValue, ConnectorTracker connectorTracker); | |||
T deserialize(Type type, JsonValue jsonValue, ConnectorTracker connectorTracker); | |||
/** | |||
* Serialize the given object into JSON. Must be compatible with | |||
* {@link #deserialize(Object, connectorTracker)} and the client side | |||
* {@link #deserialize(Type, JsonValue, ConnectorTracker)} and the client side | |||
* com.vaadin.client.communication.JSONSerializer | |||
* | |||
* @param value | |||
@@ -67,6 +65,6 @@ public interface JSONSerializer<T> { | |||
* The connector tracker instance for the UI | |||
* @return A JSON serialized version of the object | |||
*/ | |||
Object serialize(T value, ConnectorTracker connectorTracker); | |||
JsonValue serialize(T value, ConnectorTracker connectorTracker); | |||
} |
@@ -25,9 +25,6 @@ import javax.portlet.RenderRequest; | |||
import javax.portlet.RenderResponse; | |||
import javax.portlet.ResourceURL; | |||
import org.json.JSONException; | |||
import org.json.JSONObject; | |||
import com.vaadin.server.BootstrapHandler; | |||
import com.vaadin.server.PaintException; | |||
import com.vaadin.server.VaadinPortlet; | |||
@@ -39,6 +36,7 @@ import com.vaadin.server.VaadinResponse; | |||
import com.vaadin.server.VaadinService; | |||
import com.vaadin.server.VaadinSession; | |||
import com.vaadin.shared.ApplicationConstants; | |||
import elemental.json.JsonObject; | |||
public class PortletBootstrapHandler extends BootstrapHandler { | |||
@Override | |||
@@ -71,7 +69,7 @@ public class PortletBootstrapHandler extends BootstrapHandler { | |||
@Override | |||
protected void appendMainScriptTagContents(BootstrapContext context, | |||
StringBuilder builder) throws JSONException, IOException { | |||
StringBuilder builder) throws IOException { | |||
// fixed base theme to use - all portal pages with Vaadin | |||
// applications will load this exactly once | |||
String portalTheme = ((VaadinPortletRequest) context.getRequest()) | |||
@@ -94,9 +92,9 @@ public class PortletBootstrapHandler extends BootstrapHandler { | |||
} | |||
@Override | |||
protected JSONObject getApplicationParameters(BootstrapContext context) | |||
throws JSONException, PaintException { | |||
JSONObject parameters = super.getApplicationParameters(context); | |||
protected JsonObject getApplicationParameters(BootstrapContext context) | |||
throws PaintException { | |||
JsonObject parameters = super.getApplicationParameters(context); | |||
VaadinPortletResponse response = (VaadinPortletResponse) context | |||
.getResponse(); | |||
VaadinPortletRequest request = (VaadinPortletRequest) context |
@@ -29,7 +29,6 @@ import org.atmosphere.cpr.AtmosphereResource.TRANSPORT; | |||
import org.atmosphere.cpr.AtmosphereResourceEvent; | |||
import org.atmosphere.cpr.AtmosphereResourceEventListenerAdapter; | |||
import org.atmosphere.handler.AbstractReflectorAtmosphereHandler; | |||
import org.json.JSONException; | |||
import com.vaadin.server.ErrorEvent; | |||
import com.vaadin.server.ErrorHandler; | |||
@@ -46,6 +45,7 @@ import com.vaadin.server.VaadinSession; | |||
import com.vaadin.shared.ApplicationConstants; | |||
import com.vaadin.shared.communication.PushMode; | |||
import com.vaadin.ui.UI; | |||
import elemental.json.JsonException; | |||
/** | |||
* Establishes bidirectional ("push") communication channels | |||
@@ -173,7 +173,7 @@ public class PushHandler extends AtmosphereResourceEventListenerAdapter { | |||
try { | |||
new ServerRpcHandler().handleRpc(ui, reader, vaadinRequest); | |||
connection.push(false); | |||
} catch (JSONException e) { | |||
} catch (JsonException e) { | |||
getLogger().log(Level.SEVERE, "Error writing JSON to response", | |||
e); | |||
// Refresh on client side |
@@ -28,10 +28,6 @@ import java.util.Set; | |||
import java.util.logging.Level; | |||
import java.util.logging.Logger; | |||
import org.json.JSONArray; | |||
import org.json.JSONException; | |||
import org.json.JSONObject; | |||
import com.vaadin.server.ClientConnector; | |||
import com.vaadin.server.JsonCodec; | |||
import com.vaadin.server.LegacyCommunicationManager; | |||
@@ -52,6 +48,12 @@ import com.vaadin.ui.Component; | |||
import com.vaadin.ui.ConnectorTracker; | |||
import com.vaadin.ui.UI; | |||
import elemental.json.JsonArray; | |||
import elemental.json.JsonException; | |||
import elemental.json.JsonObject; | |||
import elemental.json.JsonValue; | |||
import elemental.json.impl.JsonUtil; | |||
/** | |||
* Handles a client-to-server message containing serialized {@link ServerRpc | |||
* server RPC} invocations. | |||
@@ -71,28 +73,31 @@ public class ServerRpcHandler implements Serializable { | |||
public static class RpcRequest implements Serializable { | |||
private final String csrfToken; | |||
private final JSONArray invocations; | |||
private final JsonArray invocations; | |||
private final int syncId; | |||
private final JSONObject json; | |||
private final JsonObject json; | |||
public RpcRequest(String jsonString, VaadinRequest request) | |||
throws JSONException { | |||
json = new JSONObject(jsonString); | |||
public RpcRequest(String jsonString, VaadinRequest request) { | |||
json = JsonUtil.parse(jsonString); | |||
String csrfToken = json.optString(ApplicationConstants.CSRF_TOKEN); | |||
if (csrfToken.equals("")) { | |||
csrfToken = ApplicationConstants.CSRF_TOKEN_DEFAULT_VALUE; | |||
JsonValue token = json.get(ApplicationConstants.CSRF_TOKEN); | |||
if (token == null) { | |||
this.csrfToken = ApplicationConstants.CSRF_TOKEN_DEFAULT_VALUE; | |||
} else { | |||
String csrfToken = token.asString(); | |||
if (csrfToken.equals("")) { | |||
csrfToken = ApplicationConstants.CSRF_TOKEN_DEFAULT_VALUE; | |||
} | |||
this.csrfToken = csrfToken; | |||
} | |||
this.csrfToken = csrfToken; | |||
if (request.getService().getDeploymentConfiguration() | |||
.isSyncIdCheckEnabled()) { | |||
syncId = json.getInt(ApplicationConstants.SERVER_SYNC_ID); | |||
syncId = (int) json.getNumber(ApplicationConstants.SERVER_SYNC_ID); | |||
} else { | |||
syncId = -1; | |||
} | |||
invocations = json | |||
.getJSONArray(ApplicationConstants.RPC_INVOCATIONS); | |||
invocations = json.getArray(ApplicationConstants.RPC_INVOCATIONS); | |||
} | |||
/** | |||
@@ -110,7 +115,7 @@ public class ServerRpcHandler implements Serializable { | |||
* @return the data describing which RPC should be made, and all their | |||
* data | |||
*/ | |||
public JSONArray getRpcInvocationsData() { | |||
public JsonArray getRpcInvocationsData() { | |||
return invocations; | |||
} | |||
@@ -134,7 +139,7 @@ public class ServerRpcHandler implements Serializable { | |||
* @return the raw JSON object that was received from the client | |||
* | |||
*/ | |||
public JSONObject getRawJson() { | |||
public JsonObject getRawJson() { | |||
return json; | |||
} | |||
} | |||
@@ -155,11 +160,9 @@ public class ServerRpcHandler implements Serializable { | |||
* @throws InvalidUIDLSecurityKeyException | |||
* If the received security key does not match the one stored in | |||
* the session. | |||
* @throws JSONException | |||
* If deserializing the JSON fails. | |||
*/ | |||
public void handleRpc(UI ui, Reader reader, VaadinRequest request) | |||
throws IOException, InvalidUIDLSecurityKeyException, JSONException { | |||
throws IOException, InvalidUIDLSecurityKeyException { | |||
ui.getSession().setLastRequestTimestamp(System.currentTimeMillis()); | |||
String changeMessage = getMessage(reader); | |||
@@ -205,7 +208,7 @@ public class ServerRpcHandler implements Serializable { | |||
* requested RPC calls. | |||
*/ | |||
private void handleInvocations(UI uI, int lastSyncIdSeenByClient, | |||
JSONArray invocationsData) { | |||
JsonArray invocationsData) { | |||
// TODO PUSH Refactor so that this is not needed | |||
LegacyCommunicationManager manager = uI.getSession() | |||
.getCommunicationManager(); | |||
@@ -314,7 +317,7 @@ public class ServerRpcHandler implements Serializable { | |||
} | |||
} | |||
} | |||
} catch (JSONException e) { | |||
} catch (JsonException e) { | |||
getLogger().warning( | |||
"Unable to parse RPC call from the client: " | |||
+ e.getMessage()); | |||
@@ -334,11 +337,10 @@ public class ServerRpcHandler implements Serializable { | |||
* the most recent sync id the client has seen at the time the | |||
* request was sent | |||
* @return list of MethodInvocation to perform | |||
* @throws JSONException | |||
*/ | |||
private List<MethodInvocation> parseInvocations( | |||
ConnectorTracker connectorTracker, JSONArray invocationsJson, | |||
int lastSyncIdSeenByClient) throws JSONException { | |||
ConnectorTracker connectorTracker, JsonArray invocationsJson, | |||
int lastSyncIdSeenByClient) { | |||
int invocationCount = invocationsJson.length(); | |||
ArrayList<MethodInvocation> invocations = new ArrayList<MethodInvocation>( | |||
invocationCount); | |||
@@ -347,7 +349,7 @@ public class ServerRpcHandler implements Serializable { | |||
// parse JSON to MethodInvocations | |||
for (int i = 0; i < invocationCount; ++i) { | |||
JSONArray invocationJson = invocationsJson.getJSONArray(i); | |||
JsonArray invocationJson = invocationsJson.getArray(i); | |||
MethodInvocation invocation = parseInvocation(invocationJson, | |||
previousInvocation, connectorTracker, | |||
@@ -363,17 +365,15 @@ public class ServerRpcHandler implements Serializable { | |||
return invocations; | |||
} | |||
private MethodInvocation parseInvocation(JSONArray invocationJson, | |||
private MethodInvocation parseInvocation(JsonArray invocationJson, | |||
MethodInvocation previousInvocation, | |||
ConnectorTracker connectorTracker, long lastSyncIdSeenByClient) | |||
throws JSONException { | |||
ConnectorTracker connectorTracker, long lastSyncIdSeenByClient) { | |||
String connectorId = invocationJson.getString(0); | |||
String interfaceName = invocationJson.getString(1); | |||
String methodName = invocationJson.getString(2); | |||
if (connectorTracker.getConnector(connectorId) == null | |||
&& !connectorId | |||
.equals(ApplicationConstants.DRAG_AND_DROP_CONNECTOR_ID)) { | |||
&& !connectorId.equals(ApplicationConstants.DRAG_AND_DROP_CONNECTOR_ID)) { | |||
if (!connectorTracker.connectorWasPresentAsRequestWasSent( | |||
connectorId, lastSyncIdSeenByClient)) { | |||
@@ -393,7 +393,7 @@ public class ServerRpcHandler implements Serializable { | |||
return null; | |||
} | |||
JSONArray parametersJson = invocationJson.getJSONArray(3); | |||
JsonArray parametersJson = invocationJson.getArray(3); | |||
if (LegacyChangeVariablesInvocation.isLegacyVariableChange( | |||
interfaceName, methodName)) { | |||
@@ -415,10 +415,9 @@ public class ServerRpcHandler implements Serializable { | |||
private LegacyChangeVariablesInvocation parseLegacyChangeVariablesInvocation( | |||
String connectorId, String interfaceName, String methodName, | |||
LegacyChangeVariablesInvocation previousInvocation, | |||
JSONArray parametersJson, ConnectorTracker connectorTracker) | |||
throws JSONException { | |||
JsonArray parametersJson, ConnectorTracker connectorTracker) { | |||
if (parametersJson.length() != 2) { | |||
throw new JSONException( | |||
throw new JsonException( | |||
"Invalid parameters in legacy change variables call. Expected 2, was " | |||
+ parametersJson.length()); | |||
} | |||
@@ -440,8 +439,8 @@ public class ServerRpcHandler implements Serializable { | |||
private ServerRpcMethodInvocation parseServerRpcInvocation( | |||
String connectorId, String interfaceName, String methodName, | |||
JSONArray parametersJson, ConnectorTracker connectorTracker) | |||
throws JSONException { | |||
JsonArray parametersJson, ConnectorTracker connectorTracker) | |||
throws JsonException { | |||
ClientConnector connector = connectorTracker.getConnector(connectorId); | |||
ServerRpcManager<?> rpcManager = connector.getRpcManager(interfaceName); | |||
@@ -471,7 +470,7 @@ public class ServerRpcHandler implements Serializable { | |||
.getGenericParameterTypes(); | |||
for (int j = 0; j < parametersJson.length(); ++j) { | |||
Object parameterValue = parametersJson.get(j); | |||
JsonValue parameterValue = parametersJson.get(j); | |||
Type parameterType = declaredRpcMethodParameterTypes[j]; | |||
parameters[j] = JsonCodec.decodeInternalOrCustomType(parameterType, | |||
parameterValue, connectorTracker); |
@@ -21,14 +21,16 @@ import java.io.Serializable; | |||
import java.io.Writer; | |||
import java.util.Collection; | |||
import org.json.JSONException; | |||
import org.json.JSONObject; | |||
import com.vaadin.server.ClientConnector; | |||
import com.vaadin.server.PaintException; | |||
import com.vaadin.shared.communication.SharedState; | |||
import com.vaadin.ui.UI; | |||
import elemental.json.Json; | |||
import elemental.json.JsonException; | |||
import elemental.json.JsonObject; | |||
import elemental.json.impl.JsonUtil; | |||
/** | |||
* Serializes {@link SharedState shared state} changes to JSON. | |||
* | |||
@@ -53,16 +55,16 @@ public class SharedStateWriter implements Serializable { | |||
Collection<ClientConnector> dirtyVisibleConnectors = ui | |||
.getConnectorTracker().getDirtyVisibleConnectors(); | |||
JSONObject sharedStates = new JSONObject(); | |||
JsonObject sharedStates = Json.createObject(); | |||
for (ClientConnector connector : dirtyVisibleConnectors) { | |||
// encode and send shared state | |||
try { | |||
JSONObject stateJson = connector.encodeState(); | |||
JsonObject stateJson = connector.encodeState(); | |||
if (stateJson != null && stateJson.length() != 0) { | |||
if (stateJson != null && stateJson.keys().length != 0) { | |||
sharedStates.put(connector.getConnectorId(), stateJson); | |||
} | |||
} catch (JSONException e) { | |||
} catch (JsonException e) { | |||
throw new PaintException( | |||
"Failed to serialize shared state for connector " | |||
+ connector.getClass().getName() + " (" | |||
@@ -70,6 +72,6 @@ public class SharedStateWriter implements Serializable { | |||
+ e.getMessage(), e); | |||
} | |||
} | |||
writer.write(sharedStates.toString()); | |||
writer.write(JsonUtil.stringify(sharedStates)); | |||
} | |||
} |
@@ -23,9 +23,6 @@ import java.util.List; | |||
import java.util.logging.Level; | |||
import java.util.logging.Logger; | |||
import org.json.JSONException; | |||
import org.json.JSONObject; | |||
import com.vaadin.annotations.PreserveOnRefresh; | |||
import com.vaadin.server.LegacyApplicationUIProvider; | |||
import com.vaadin.server.SynchronizedRequestHandler; | |||
@@ -43,6 +40,11 @@ import com.vaadin.shared.ui.ui.Transport; | |||
import com.vaadin.shared.ui.ui.UIConstants; | |||
import com.vaadin.ui.UI; | |||
import elemental.json.Json; | |||
import elemental.json.JsonException; | |||
import elemental.json.JsonObject; | |||
import elemental.json.impl.JsonUtil; | |||
/** | |||
* Handles an initial request from the client to initialize a {@link UI}. | |||
* | |||
@@ -75,13 +77,13 @@ public abstract class UIInitHandler extends SynchronizedRequestHandler { | |||
session.getCommunicationManager().repaintAll(uI); | |||
JSONObject params = new JSONObject(); | |||
JsonObject params = Json.createObject(); | |||
params.put(UIConstants.UI_ID_PARAMETER, uI.getUIId()); | |||
String initialUIDL = getInitialUidl(request, uI); | |||
params.put("uidl", initialUIDL); | |||
stringWriter.write(params.toString()); | |||
} catch (JSONException e) { | |||
stringWriter.write(JsonUtil.stringify(params)); | |||
} catch (JsonException e) { | |||
throw new IOException("Error producing initial UIDL", e); | |||
} finally { | |||
stringWriter.close(); | |||
@@ -278,12 +280,10 @@ public abstract class UIInitHandler extends SynchronizedRequestHandler { | |||
* @param uI | |||
* the UI for which the UIDL should be generated | |||
* @return a string with the initial UIDL message | |||
* @throws JSONException | |||
* if an exception occurs while encoding output | |||
* @throws IOException | |||
*/ | |||
protected String getInitialUidl(VaadinRequest request, UI uI) | |||
throws JSONException, IOException { | |||
throws IOException { | |||
StringWriter writer = new StringWriter(); | |||
try { | |||
writer.write("{"); |
@@ -22,8 +22,6 @@ import java.io.Writer; | |||
import java.util.logging.Level; | |||
import java.util.logging.Logger; | |||
import org.json.JSONException; | |||
import com.vaadin.server.Constants; | |||
import com.vaadin.server.LegacyCommunicationManager.InvalidUIDLSecurityKeyException; | |||
import com.vaadin.server.ServletPortletHelper; | |||
@@ -38,6 +36,7 @@ import com.vaadin.shared.ApplicationConstants; | |||
import com.vaadin.shared.JsonConstants; | |||
import com.vaadin.shared.Version; | |||
import com.vaadin.ui.UI; | |||
import elemental.json.JsonException; | |||
/** | |||
* Processes a UIDL request from the client. | |||
@@ -97,7 +96,7 @@ public class UidlRequestHandler extends SynchronizedRequestHandler implements | |||
} | |||
writeUidl(request, response, uI, stringWriter, repaintAll); | |||
} catch (JSONException e) { | |||
} catch (JsonException e) { | |||
getLogger().log(Level.SEVERE, "Error writing JSON to response", e); | |||
// Refresh on client side | |||
response.getWriter().write( | |||
@@ -144,8 +143,7 @@ public class UidlRequestHandler extends SynchronizedRequestHandler implements | |||
} | |||
private void writeUidl(VaadinRequest request, VaadinResponse response, | |||
UI ui, Writer writer, boolean repaintAll) throws IOException, | |||
JSONException { | |||
UI ui, Writer writer, boolean repaintAll) throws IOException { | |||
openJsonMessage(writer, response); | |||
new UidlWriter().write(ui, writer, repaintAll, false); |
@@ -27,9 +27,6 @@ import java.util.List; | |||
import java.util.logging.Level; | |||
import java.util.logging.Logger; | |||
import org.json.JSONArray; | |||
import org.json.JSONException; | |||
import com.vaadin.annotations.JavaScript; | |||
import com.vaadin.annotations.StyleSheet; | |||
import com.vaadin.server.ClientConnector; | |||
@@ -43,6 +40,10 @@ import com.vaadin.shared.ApplicationConstants; | |||
import com.vaadin.ui.ConnectorTracker; | |||
import com.vaadin.ui.UI; | |||
import elemental.json.Json; | |||
import elemental.json.JsonArray; | |||
import elemental.json.impl.JsonUtil; | |||
/** | |||
* Serializes pending server-side changes to UI state to JSON. This includes | |||
* shared state, client RPC invocations, connector hierarchy changes, connector | |||
@@ -70,11 +71,9 @@ public class UidlWriter implements Serializable { | |||
* | |||
* @throws IOException | |||
* If the writing fails. | |||
* @throws JSONException | |||
* If the JSON serialization fails. | |||
*/ | |||
public void write(UI ui, Writer writer, boolean repaintAll, boolean async) | |||
throws IOException, JSONException { | |||
throws IOException { | |||
VaadinSession session = ui.getSession(); | |||
VaadinService service = session.getService(); | |||
@@ -282,13 +281,13 @@ public class UidlWriter implements Serializable { | |||
// Include script dependencies in output if there are any | |||
if (!scriptDependencies.isEmpty()) { | |||
writer.write(", \"scriptDependencies\": " | |||
+ new JSONArray(scriptDependencies).toString()); | |||
+ JsonUtil.stringify(toJsonArray(scriptDependencies))); | |||
} | |||
// Include style dependencies in output if there are any | |||
if (!styleDependencies.isEmpty()) { | |||
writer.write(", \"styleDependencies\": " | |||
+ new JSONArray(styleDependencies).toString()); | |||
+ JsonUtil.stringify(toJsonArray(styleDependencies))); | |||
} | |||
session.getDragAndDropService().printJSONResponse(writer); | |||
@@ -306,6 +305,15 @@ public class UidlWriter implements Serializable { | |||
} | |||
} | |||
private JsonArray toJsonArray(List<String> list) { | |||
JsonArray result = Json.createArray(); | |||
for (int i = 0; i < list.size(); i++) { | |||
result.set(i, list.get(i)); | |||
} | |||
return result; | |||
} | |||
/** | |||
* Adds the performance timing data (used by TestBench 3) to the UIDL | |||
* response. |
@@ -19,8 +19,6 @@ package com.vaadin.ui; | |||
import java.io.Serializable; | |||
import java.lang.reflect.Method; | |||
import org.json.JSONException; | |||
import com.vaadin.event.Action; | |||
import com.vaadin.event.FieldEvents; | |||
import com.vaadin.event.FieldEvents.BlurEvent; | |||
@@ -63,12 +61,8 @@ public class Button extends AbstractComponent implements | |||
// Makes sure the enabled=false state is noticed at once - otherwise | |||
// a following setEnabled(true) call might have no effect. see | |||
// ticket #10030 | |||
try { | |||
getUI().getConnectorTracker().getDiffState(Button.this) | |||
.put("enabled", false); | |||
} catch (JSONException e) { | |||
throw new RuntimeException(e); | |||
} | |||
getUI().getConnectorTracker().getDiffState(Button.this) | |||
.put("enabled", false); | |||
} | |||
}; | |||
@@ -16,8 +16,6 @@ | |||
package com.vaadin.ui; | |||
import org.json.JSONException; | |||
import com.vaadin.data.Property; | |||
import com.vaadin.event.FieldEvents.BlurEvent; | |||
import com.vaadin.event.FieldEvents.BlurListener; | |||
@@ -47,12 +45,8 @@ public class CheckBox extends AbstractField<Boolean> { | |||
* | |||
* See #11028, #10030. | |||
*/ | |||
try { | |||
getUI().getConnectorTracker().getDiffState(CheckBox.this) | |||
.put("checked", checked); | |||
} catch (JSONException e) { | |||
throw new RuntimeException(e); | |||
} | |||
getUI().getConnectorTracker().getDiffState(CheckBox.this) | |||
.put("checked", checked); | |||
final Boolean oldValue = getValue(); | |||
final Boolean newValue = checked; |
@@ -30,9 +30,6 @@ import java.util.UUID; | |||
import java.util.logging.Level; | |||
import java.util.logging.Logger; | |||
import org.json.JSONException; | |||
import org.json.JSONObject; | |||
import com.vaadin.server.AbstractClientConnector; | |||
import com.vaadin.server.ClientConnector; | |||
import com.vaadin.server.DragAndDropService; | |||
@@ -40,6 +37,10 @@ import com.vaadin.server.GlobalResourceHandler; | |||
import com.vaadin.server.LegacyCommunicationManager; | |||
import com.vaadin.server.StreamVariable; | |||
import elemental.json.Json; | |||
import elemental.json.JsonException; | |||
import elemental.json.JsonObject; | |||
/** | |||
* A class which takes care of book keeping of {@link ClientConnector}s for a | |||
* UI. | |||
@@ -76,7 +77,7 @@ public class ConnectorTracker implements Serializable { | |||
private boolean writingResponse = false; | |||
private UI uI; | |||
private transient Map<ClientConnector, JSONObject> diffStates = new HashMap<ClientConnector, JSONObject>(); | |||
private transient Map<ClientConnector, JsonObject> diffStates = new HashMap<ClientConnector, JsonObject>(); | |||
/** Maps connectorIds to a map of named StreamVariables */ | |||
private Map<String, Map<String, StreamVariable>> pidToNameToStreamVariable; | |||
@@ -556,12 +557,12 @@ public class ConnectorTracker implements Serializable { | |||
return dirtyVisibleConnectors; | |||
} | |||
public JSONObject getDiffState(ClientConnector connector) { | |||
public JsonObject getDiffState(ClientConnector connector) { | |||
assert getConnector(connector.getConnectorId()) == connector; | |||
return diffStates.get(connector); | |||
} | |||
public void setDiffState(ClientConnector connector, JSONObject diffState) { | |||
public void setDiffState(ClientConnector connector, JsonObject diffState) { | |||
assert getConnector(connector.getConnectorId()) == connector; | |||
diffStates.put(connector, diffState); | |||
} | |||
@@ -621,11 +622,11 @@ public class ConnectorTracker implements Serializable { | |||
this.writingResponse = writingResponse; | |||
} | |||
/* Special serialization to JSONObjects which are not serializable */ | |||
/* Special serialization to JsonObjects which are not serializable */ | |||
private void writeObject(java.io.ObjectOutputStream out) throws IOException { | |||
out.defaultWriteObject(); | |||
// Convert JSONObjects in diff state to String representation as | |||
// JSONObject is not serializable | |||
// Convert JsonObjects in diff state to String representation as | |||
// JsonObject is not serializable | |||
HashMap<ClientConnector, String> stringDiffStates = new HashMap<ClientConnector, String>( | |||
diffStates.size() * 2); | |||
for (ClientConnector key : diffStates.keySet()) { | |||
@@ -634,23 +635,23 @@ public class ConnectorTracker implements Serializable { | |||
out.writeObject(stringDiffStates); | |||
} | |||
/* Special serialization to JSONObjects which are not serializable */ | |||
/* Special serialization to JsonObjects which are not serializable */ | |||
private void readObject(java.io.ObjectInputStream in) throws IOException, | |||
ClassNotFoundException { | |||
in.defaultReadObject(); | |||
// Read String versions of JSONObjects and parse into JSONObjects as | |||
// JSONObject is not serializable | |||
diffStates = new HashMap<ClientConnector, JSONObject>(); | |||
// Read String versions of JsonObjects and parse into JsonObjects as | |||
// JsonObject is not serializable | |||
diffStates = new HashMap<ClientConnector, JsonObject>(); | |||
@SuppressWarnings("unchecked") | |||
HashMap<ClientConnector, String> stringDiffStates = (HashMap<ClientConnector, String>) in | |||
.readObject(); | |||
diffStates = new HashMap<ClientConnector, JSONObject>( | |||
diffStates = new HashMap<ClientConnector, JsonObject>( | |||
stringDiffStates.size() * 2); | |||
for (ClientConnector key : stringDiffStates.keySet()) { | |||
try { | |||
diffStates.put(key, new JSONObject(stringDiffStates.get(key))); | |||
} catch (JSONException e) { | |||
diffStates.put(key, Json.parse(stringDiffStates.get(key))); | |||
} catch (JsonException e) { | |||
throw new IOException(e); | |||
} | |||
} |
@@ -19,15 +19,15 @@ package com.vaadin.ui; | |||
import java.util.HashMap; | |||
import java.util.Map; | |||
import org.json.JSONArray; | |||
import org.json.JSONException; | |||
import com.vaadin.server.AbstractExtension; | |||
import com.vaadin.server.Page; | |||
import com.vaadin.shared.communication.ServerRpc; | |||
import com.vaadin.shared.extension.javascriptmanager.ExecuteJavaScriptRpc; | |||
import com.vaadin.shared.extension.javascriptmanager.JavaScriptManagerState; | |||
import elemental.json.JsonArray; | |||
import elemental.json.JsonException; | |||
/** | |||
* Provides access to JavaScript functionality in the web browser. To get an | |||
* instance of JavaScript, either use Page.getJavaScript() or | |||
@@ -43,7 +43,7 @@ public class JavaScript extends AbstractExtension { | |||
// Can not be defined in client package as this JSONArray is not available | |||
// in GWT | |||
public interface JavaScriptCallbackRpc extends ServerRpc { | |||
public void call(String name, JSONArray arguments); | |||
public void call(String name, JsonArray arguments); | |||
} | |||
/** | |||
@@ -54,12 +54,12 @@ public class JavaScript extends AbstractExtension { | |||
public JavaScript() { | |||
registerRpc(new JavaScriptCallbackRpc() { | |||
@Override | |||
public void call(String name, JSONArray arguments) { | |||
public void call(String name, JsonArray arguments) { | |||
JavaScriptFunction function = functions.get(name); | |||
// TODO handle situation if name is not registered | |||
try { | |||
function.call(arguments); | |||
} catch (JSONException e) { | |||
} catch (JsonException e) { | |||
throw new IllegalArgumentException(e); | |||
} | |||
} |
@@ -18,14 +18,12 @@ package com.vaadin.ui; | |||
import java.io.Serializable; | |||
import org.json.JSONArray; | |||
import org.json.JSONException; | |||
import com.vaadin.server.AbstractJavaScriptExtension; | |||
import elemental.json.JsonArray; | |||
/** | |||
* Defines a method that is called by a client-side JavaScript function. When | |||
* the corresponding JavaScript function is called, the {@link #call(JSONArray)} | |||
* the corresponding JavaScript function is called, the {@link #call(JsonArray)} | |||
* method is invoked. | |||
* | |||
* @see JavaScript#addFunction(String, JavaScriptCallback) | |||
@@ -46,8 +44,6 @@ public interface JavaScriptFunction extends Serializable { | |||
* @param arguments | |||
* an array with JSON representations of the arguments with which | |||
* the JavaScript function was called. | |||
* @throws JSONException | |||
* if the arguments can not be interpreted | |||
*/ | |||
public void call(JSONArray arguments) throws JSONException; | |||
public void call(JsonArray arguments); | |||
} |
@@ -16,8 +16,6 @@ | |||
package com.vaadin.ui; | |||
import org.json.JSONException; | |||
import com.vaadin.shared.ui.slider.SliderOrientation; | |||
import com.vaadin.shared.ui.slider.SliderServerRpc; | |||
import com.vaadin.shared.ui.slider.SliderState; | |||
@@ -42,12 +40,8 @@ public class Slider extends AbstractField<Double> { | |||
* | |||
* See #12133. | |||
*/ | |||
try { | |||
getUI().getConnectorTracker().getDiffState(Slider.this) | |||
.put("value", value); | |||
} catch (JSONException e) { | |||
throw new RuntimeException(e); | |||
} | |||
getUI().getConnectorTracker().getDiffState(Slider.this) | |||
.put("value", value); | |||
try { | |||
setValue(value, true); |
@@ -15,8 +15,8 @@ package com.vaadin.server; | |||
* License for the specific language governing permissions and limitations under | |||
* the License. | |||
*/ | |||
import java.lang.reflect.Type; | |||
import java.util.Arrays; | |||
import java.util.Collection; | |||
import java.util.HashMap; | |||
import java.util.Map; | |||
@@ -24,14 +24,15 @@ import java.util.Map; | |||
import junit.framework.AssertionFailedError; | |||
import junit.framework.TestCase; | |||
import org.json.JSONArray; | |||
import org.json.JSONException; | |||
import org.json.JSONObject; | |||
import com.vaadin.server.JsonCodec.BeanProperty; | |||
import com.vaadin.shared.communication.UidlValue; | |||
import com.vaadin.shared.ui.splitpanel.AbstractSplitPanelState; | |||
import elemental.json.Json; | |||
import elemental.json.JsonArray; | |||
import elemental.json.JsonException; | |||
import elemental.json.JsonValue; | |||
/** | |||
* Tests for {@link JsonCodec} | |||
* | |||
@@ -39,7 +40,7 @@ import com.vaadin.shared.ui.splitpanel.AbstractSplitPanelState; | |||
* @since 7.0 | |||
* | |||
*/ | |||
public class JSONSerializerTest extends TestCase { | |||
public class JsonSerializerTest extends TestCase { | |||
HashMap<String, AbstractSplitPanelState> stringToStateMap; | |||
HashMap<AbstractSplitPanelState, String> stateToStringMap; | |||
@@ -56,7 +57,7 @@ public class JSONSerializerTest extends TestCase { | |||
stringToStateMap.put("string - state 1", s); | |||
stringToStateMap.put("String - state 2", s2); | |||
Object encodedMap = JsonCodec.encode(stringToStateMap, null, mapType, | |||
JsonValue encodedMap = JsonCodec.encode(stringToStateMap, null, mapType, | |||
null).getEncodedValue(); | |||
ensureDecodedCorrectly(stringToStateMap, encodedMap, mapType); | |||
@@ -73,15 +74,16 @@ public class JSONSerializerTest extends TestCase { | |||
stateToStringMap.put(s, "string - state 1"); | |||
stateToStringMap.put(s2, "String - state 2"); | |||
Object encodedMap = JsonCodec.encode(stateToStringMap, null, mapType, | |||
JsonValue encodedMap = JsonCodec.encode(stateToStringMap, null, mapType, | |||
null).getEncodedValue(); | |||
ensureDecodedCorrectly(stateToStringMap, encodedMap, mapType); | |||
} | |||
public void testNullLegacyValue() throws JSONException { | |||
JSONArray inputArray = new JSONArray( | |||
Arrays.asList("n", JSONObject.NULL)); | |||
public void testNullLegacyValue() throws JsonException { | |||
JsonArray inputArray = Json.createArray(); | |||
inputArray.set(0, "n"); | |||
inputArray.set(1, Json.createNull()); | |||
UidlValue decodedObject = (UidlValue) JsonCodec.decodeInternalType( | |||
UidlValue.class, true, inputArray, null); | |||
assertNull(decodedObject.getValue()); | |||
@@ -89,17 +91,19 @@ public class JSONSerializerTest extends TestCase { | |||
public void testNullTypeOtherValue() { | |||
try { | |||
JSONArray inputArray = new JSONArray(Arrays.asList("n", "a")); | |||
JsonArray inputArray = Json.createArray(); | |||
inputArray.set(0, "n"); | |||
inputArray.set(1, "a"); | |||
UidlValue decodedObject = (UidlValue) JsonCodec.decodeInternalType( | |||
UidlValue.class, true, inputArray, null); | |||
throw new AssertionFailedError("No JSONException thrown"); | |||
} catch (JSONException e) { | |||
throw new AssertionFailedError("No JsonException thrown"); | |||
} catch (JsonException e) { | |||
// Should throw exception | |||
} | |||
} | |||
private void ensureDecodedCorrectly(Object original, Object encoded, | |||
private void ensureDecodedCorrectly(Object original, JsonValue encoded, | |||
Type type) throws Exception { | |||
Object serverSideDecoded = JsonCodec.decodeInternalOrCustomType(type, | |||
encoded, null); |
@@ -22,7 +22,6 @@ import java.util.logging.Logger; | |||
import javax.servlet.http.HttpServletRequest; | |||
import org.easymock.EasyMock; | |||
import org.json.JSONException; | |||
import org.junit.Assert; | |||
import org.junit.Before; | |||
import org.junit.Test; | |||
@@ -37,6 +36,7 @@ import com.vaadin.server.communication.ServerRpcHandler.RpcRequest; | |||
import com.vaadin.shared.ApplicationConstants; | |||
import com.vaadin.tests.util.AlwaysLockedVaadinSession; | |||
import com.vaadin.tests.util.MockDeploymentConfiguration; | |||
import elemental.json.JsonException; | |||
/** | |||
* Test the actual csrf token validation by the server. | |||
@@ -141,7 +141,7 @@ public class CsrfTokenMissingTestServer { | |||
private RpcRequest createRequest() { | |||
try { | |||
return new RpcRequest(getPayload(), vaadinRequest); | |||
} catch (JSONException e) { | |||
} catch (JsonException e) { | |||
LOGGER.log(Level.SEVERE, "", e); | |||
Assert.assertTrue(false); |
@@ -51,7 +51,7 @@ public class TestClassesSerializable extends TestCase { | |||
"com\\.vaadin\\.server\\.communication\\.PushRequestHandler.*", | |||
"com\\.vaadin\\.server\\.communication\\.PushHandler.*", // PushHandler | |||
"com\\.vaadin\\.server\\.communication\\.DateSerializer", // | |||
"com\\.vaadin\\.server\\.communication\\.JSONSerializer", // | |||
"com\\.vaadin\\.server\\.communication\\.JsonSerializer", // | |||
// and its inner classes do not need to be serializable | |||
"com\\.vaadin\\.util\\.SerializerHelper", // fully static | |||
// class level filtering, also affecting nested classes and |
@@ -21,22 +21,23 @@ import java.io.ObjectInputStream; | |||
import java.io.ObjectOutputStream; | |||
import java.io.Serializable; | |||
import java.lang.reflect.Method; | |||
import java.util.Arrays; | |||
import junit.framework.TestCase; | |||
import org.json.JSONArray; | |||
import com.vaadin.server.ClientMethodInvocation; | |||
import com.vaadin.server.JavaScriptCallbackHelper; | |||
import com.vaadin.ui.JavaScript.JavaScriptCallbackRpc; | |||
import com.vaadin.util.ReflectTools; | |||
import elemental.json.Json; | |||
import elemental.json.JsonArray; | |||
import elemental.json.impl.JsonUtil; | |||
public class TestClientMethodSerialization extends TestCase { | |||
private static final Method JAVASCRIPT_CALLBACK_METHOD = ReflectTools | |||
.findMethod(JavaScriptCallbackRpc.class, "call", String.class, | |||
JSONArray.class); | |||
JsonArray.class); | |||
private static final Method BASIC_PARAMS_CALL_METHOD = ReflectTools | |||
.findMethod(TestClientMethodSerialization.class, | |||
@@ -60,15 +61,17 @@ public class TestClientMethodSerialization extends TestCase { | |||
*/ | |||
public void testClientMethodSerialization_WithJSONArray_ContentStaysSame() | |||
throws Exception { | |||
JSONArray originalArray = new JSONArray(Arrays.asList( | |||
"callbackParameter1", "callBackParameter2", "12345")); | |||
JsonArray originalArray = Json.createArray(); | |||
originalArray.set(0, "callbackParameter1"); | |||
originalArray.set(1, "callBackParameter2"); | |||
originalArray.set(2, "12345"); | |||
ClientMethodInvocation original = new ClientMethodInvocation(null, | |||
"interfaceName", JAVASCRIPT_CALLBACK_METHOD, new Object[] { | |||
"callBackMethodName", originalArray }); | |||
ClientMethodInvocation copy = (ClientMethodInvocation) serializeAndDeserialize(original); | |||
JSONArray copyArray = (JSONArray) copy.getParameters()[1]; | |||
assertEquals(originalArray.toString(), copyArray.toString()); | |||
JsonArray copyArray = (JsonArray) copy.getParameters()[1]; | |||
assertEquals(JsonUtil.stringify(originalArray), JsonUtil.stringify(copyArray)); | |||
} | |||
public void testClientMethodSerialization_WithBasicParams_NoChanges() |
@@ -27,8 +27,6 @@ | |||
conf="build,ide,test->default" /> | |||
<dependency org="com.vaadin.external.google" name="guava" | |||
rev="16.0.1.vaadin1" conf="build,ide,test->default" /> | |||
<dependency org="com.vaadin.external.json" name="json" | |||
rev="0.0.20080701" conf="build,ide,test->default" /> | |||
<dependency org="junit" name="junit" rev="4.11" | |||
conf="test,ide -> default" /> | |||
@@ -19,9 +19,6 @@ import java.util.ArrayList; | |||
import java.util.Arrays; | |||
import java.util.List; | |||
import org.json.JSONArray; | |||
import org.json.JSONException; | |||
import com.vaadin.annotations.JavaScript; | |||
import com.vaadin.server.ConnectorResource; | |||
import com.vaadin.server.DownloadStream; | |||
@@ -39,6 +36,7 @@ import com.vaadin.ui.Button; | |||
import com.vaadin.ui.Button.ClickEvent; | |||
import com.vaadin.ui.HasComponents; | |||
import com.vaadin.ui.JavaScriptFunction; | |||
import elemental.json.JsonArray; | |||
public class BasicJavaScriptComponent extends AbstractTestUI { | |||
@@ -78,15 +76,15 @@ public class BasicJavaScriptComponent extends AbstractTestUI { | |||
}); | |||
addFunction("messageToServer", new JavaScriptFunction() { | |||
@Override | |||
public void call(JSONArray arguments) throws JSONException { | |||
public void call(JsonArray arguments) { | |||
log.log("Got callback message: " + arguments.getString(0)); | |||
} | |||
}); | |||
addFunction("reportParentIds", new JavaScriptFunction() { | |||
@Override | |||
public void call(JSONArray arguments) throws JSONException { | |||
JSONArray parentIds = arguments.getJSONArray(0); | |||
public void call(JsonArray arguments) { | |||
JsonArray parentIds = arguments.getArray(0); | |||
if (!parentIds.getString(0).equals(getConnectorId())) { | |||
log.log("Connector ids doesn't match"); | |||
} |
@@ -19,8 +19,6 @@ package com.vaadin.tests.components.table; | |||
import java.util.ArrayList; | |||
import java.util.Collection; | |||
import org.json.JSONObject; | |||
import com.vaadin.annotations.Push; | |||
import com.vaadin.server.ClientConnector; | |||
import com.vaadin.server.StreamVariable; | |||
@@ -30,6 +28,7 @@ import com.vaadin.ui.Button; | |||
import com.vaadin.ui.Button.ClickEvent; | |||
import com.vaadin.ui.ConnectorTracker; | |||
import com.vaadin.ui.Table; | |||
import elemental.json.JsonObject; | |||
@Push | |||
public class TableRemovedQuicklySendsInvalidRpcCalls extends AbstractTestUI { | |||
@@ -125,12 +124,12 @@ public class TableRemovedQuicklySendsInvalidRpcCalls extends AbstractTestUI { | |||
} | |||
@Override | |||
public JSONObject getDiffState(ClientConnector connector) { | |||
public JsonObject getDiffState(ClientConnector connector) { | |||
return tracker.getDiffState(connector); | |||
} | |||
@Override | |||
public void setDiffState(ClientConnector connector, JSONObject diffState) { | |||
public void setDiffState(ClientConnector connector, JsonObject diffState) { | |||
tracker.setDiffState(connector, diffState); | |||
} | |||
@@ -16,16 +16,15 @@ | |||
package com.vaadin.tests.extensions; | |||
import org.json.JSONArray; | |||
import org.json.JSONException; | |||
import org.json.JSONObject; | |||
import com.vaadin.server.VaadinRequest; | |||
import com.vaadin.tests.components.AbstractTestUI; | |||
import com.vaadin.tests.util.Log; | |||
import com.vaadin.ui.JavaScript; | |||
import com.vaadin.ui.JavaScriptFunction; | |||
import elemental.json.JsonArray; | |||
import elemental.json.JsonNull; | |||
public class JavascriptManagerTest extends AbstractTestUI { | |||
private Log log = new Log(5); | |||
@@ -36,14 +35,14 @@ public class JavascriptManagerTest extends AbstractTestUI { | |||
final JavaScript js = JavaScript.getCurrent(); | |||
js.addFunction("testing.doTest", new JavaScriptFunction() { | |||
@Override | |||
public void call(JSONArray arguments) throws JSONException { | |||
public void call(JsonArray arguments) { | |||
log.log("Got " + arguments.length() + " arguments"); | |||
log.log("Argument 1 as a number: " + arguments.getInt(0)); | |||
log.log("Argument 1 as a number: " + (int) arguments.getNumber(0)); | |||
log.log("Argument 2 as a string: " + arguments.getString(1)); | |||
log.log("Argument 3.p as a boolean: " | |||
+ arguments.getJSONObject(2).getBoolean("p")); | |||
+ arguments.getObject(2).getBoolean("p")); | |||
log.log("Argument 4 is JSONObject.NULL: " | |||
+ (arguments.get(3) == JSONObject.NULL)); | |||
+ (arguments.get(3) instanceof JsonNull)); | |||
js.removeFunction("testing.doTest"); | |||
} | |||
}); |
@@ -16,9 +16,6 @@ | |||
package com.vaadin.tests.extensions; | |||
import org.json.JSONArray; | |||
import org.json.JSONException; | |||
import com.vaadin.annotations.JavaScript; | |||
import com.vaadin.annotations.StyleSheet; | |||
import com.vaadin.server.AbstractJavaScriptExtension; | |||
@@ -31,6 +28,7 @@ import com.vaadin.ui.Button; | |||
import com.vaadin.ui.Button.ClickEvent; | |||
import com.vaadin.ui.JavaScriptFunction; | |||
import com.vaadin.ui.Notification; | |||
import elemental.json.JsonArray; | |||
public class SimpleJavaScriptExtensionTest extends AbstractTestUI { | |||
@@ -71,7 +69,7 @@ public class SimpleJavaScriptExtensionTest extends AbstractTestUI { | |||
}); | |||
addFunction("greetToServer", new JavaScriptFunction() { | |||
@Override | |||
public void call(JSONArray arguments) throws JSONException { | |||
public void call(JsonArray arguments) { | |||
Notification.show(getState().getPrefix() | |||
+ arguments.getString(0)); | |||
} |
@@ -20,13 +20,11 @@ import java.util.ArrayList; | |||
import java.util.Arrays; | |||
import java.util.List; | |||
import org.json.JSONArray; | |||
import org.json.JSONException; | |||
import com.vaadin.annotations.JavaScript; | |||
import com.vaadin.ui.AbstractJavaScriptComponent; | |||
import com.vaadin.ui.JavaScriptFunction; | |||
import com.vaadin.ui.Notification; | |||
import elemental.json.JsonArray; | |||
@JavaScript({ | |||
"https://ajax.googleapis.com/ajax/libs/jquery/1.7.2/jquery.min.js", | |||
@@ -42,9 +40,9 @@ public class Flot extends AbstractJavaScriptComponent { | |||
}); | |||
addFunction("onPlotClick", new JavaScriptFunction() { | |||
@Override | |||
public void call(JSONArray arguments) throws JSONException { | |||
int seriesIndex = arguments.getInt(0); | |||
int dataIndex = arguments.getInt(1); | |||
public void call(JsonArray arguments) { | |||
int seriesIndex = (int) arguments.getNumber(0); | |||
int dataIndex = (int) arguments.getNumber(1); | |||
Notification.show("Clicked on [" + seriesIndex + ", " | |||
+ dataIndex + "]"); | |||
} |
@@ -1,8 +1,5 @@ | |||
package com.vaadin.tests.minitutorials.v7a3; | |||
import org.json.JSONArray; | |||
import org.json.JSONException; | |||
import com.vaadin.server.ExternalResource; | |||
import com.vaadin.server.VaadinRequest; | |||
import com.vaadin.ui.JavaScript; | |||
@@ -12,6 +9,9 @@ import com.vaadin.ui.Notification; | |||
import com.vaadin.ui.Notification.Type; | |||
import com.vaadin.ui.UI; | |||
import elemental.json.JsonArray; | |||
import elemental.json.JsonException; | |||
public class JSAPIUI extends UI { | |||
@Override | |||
public void init(VaadinRequest request) { | |||
@@ -19,7 +19,7 @@ public class JSAPIUI extends UI { | |||
JavaScript.getCurrent().addFunction("com.example.api.notify", | |||
new JavaScriptFunction() { | |||
@Override | |||
public void call(JSONArray arguments) throws JSONException { | |||
public void call(JsonArray arguments) { | |||
try { | |||
String caption = arguments.getString(0); | |||
if (arguments.length() == 1) { | |||
@@ -28,10 +28,10 @@ public class JSAPIUI extends UI { | |||
} else { | |||
// type should be in [1] | |||
Notification.show(caption, | |||
Type.values()[arguments.getInt(1)]); | |||
Type.values()[((int) arguments.getNumber(1))]); | |||
} | |||
} catch (JSONException e) { | |||
} catch (JsonException e) { | |||
// We'll log in the console, you might not want to | |||
JavaScript.getCurrent().execute( | |||
"console.error('" + e.getMessage() + "')"); |
@@ -23,8 +23,6 @@ import java.net.URL; | |||
import javax.servlet.ServletContext; | |||
import org.apache.commons.io.IOUtils; | |||
import org.json.JSONArray; | |||
import org.json.JSONException; | |||
import com.vaadin.annotations.JavaScript; | |||
import com.vaadin.server.VaadinRequest; | |||
@@ -32,6 +30,7 @@ import com.vaadin.server.VaadinService; | |||
import com.vaadin.server.VaadinServletService; | |||
import com.vaadin.tests.components.AbstractTestUIWithLog; | |||
import com.vaadin.ui.JavaScriptFunction; | |||
import elemental.json.JsonArray; | |||
// Load vaadinPush.js so that jQueryVaadin is defined | |||
@JavaScript("vaadin://vaadinPush.debug.js") | |||
@@ -58,7 +57,7 @@ public class TrackMessageSizeUI extends AbstractTestUIWithLog { | |||
getPage().getJavaScript().addFunction("logToServer", | |||
new JavaScriptFunction() { | |||
@Override | |||
public void call(JSONArray arguments) throws JSONException { | |||
public void call(JsonArray arguments) { | |||
String message = arguments.getString(0); | |||
log(message); | |||
} |
@@ -86,9 +86,8 @@ public class SerializerTestTest extends MultiBrowserTest { | |||
getLogRow(logRow++)); | |||
Assert.assertEquals("state.floatArray: [57, 0, -12]", | |||
getLogRow(logRow++)); | |||
Assert.assertEquals("state.floatObjectValue: 1.0000001", | |||
getLogRow(logRow++)); | |||
Assert.assertEquals("state.floatValue: 3.14159", getLogRow(logRow++)); | |||
Assert.assertTrue(getLogRow(logRow++).startsWith("state.floatObjectValue: 1.0000001")); | |||
Assert.assertTrue(getLogRow(logRow++).startsWith("state.floatValue: 3.14159")); | |||
Assert.assertEquals("state.longArray: [-57841235865, 57]", | |||
getLogRow(logRow++)); | |||
Assert.assertEquals("state.longObjectValue: 577431841360", |
@@ -30,13 +30,13 @@ import java.net.URL; | |||
import java.util.Collections; | |||
import java.util.List; | |||
import elemental.json.JsonObject; | |||
import elemental.json.impl.JsonUtil; | |||
import org.apache.commons.io.IOUtils; | |||
import org.apache.http.HttpHost; | |||
import org.apache.http.HttpResponse; | |||
import org.apache.http.impl.client.DefaultHttpClient; | |||
import org.apache.http.message.BasicHttpEntityEnclosingRequest; | |||
import org.json.JSONException; | |||
import org.json.JSONObject; | |||
import org.junit.After; | |||
import org.junit.Before; | |||
import org.junit.runner.RunWith; | |||
@@ -1247,7 +1247,7 @@ public abstract class AbstractTB3Test extends TestBenchTestCase { | |||
BasicHttpEntityEnclosingRequest r = new BasicHttpEntityEnclosingRequest( | |||
"POST", sessionURL.toExternalForm()); | |||
HttpResponse response = client.execute(host, r); | |||
JSONObject object = extractObject(response); | |||
JsonObject object = extractObject(response); | |||
URL myURL = new URL(object.getString("proxyId")); | |||
if ((myURL.getHost() != null) && (myURL.getPort() != -1)) { | |||
return myURL.getHost(); | |||
@@ -1258,13 +1258,11 @@ public abstract class AbstractTB3Test extends TestBenchTestCase { | |||
return null; | |||
} | |||
private static JSONObject extractObject(HttpResponse resp) | |||
throws IOException, JSONException { | |||
private static JsonObject extractObject(HttpResponse resp) throws IOException { | |||
InputStream contents = resp.getEntity().getContent(); | |||
StringWriter writer = new StringWriter(); | |||
IOUtils.copy(contents, writer, "UTF8"); | |||
JSONObject objToReturn = new JSONObject(writer.toString()); | |||
return objToReturn; | |||
return JsonUtil.parse(writer.toString()); | |||
} | |||
} |