/interpreter/tags/at2dist130208/src/edu/vub/at/objects/coercion/Coercer.java

http://ambienttalk.googlecode.com/ · Java · 201 lines · 85 code · 20 blank · 96 comment · 23 complexity · ed99002b47c623eb17650e9d3b37f4db MD5 · raw file

  1. /**
  2. * AmbientTalk/2 Project
  3. * Coercer.java created on 3-okt-2006 at 16:12:05
  4. * (c) Programming Technology Lab, 2006 - 2007
  5. * Authors: Tom Van Cutsem & Stijn Mostinckx
  6. *
  7. * Permission is hereby granted, free of charge, to any person
  8. * obtaining a copy of this software and associated documentation
  9. * files (the "Software"), to deal in the Software without
  10. * restriction, including without limitation the rights to use,
  11. * copy, modify, merge, publish, distribute, sublicense, and/or
  12. * sell copies of the Software, and to permit persons to whom the
  13. * Software is furnished to do so, subject to the following
  14. * conditions:
  15. *
  16. * The above copyright notice and this permission notice shall be
  17. * included in all copies or substantial portions of the Software.
  18. *
  19. * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  20. * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
  21. * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  22. * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
  23. * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
  24. * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  25. * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
  26. * OTHER DEALINGS IN THE SOFTWARE.
  27. */
  28. package edu.vub.at.objects.coercion;
  29. import edu.vub.at.actors.eventloops.EventLoop;
  30. import edu.vub.at.actors.eventloops.EventLoop.EventProcessor;
  31. import edu.vub.at.actors.natives.ELActor;
  32. import edu.vub.at.exceptions.XIllegalOperation;
  33. import edu.vub.at.exceptions.XTypeMismatch;
  34. import edu.vub.at.objects.ATObject;
  35. import edu.vub.at.objects.mirrors.Reflection;
  36. import edu.vub.at.objects.symbiosis.Symbiosis;
  37. import java.io.IOException;
  38. import java.io.Serializable;
  39. import java.lang.reflect.InvocationHandler;
  40. import java.lang.reflect.InvocationTargetException;
  41. import java.lang.reflect.Method;
  42. import java.lang.reflect.Proxy;
  43. /**
  44. * A coercer is a dynamic proxy which is used to 'cast' Ambienttalk base-level NATObjects to a certain ATxxx interface.
  45. * The dynamic proxy is responsible for transforming java calls to meta_invoke calls.
  46. *
  47. * For example, a method from an AT interface
  48. *
  49. * ATExpression base_expression() throws NATException
  50. *
  51. * receives the following implementation:
  52. *
  53. * ATExpression expression() throws NATException {
  54. * return principal.meta_invoke(principal, Reflection.downSelector("getExpression"), NATTable.EMPTY).asExpression();
  55. * }
  56. *
  57. * where principal is the original object 'coerced into' the given interface
  58. *
  59. * @author tvcutsem
  60. */
  61. public final class Coercer implements InvocationHandler, Serializable {
  62. private final ATObject principal_;
  63. // we have to remember which thread owned the principal
  64. private transient Thread wrappingThread_;
  65. private Coercer(ATObject principal, Thread owningThread) {
  66. principal_ = principal;
  67. wrappingThread_ = owningThread;
  68. }
  69. public String toString() {
  70. return "<coercer on: "+principal_+">";
  71. }
  72. /**
  73. * Try to coerce the given AmbientTalk object into the given Java type. This variant implicitly assumes that
  74. * the coercion is performed by the thread owning the object, which is the case when coercing arguments to a
  75. * Java method call or when passing an AmbientTalk object as a result.
  76. *
  77. * Note that the returned coercer object is also an instance of {@link ATObject} and
  78. * in the AmbientTalk world the coercer will behave as its coerced AT object.
  79. *
  80. * @param object the AmbientTalk object to coerce
  81. * @param type the class object representing the target type
  82. * @return a Java object <tt>o</tt> for which it holds that <tt>type.isInstance(o)</tt>
  83. * @throws XTypeMismatch if the coercion fails
  84. */
  85. public static final Object coerce(ATObject object, Class type) throws XTypeMismatch {
  86. return coerce(object, type, Thread.currentThread());
  87. }
  88. /**
  89. * Try to coerce the given AmbientTalk object into the given Java type, while explicitly providing the thread
  90. * which is the owning actor for the object.
  91. * <p>
  92. * This variant of coerce is provided explicitly to allow coercion to occur from a Java thread which is not the
  93. * owning actor of the object. This occurs when the coercion is performed explicitly on the return value of an
  94. * evaluation, after the latter has been finalized.
  95. *
  96. * @param object the AmbientTalk object to coerce
  97. * @param type the class object representing the target type
  98. * @param owningThread the owning Actor
  99. * @return a Java object <tt>o</tt> for which it holds that <tt>type.isInstance(o)</tt>
  100. * @throws XTypeMismatch if the coercion fails
  101. */
  102. public static final Object coerce(ATObject object, Class type, Thread owningThread) throws XTypeMismatch {
  103. if (type.isInstance(object)) { // object instanceof type
  104. return object; // no need to coerce
  105. } else if (type.isInterface()) {
  106. // see which class loader is required to load the interface
  107. // first try this thread's context class loader
  108. ClassLoader loader = Thread.currentThread().getContextClassLoader();
  109. try {
  110. Class.forName(type.getName(), false, loader);
  111. } catch(ClassNotFoundException e) {
  112. // if that fails, try the class loader that created the interface type
  113. loader = type.getClassLoader();
  114. }
  115. // note that the proxy implements both the required type
  116. // and the Symbiotic object marker interface to identify it as a wrapper
  117. return Proxy.newProxyInstance(loader,
  118. new Class[] { type, ATObject.class },
  119. new Coercer(object, owningThread));
  120. } else {
  121. throw new XTypeMismatch(type, object);
  122. }
  123. }
  124. public Object invoke(Object receiver, final Method method, Object[] arguments) throws Throwable {
  125. Class methodImplementor = method.getDeclaringClass();
  126. // handle toString, hashCode and equals in a dedicated fashion
  127. // similarly, handle any native AT methods by simply forwarding them to the native AT object
  128. if (methodImplementor == Object.class || methodImplementor == ATObject.class) {
  129. // invoke these methods on the principal rather than on the proxy
  130. try {
  131. return method.invoke(principal_, arguments);
  132. } catch (InvocationTargetException e) {
  133. throw e.getTargetException();
  134. }
  135. } else {
  136. final ATObject[] symbioticArgs;
  137. // support for variable-arity invocations from within AmbientTalk
  138. if ((arguments != null) && (arguments.length == 1) && (arguments[0] instanceof ATObject[])) {
  139. // no need to convert arguments
  140. symbioticArgs = (ATObject[]) arguments[0];
  141. } else {
  142. symbioticArgs = new ATObject[(arguments == null) ? 0 : arguments.length];
  143. for (int i = 0; i < symbioticArgs.length; i++) {
  144. symbioticArgs[i] = Symbiosis.javaToAmbientTalk(arguments[i]);
  145. }
  146. }
  147. // if the current thread is not an actor thread, treat the Java invocation
  148. // as a message send instead and enqueue it in my actor's thread
  149. if (Thread.currentThread() != wrappingThread_) {
  150. if (Thread.currentThread() instanceof EventProcessor) {
  151. // another event loop has direct access to this object, this means
  152. // an AT object has been shared between actors via Java, signal an error
  153. throw new XIllegalOperation("Detected illegal invocation of "+method.getName()+": sharing via Java level of object " + principal_);
  154. }
  155. ELActor owningActor = (ELActor) EventLoop.toEventLoop(wrappingThread_);
  156. // if the invoked method is part of an EventListener interface, treat the
  157. // invocation as a pure asynchronous message send, if the returntype is void
  158. if (Symbiosis.isEvent(method)) {
  159. owningActor.event_symbioticInvocation(principal_, method, symbioticArgs);
  160. return null; // void return type
  161. } else {
  162. // because a message send is asynchronous and Java threads work synchronously,
  163. // we'll have to make the Java thread wait for the result
  164. return owningActor.sync_event_symbioticInvocation(principal_, method, symbioticArgs);
  165. }
  166. } else {
  167. // perform a synchronous invocation
  168. ATObject result = Reflection.downInvocation(principal_, method, symbioticArgs);
  169. // properly 'cast' the returned object into the appropriate interface
  170. return Symbiosis.ambientTalkToJava(result, method.getReturnType());
  171. }
  172. }
  173. }
  174. /**
  175. * Upon deserialization, re-assign the thread to the actor deserializing this coercer
  176. */
  177. private void readObject(java.io.ObjectInputStream in) throws IOException, ClassNotFoundException {
  178. in.defaultReadObject();
  179. wrappingThread_ = Thread.currentThread();
  180. }
  181. }