Differences

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

--- at:tutorial:symbiosis [2007/06/20 14:19] – jdedecker
+++ at:tutorial:symbiosis [2007/07/04 22:46] – jdedecker
@@ Line 10: / Line 10: @@
 ===== Symbiosis Architecture =====
-AmbientTalk has been implemented in Java. Because of this, Java plays two roles: it is both a symbiont language and the implementation language of AmbientTalk (and hence of the linguistic symbiosis itself). Figure \ref{fig:wrappers} illustrates the different objects that play a part in the AmbientTalk/Java symbiosis, according to the implementation model of Inter-language reflection. AmbientTalk objects are physically implemented as Java objects. This is illustrated by means of the ``represents'' relationship. To enable symbiosis, additional objects are required which denote the //appearance// of objects from one language in the other language. At the implementation level, such appearances are implemented as //wrapper// objects, which wrap an object from a different language and which perform the protocol mapping which translates between the semantics of the symbiont languages.
+AmbientTalk has been implemented in Java. Because of this, Java plays two roles: it is both a symbiont language and the implementation language of AmbientTalk (and hence of the linguistic symbiosis itself). The figure below illustrates the different objects that play a part in the AmbientTalk/Java symbiosis, according to the implementation model of Inter-language reflection. AmbientTalk objects are physically implemented as Java objects. This is illustrated by means of the "represents" relationship. To enable symbiosis, additional objects are required which denote the //appearance// of objects from one language in the other language. At the implementation level, such appearances are implemented as //wrapper// objects, which wrap an object from a different language and which perform the protocol mapping which translates between the semantics of the symbiont languages.
 {{:at:tutorial:wrapper-architecture.png?450|Symbiotic representation of AmbientTalk and Java Objects}}
@@ Line 58: / Line 58: @@
 <code>
-Add code that shows how to disambiguate between overloaded methods
+>aVector.remove.cast(jlobby.java.lang.Integer)(1)
+>>
+>aVector.remove.cast(jlobby.java.lang.Object)(3)
+>>true
 </code>
-==== Concurrency ====
+Selection of the correct overloaded method is done using the //cast// method.
 ===== Accessing AmbientTalk from within Java =====
 ==== Invoking AmbientTalk methods in Java ====
-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. Hence, messages sent to this wrapped AmbientTalk object appear as regular Java method invocations on an interface type. For example, the action listener in the chat example can be notified as if it were a normal Java object by performing **listener.actionPerformed(event)**.
+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.
+<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>
@@ Line 86: / Line 114: @@
 }
-</code>
-<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!"); 42 }
-	};
-	javaDemo.run(atObject);
-};
-self
 </code>
 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.
-==== Conversions ====
-==== Thread-Actor Symbiosis ====