public Object getDefaultValue(Class<?> hint) {
Object value;
if (hint == null) {
if (javaObject instanceof Boolean) {
hint = ScriptRuntime.BooleanClass;
}
}
if (hint == null || hint == ScriptRuntime.StringClass) {
value = javaObject.toString();
} else {
String converterName;
if (hint == ScriptRuntime.BooleanClass) {
converterName = "booleanValue";
} else if (hint == ScriptRuntime.NumberClass) {
converterName = "doubleValue";
} else {
throw Context.reportRuntimeError0("msg.default.value");
}
Object converterObject = get(converterName, this);
if (converterObject instanceof Function) {
Function f = (Function) converterObject;
value = f.call(Context.getContext(), f.getParentScope(), this, ScriptRuntime.emptyArgs);
} else {
if (hint == ScriptRuntime.NumberClass && javaObject instanceof Boolean) {
boolean b = ((Boolean) javaObject).booleanValue();
value = ScriptRuntime.wrapNumber(b ? 1.0 : 0.0);
} else {
value = javaObject.toString();
}
}
}
return value;
}
/**
* Utility method which dynamically binds a Context to the current thread, if none already exists.
*/
public static Object callMethod(
ContextFactory factory,
final Scriptable thisObj,
final Function f,
final Object[] args,
final long argsToWrap) {
if (f == null) {
// See comments in getFunction
return Undefined.instance;
}
if (factory == null) {
factory = ContextFactory.getGlobal();
}
final Scriptable scope = f.getParentScope();
if (argsToWrap == 0) {
return Context.call(factory, f, scope, thisObj, args);
}
Context cx = Context.getCurrentContext();
if (cx != null) {
return doCall(cx, scope, thisObj, f, args, argsToWrap);
} else {
return factory.call(
new ContextAction() {
public Object run(Context cx) {
return doCall(cx, scope, thisObj, f, args, argsToWrap);
}
});
}
}
/** evaluate implicit function syntax; e.g., A1(5) or A1(A2) */
public static Data implicit(Function f, Real r) {
Data value = null;
try {
value = f.evaluate(r);
} catch (VisADException exc) {
if (FormulaVar.DEBUG) exc.printStackTrace();
} catch (RemoteException exc) {
if (FormulaVar.DEBUG) exc.printStackTrace();
}
return value;
}
/** evaluate the derive function */
public static Data derive(Function f, VRealType rt) {
Data val = null;
try {
val = f.derivative(rt.getRealType(), Data.NO_ERRORS);
} catch (VisADException exc) {
if (FormulaVar.DEBUG) exc.printStackTrace();
} catch (RemoteException exc) {
if (FormulaVar.DEBUG) exc.printStackTrace();
}
return val;
}
/**
* Returns the class this method was called 'framesToSkip' frames up the caller hierarchy. JDK
* used to have {@link sun.reflect.Reflection#getCallerClass(int)} until jdk 1.8 build 87. So we
* have to resort to slow stack unwinding.
*
* <p>NOTE: <b>Extremely expensive! Please consider not using it. These aren't the droids you're
* looking for!</b>
*/
@SuppressWarnings("JavadocReference")
@Nullable
public static Class getCallerClass(int framesToSkip) {
int frames = framesToSkip;
StackTraceElement[] stackTrace = new Throwable().getStackTrace();
String className = null;
for (int i = 1; i <= frames; i++) {
if (i >= stackTrace.length) {
break;
}
StackTraceElement element = stackTrace[i];
className = element.getClassName();
if (className.equals("java.lang.reflect.Method")
|| className.equals("sun.reflect.NativeMethodAccessorImpl")
|| className.equals("sun.reflect.DelegatingMethodAccessorImpl")) {
frames++;
continue;
}
if (i == frames) {
break;
}
}
if (className == null) {
// some plugins incorrectly expect not-null class too far up the caller chain,
// so provide some not-null class for them
className = ReflectionUtil.class.getName();
}
try {
return Class.forName(className);
} catch (ClassNotFoundException ignored) {
}
ClassLoader pluginClassLoader = PLUGIN_CLASS_LOADER_DETECTOR.fun(className);
if (pluginClassLoader != null) {
try {
return Class.forName(className, false, pluginClassLoader);
} catch (ClassNotFoundException ignored) {
}
}
LOG.error(
"Could not load class '"
+ className
+ "' using classLoader "
+ ReflectionUtil.class.getClassLoader()
+ "."
+ (stackTrace[1].getClassName().equals("com.intellij.openapi.util.IconLoader")
? " Use getIcon(String, Class) instead."
: ""));
return null;
}
private static Object doCall(
Context cx,
Scriptable scope,
Scriptable thisObj,
Function f,
Object[] args,
long argsToWrap) {
// Wrap the rest of objects
for (int i = 0; i != args.length; ++i) {
if (0 != (argsToWrap & (1 << i))) {
Object arg = args[i];
if (!(arg instanceof Scriptable)) {
args[i] = cx.getWrapFactory().wrap(cx, scope, arg, null);
}
}
}
return f.call(cx, scope, thisObj, args);
}