/*
* Copyright 2008 Google Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License"); you may not
* use this file except in compliance with the License. You may obtain a copy of
* the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
* License for the specific language governing permissions and limitations under
* the License.
*/
package com.google.gwt.dev.shell;
import com.google.gwt.core.ext.TreeLogger;
import com.google.gwt.dev.util.TypeInfo;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
/**
* Glue layer that performs GWT-specific operations on JsValues. Used to isolate
* HostedModeExceptions/etc from JsValue code
*/
public final class JsValueGlue {
public static final String HOSTED_MODE_REFERENCE = "hostedModeReference";
public static final String JSO_CLASS = "com.google.gwt.core.client.JavaScriptObject";
public static final String JSO_IMPL_CLASS = "com.google.gwt.core.client.JavaScriptObject$";
/**
* Create a JavaScriptObject instance referring to this JavaScript object.
*
* @param classLoader the classLoader to create from
* @return the constructed JavaScriptObject
*/
public static Object createJavaScriptObject(JsValue value,
CompilingClassLoader classLoader) {
Throwable caught;
try {
// See if there's already a wrapper object (assures identity comparison).
Object jso = classLoader.getCachedJso(value.getJavaScriptObjectPointer());
if (jso != null) {
return jso;
}
// Instantiate the JSO class.
Class<?> jsoType = Class.forName(JSO_IMPL_CLASS, true, classLoader);
Constructor<?> ctor = jsoType.getDeclaredConstructor();
ctor.setAccessible(true);
jso = ctor.newInstance();
// Set the reference field to this JsValue using reflection.
Field referenceField = jsoType.getField(HOSTED_MODE_REFERENCE);
referenceField.set(jso, value);
classLoader.putCachedJso(value.getJavaScriptObjectPointer(), jso);
return jso;
} catch (InstantiationException e) {
caught = e;
} catch (IllegalAccessException e) {
caught = e;
} catch (SecurityException e) {
caught = e;
} catch (NoSuchMethodException e) {
caught = e;
} catch (IllegalArgumentException e) {
caught = e;
} catch (InvocationTargetException e) {
caught = e;
} catch (ClassNotFoundException e) {
caught = e;
} catch (NoSuchFieldException e) {
caught = e;
}
throw new RuntimeException("Error creating JavaScript object", caught);
}
/**
* Return an object containing the value JavaScript object as a specified
* type.
*
* @param value the JavaScript value
* @param type expected type of the returned object
* @param msgPrefix a prefix for error/warning messages
* @return the object reference
* @throws com.google.gwt.dev.shell.HostedModeException if the JavaScript
* object is not assignable to the supplied type.
*/
@SuppressWarnings("unchecked")
public static <T> T get(JsValue value, CompilingClassLoader cl,
Class<T> type, String msgPrefix) {
if (type.isPrimitive()) {
if (type == Boolean.TYPE) {
if (!value.isBoolean()) {
throw new HostedModeException(msgPrefix + ": JS value of type "
+ value.getTypeString() + ", expected boolean");
}
return (T) Boolean.valueOf(value.getBoolean());
} else if (type == Byte.TYPE) {
return (T) Byte.valueOf((byte) getIntRange(value, Byte.MIN_VALUE,
Byte.MAX_VALUE, "byte", msgPrefix));
} else if (type == Character.TYPE) {
return (T) Character.valueOf((char) getIntRange(value,
Character.MIN_VALUE, Character.MAX_VALUE, "char", msgPrefix));
} else if (type == Double.TYPE) {
if (!value.isNumber()) {
throw new HostedModeException(msgPrefix + ": JS value of type "
+ value.getTypeString() + ", expected double");
}
return (T) Double.valueOf(value.getNumber());
} else if (type == Float.TYPE) {
if (!value.isNumber()) {
throw new HostedModeException(msgPrefix + ": JS value of type "
+ value.getTypeString() + ", expected float");
}
double doubleVal = value.getNumber();
// Check for small changes near MIN_VALUE and replace with the
// actual end point value, in case it is being used as a sentinel
// value. This test works by the subtraction result rounding off to
// zero if the delta is not representable in a float.
// TODO(jat): add similar test for MAX_VALUE if we have a JS
// platform that alters the value while converting to/from strings.
if ((float) (doubleVal - Float.MIN_VALUE) == 0.0f) {
doubleVal = Float.MIN_VALUE;
}
float floatVal = (float) doubleVal;
if (Float.isInfinite(floatVal) && !Double.isInfinite(doubleVal)) {
// in this case we had overflow from the double value which was
// outside the range of supported float values, and the cast
// converted it to infinity. Since this lost data, we treat this
// as an error in hosted mode.
throw new HostedModeException(msgPrefix + ": JS value " + doubleVal
+ " out of range for a float");
}
return (T) Float.valueOf(floatVal);
} else if (type == Integer.TYPE) {
return (T) Integer.valueOf(getIntRange(value, Integer.MIN_VALUE,
Integer.MAX_VALUE, "int", msgPrefix));
} else if (type == Long.TYPE) {
if (!value.isWrappedJavaObject()) {
throw new HostedModeException(msgPrefix + ": JS value of type "
+ value.getTypeString() + ", expected Java long");
}
JavaLong javaLong = (JavaLong) value.getWrappedJavaObject();
return (T) Long.valueOf(javaLong.longValue());
} else if (type == Short.TYPE) {
return (T) Short.valueOf((short) getIntRange(value, Short.MIN_VALUE,
Short.MAX_VALUE, "short", msgPrefix));
}
}
if (value.isNull() || value.isUndefined()) {
return null;
}
if (value.isWrappedJavaObject()) {
return type.cast(value.getWrappedJavaObject());
}
if (value.isString()) {
return type.cast(value.getString());
}
if (value.isJavaScriptObject()) {
return type.cast(createJavaScriptObject(value, cl));
}
// Just don't know what do to with this.
/*
* TODO (amitmanjhi): does throwing a HostedModeException here and catching
* a RuntimeException in user test
* com.google.gwt.dev.jjs.test.HostedTest::testObjectReturns() make sense
*/
throw new IllegalArgumentException(msgPrefix + ": JS value of type "
+ value.getTypeString() + ", expected "
+ TypeInfo.getSourceRepresentation(type));
}
/**
* Set the underlying value.
*
* @param value JsValue to set
* @param type static type of the object
* @param obj the object to store in the JS value
*/
public static void set(JsValue value, CompilingClassLoader cl, Class<?> type,
Object obj) {
if (type.isPrimitive()) {
if (type == Boolean.TYPE) {
value.setBoolean(((Boolean) obj).booleanValue());
} else if (type == Byte.TYPE) {
value.setInt(((Byte) obj).byteValue());
} else if (type == Character.TYPE) {
value.setInt(((Character) obj).charValue());
} else if (type == Double.TYPE) {
value.setDouble(((Double) obj).doubleValue());
} else if (type == Float.TYPE) {
value.setDouble(((Float) obj).floatValue());
} else if (type == Integer.TYPE) {
value.setInt(((Integer) obj).intValue());
} else if (type == Long.TYPE) {
long longVal = ((Long) obj).longValue();
value.setWrappedJavaObject(cl, new JavaLong(longVal));
} else if (type == Short.TYPE) {
value.setInt(((Short) obj).shortValue());
} else if (type == Void.TYPE) {
value.setUndefined();
} else {
throw new HostedModeException("Cannot marshal primitive type " + type);
}
} else if (obj == null) {
value.setNull();
} else {
// not a boxed primitive
try {
Class<?> jsoType = Class.forName(JSO_IMPL_CLASS, false, cl);
if (jsoType == obj.getClass()) {
JsValue jsObject = getUnderlyingObject(obj);
value.setValue(jsObject);
return;
}
} catch (ClassNotFoundException e) {
// Ignore the exception, if we can't find the class then obviously we
// don't have to worry about o being one
}
// Fall through case: Object.
if (!type.isInstance(obj)) {
throw new HostedModeException("object is of type "
+ obj.getClass().getName() + ", expected " + type.getName());
}
if (obj instanceof String) {
value.setString((String) obj);
} else {
value.setWrappedJavaObject(cl, obj);
}
}
}
private static int getIntRange(JsValue value, int low, int high,
String typeName, String msgPrefix) {
int intVal;
if (value.isInt()) {
intVal = value.getInt();
if (intVal < low || intVal > high) {
throw new HostedModeException(msgPrefix + ": JS int value " + intVal
+ " out of range for a " + typeName);
}
} else if (value.isNumber()) {
double doubleVal = value.getNumber();
if (doubleVal < low || doubleVal > high) {
throw new HostedModeException(msgPrefix + ": JS double value "
+ doubleVal + " out of range for a " + typeName);
}
intVal = (int) doubleVal;
if (intVal != doubleVal) {
ModuleSpace.getLogger().log(TreeLogger.WARN,
msgPrefix + ": Rounding double (" + doubleVal + ") to int for "
+ typeName, null);
}
} else {
throw new HostedModeException(msgPrefix + ": JS value of type "
+ value.getTypeString() + ", expected " + typeName);
}
return intVal;
}
/**
* Returns the underlying JsValue from a JavaScriptObject instance.
*
* The tricky part is that it is in a different ClassLoader so therefore can't
* be specified directly. The type is specified as Object, and reflection is
* used to retrieve the reference field.
*
* @param jso the instance of JavaScriptObject to retrieve the JsValue from.
* @return the JsValue representing the JavaScript object
*/
private static JsValue getUnderlyingObject(Object jso) {
Throwable caught;
try {
Field referenceField = jso.getClass().getField(HOSTED_MODE_REFERENCE);
referenceField.setAccessible(true);
return (JsValue) referenceField.get(jso);
} catch (IllegalAccessException e) {
caught = e;
} catch (SecurityException e) {
caught = e;
} catch (NoSuchFieldException e) {
caught = e;
}
throw new RuntimeException("Error reading " + HOSTED_MODE_REFERENCE, caught);
}
private JsValueGlue() {
}
}