Differences

This shows you the differences between two versions of the page.

--- at:tutorial:symbiosis [2007/06/19 10:58] – jdedecker
+++ at:tutorial:symbiosis [2007/06/20 15:33] – jdedecker
@@ Line 51: / Line 51: @@
 </code>
-The AmbientTalk/Java symbiosis treats message sends from AmbientTalk to Java as follows: if a message is sent to a class wrapper, only static fields or methods of the Java class are considered. If the message is sent to an instance wrapper, only non-static fields or methods of the Java class of the wrapped object are considered. If the AmbientTalk selector uniquely identifies a method (i.e. no overloading on the method name is performed in Java), the matching method is invoked. All AmbientTalk arguments are converted to Java objects.  This is done by wrapping them into Java objects in the case of custom objects or by converting them to native Java values if possible (e.g. for the different number types). The Java return value is mapped back to an AmbientTalk value.
+The AmbientTalk/Java symbiosis treats message sends from AmbientTalk to Java as follows: if a message is sent to a class wrapper, only static fields or methods of the Java class are considered. If the message is sent to an instance wrapper, only non-static fields or methods of the Java class of the wrapped object are considered. If the AmbientTalk selector uniquely identifies a method (i.e. no overloading on the method name is performed in Java), the matching method is invoked. All AmbientTalk arguments are converted to Java objects.  This is done by wrapping them into Java objects in the case of custom objects or by converting them to native Java values if possible (e.g. for the different number types and strings). The Java return value is mapped back to an AmbientTalk value.
 ==== Overloading ====
@@ Line 60: / Line 60: @@
 Add code that shows how to disambiguate between overloaded methods
 </code>
-==== Concurrency ====
 ===== Accessing AmbientTalk from within Java =====
-===== Using Java wrappers =====
+==== Invoking AmbientTalk methods in Java ====
+Besides calling Java methods from within AmbientTalk it is also possible to call AmbientTalk methods from within Java.  To illustrate this consider the code snippet shown below.  The **SymbiosisDemo** class is loaded and an instance is assigned to **javaDemo** variable.  The method **run** is invoked on this object and an AmbientTalk object **atObject** is passed as its argument.
-===== Symbionts =====
+<code>
+def SymbiosisDemo := jlobby.at.tutorial.SymbiosisDemo;
+def showSymbiosis() {
+	def javaDemo := SymbiosisDemo.new();
+	def atObject := object: {
+		def ping() {
+          system.println("ping!");
+          javaDemo.run2(self);
+        };
+		def pong() {
+          system.println("pong!");
+
+        }
+	};
+	javaDemo.run(atObject);
+};
+self
+</code>
+When an AmbientTalk object is passed as an argument to a Java method expecting an object of an interface type, the AmbientTalk object will appear to Java objects as a regular Java object implementing that interface.  In the example the Java interface **PingPong** contains the two methods **ping** and **pong** that were defined in **atObject**.  This interface is also the type of the Java method **run**.  Hence, messages sent to this wrapped AmbientTalk object appear as regular Java method invocations on an interface type.  Also, note the return type of the methods **ping** and **pong**: since the AmbientTalk implementation of **pong** returns an integer, which is also the return value of the method **ping**.
+<code>
+package at.tutorial;
+public class SymbiosisDemo {
+	public interface PingPong {
+		public int ping();
+		public int pong();
+	}
+	public int run(PingPong pp) {
+		return pp.ping();
+	}
+	public int run2(PingPong pp) {
+		return pp.pong();
+	}
+}
+</code>
-===== Conversions =====
+If Java invokes a method declared in an interface with an overloaded method signature, all overloaded invocations are transformed into the same method invocation on the AmbientTalk object. In other words, the AmbientTalk object does not take the types into consideration. However, if the Java method is overloaded based on arity, the AmbientTalk programmer can take this into account in the parameter list of the corresponding AmbientTalk method, by means of a variable-argument list or optional parameters. Otherwise, the Java invocation may fail because of an arity mismatch.
-===== Thread-Actor Symbiosis =====