@Override public Object asHostObject(Object receiver) { TruffleObject castReceiver = (TruffleObject) receiver; // TODO temporary allow proxies as host objects GR-8034 if (isProxy) { return PolyglotProxy.toProxyHostObject((TruffleObject) receiver); } else if (isJava) { return JavaInterop.asJavaObject(castReceiver); } else { return super.asHostObject(receiver); } }
@Override public Object execute(VirtualFrame frame) { return JavaInterop.asTruffleObject(allTarget); } });
@Override public Object toGuestValue(Object obj, Object languageContext) { return JavaInterop.asTruffleValue(obj); }
static Object asTruffleValue(Object obj, Object languageContext) { return JavaInterop.isPrimitive(obj) ? obj : JavaInterop.asTruffleObject(obj, languageContext); } }
return asTruffleObject(obj, currentPolyglotContext(), true);
@Override protected Object findMetaObject(HostContext context, Object value) { if (value instanceof TruffleObject) { TruffleObject to = (TruffleObject) value; if (JavaInterop.isJavaObject(to)) { Object javaObject = JavaInterop.asJavaObject(to); Class<?> javaType; if (javaObject == null) { javaType = Void.class; } else { javaType = javaObject.getClass(); } return javaClassToGuestObject(javaType); } else if (PolyglotProxy.isProxyGuestObject(to)) { Proxy proxy = PolyglotProxy.toProxyHostObject(to); return javaClassToGuestObject(proxy.getClass()); } else if (VMAccessor.JAVAINTEROP.isJavaFunction(value)) { return "Bound Method"; } else { return "Foreign Object"; } } else { return javaClassToGuestObject(value.getClass()); } }
/** @since 0.8 or earlier */ @Test public void testPrimitiveReturnTypeFloat() throws Exception { PolyglotEngine.Value apply = findGlobalSymbol(applyNumbers()); float value = RANDOM.nextInt(1000) + RANDOM.nextFloat(); TruffleObject fn = JavaInterop.asTruffleFunction(ObjectBinaryOperation.class, new ConstantFunction(value)); Number n = apply.execute(fn).as(Number.class); assertDouble("The same value returned (" + value + " + 10): ", value + 10, n.floatValue()); }
TruffleObject obj = (TruffleObject) apply.execute().get(); assertIsObjectOfLanguage(obj); KeyInfoInterface object = JavaInterop.asJavaObject(KeyInfoInterface.class, obj); Map map = JavaInterop.asJavaObject(Map.class, obj); assertEquals(map.toString(), numKeys, map.size()); if (KeyInfo.isExisting(ro)) { map = JavaInterop.getMapView(map, true); if (KeyInfo.isExisting(intern)) { assertEquals(numKeys + 1, map.size());
@CompilerDirectives.TruffleBoundary static <T> T asJavaFunction(Class<T> functionalType, TruffleObject function, Object languageContext) { assert JavaInterop.isJavaFunctionInterface(functionalType); Method functionalInterfaceMethod = functionalInterfaceMethod(functionalType); final FunctionProxyHandler handler = new FunctionProxyHandler(function, functionalInterfaceMethod, languageContext); Object obj = Proxy.newProxyInstance(functionalType.getClassLoader(), new Class<?>[]{functionalType}, handler); return functionalType.cast(obj); }
@Override public Object execute(VirtualFrame frame) { return node.execute(value, type, null, currentPolyglotContext()); } }
@Override public boolean isJavaFunction(Object object) { return JavaInterop.isJavaFunction(object); }
return convertToJavaObject(type, foreignObject);
/** @since 0.16 */ @Test public void testFunctionAddNumbers() throws Exception { String id = functionAddNumbers(); if (id == null) { return; } PolyglotEngine.Value apply = findGlobalSymbol(id); TruffleObject truffleObject = (TruffleObject) apply.execute().get(); assertIsObjectOfLanguage(truffleObject); DoubleBinaryOperator object = JavaInterop.asJavaFunction(DoubleBinaryOperator.class, truffleObject); Assert.assertEquals(42.0, object.applyAsDouble(20.0, 22.0), 0.1); }
/** * Prepares a Java object for use in any {@link TruffleLanguage}. If the object is one of * {@link #isPrimitive primitive} values, it is just returned, as all {@link TruffleLanguage}s * are supposed to handle such object. If it is a non-primitive type of Java object, the method * does exactly the same thing as {@link #asTruffleObject}. * * @param obj a Java object to convert into one suitable for <em>Truffle</em> languages * @return converted object, or primitive * @since 0.18 */ public static Object asTruffleValue(Object obj) { return isPrimitive(obj) ? obj : asTruffleObject(obj); }
private String toStringImpl(HostContext context, Object value, int level) { if (value instanceof TruffleObject) { TruffleObject to = (TruffleObject) value; if (JavaInterop.isJavaObject(to)) { Object javaObject = JavaInterop.asJavaObject(to); try { if (javaObject == null) {
/** @since 0.8 or earlier */ @Test public void testPrimitiveReturnTypeDouble() throws Exception { PolyglotEngine.Value apply = findGlobalSymbol(applyNumbers()); double value = RANDOM.nextInt(1000) + RANDOM.nextDouble(); TruffleObject fn = JavaInterop.asTruffleFunction(ObjectBinaryOperation.class, new ConstantFunction(value)); Number n = apply.execute(fn).as(Number.class); assertDouble("The same value returned (" + value + " + 10): ", value + 10, n.doubleValue()); }
} else { if (TruffleOptions.AOT) { if (JavaInterop.isJavaFunctionInterface(targetType) && (isExecutable(tValue) || isInstantiable(tValue))) { return true; } else if (targetType.isInterface() && ForeignAccess.sendHasKeys(hasKeysNode, tValue)) {
/** * Takes a functional interface and its implementation (for example lambda function) and * converts it into object executable by <em>Truffle</em> languages. Here is a definition of * function returning the meaning of life as lambda expression, converting it back to * <b>Java</b> and using it: * * <pre> * TruffleObject to = JavaInterop.asTruffleFunction(Callable.<b>class</b>, () -> 42); * Callable c = JavaInterop.{@link #asJavaFunction(java.lang.Class, com.oracle.truffle.api.interop.TruffleObject) asJavaFunction}(Callable.<b>class</b>, to); * <b>assert</b> c.call() == 42; * </pre> * * @param <T> requested interface and implementation * @param functionalType interface with a single defined method - so called <em>functional * interface</em> * @param implementation implementation of the interface, or directly a lambda expression * defining the required behavior * @return an {@link Message#IS_EXECUTABLE executable} {@link TruffleObject} ready to be used in * any <em>Truffle</em> language * @since 0.9 */ public static <T> TruffleObject asTruffleFunction(Class<T> functionalType, T implementation) { if (TruffleOptions.AOT) { throw new IllegalArgumentException(); } return JavaInteropReflect.asTruffleFunction(functionalType, implementation, currentPolyglotContext()); }
static TruffleObject asTruffleObject(Object obj, Object languageContext) { return asTruffleObject(obj, languageContext, false); }
/** @since 0.16 */ @Test public void testWriteToObjectWithElement() throws Exception { String id = objectWithElement(); if (id == null) { return; } PolyglotEngine.Value apply = findGlobalSymbol(id); TruffleObject truffleObject = (TruffleObject) apply.execute().get(); assertIsObjectOfLanguage(truffleObject); @SuppressWarnings("unchecked") List<Object> object = JavaInterop.asJavaObject(List.class, truffleObject); Assert.assertEquals(42.0, ((Number) object.get(2)).doubleValue(), 0.1); object.set(2, 13.0); Assert.assertEquals(13.0, ((Number) object.get(2)).doubleValue(), 0.1); }