/interpreter/tags/at2-build270707/src/edu/vub/at/objects/coercion/Coercer.java

http://ambienttalk.googlecode.com/ · Java · 191 lines · 82 code · 17 blank · 92 comment · 26 complexity · 779aed8c19b5c24d541106e60df21f6a 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 edu.vub.at.objects.symbiosis.SymbioticATObjectMarker;
  38. import java.io.IOException;
  39. import java.io.Serializable;
  40. import java.lang.reflect.InvocationHandler;
  41. import java.lang.reflect.InvocationTargetException;
  42. import java.lang.reflect.Method;
  43. import java.lang.reflect.Proxy;
  44. /**
  45. * A coercer is a dynamic proxy which is used to 'cast' Ambienttalk base-level NATObjects to a certain ATxxx interface.
  46. * The dynamic proxy is responsible for transforming java calls to meta_invoke calls.
  47. *
  48. * For example, a method from an AT interface
  49. *
  50. * ATExpression base_expression() throws NATException
  51. *
  52. * receives the following implementation:
  53. *
  54. * ATExpression expression() throws NATException {
  55. * return principal.meta_invoke(principal, Reflection.downSelector("getExpression"), NATTable.EMPTY).asExpression();
  56. * }
  57. *
  58. * where principal is the original object 'coerced into' the given interface
  59. *
  60. * @author tvcutsem
  61. */
  62. public final class Coercer implements InvocationHandler, Serializable {
  63. private final ATObject principal_;
  64. // we have to remember which thread owned the principal
  65. private transient Thread wrappingThread_;
  66. private Coercer(ATObject principal, Thread owningThread) {
  67. principal_ = principal;
  68. wrappingThread_ = owningThread;
  69. }
  70. public String toString() {
  71. return "<coercer on: "+principal_+">";
  72. }
  73. /**
  74. * Try to coerce the given AmbientTalk object into the given Java type. This variant implicitly assumes that
  75. * the coercion is performed by the thread owning the object, which is the case when coercing arguments to a
  76. * Java method call or when passing an AmbientTalk object as a result.
  77. *
  78. * @param object the AmbientTalk object to coerce
  79. * @param type the class object representing the target type
  80. * @return a Java object <tt>o</tt> for which it holds that <tt>type.isInstance(o)</tt>
  81. * @throws XTypeMismatch if the coercion fails
  82. */
  83. public static final Object coerce(ATObject object, Class type) throws XTypeMismatch {
  84. return coerce(object, type, Thread.currentThread());
  85. }
  86. /**
  87. * Try to coerce the given AmbientTalk object into the given Java type, while explicitly providing the thread
  88. * which is the owning actor for the object.
  89. * <p>
  90. * This variant of coerce is provided explicitly to allow coercion to occur from a Java thread which is not the
  91. * owning actor of the object. This occurs when the coercion is performed explicitly on the return value of an
  92. * evaluation, after the latter has been finalized.
  93. *
  94. * @param object the AmbientTalk object to coerce
  95. * @param type the class object representing the target type
  96. * @param owningThread the owning Actor
  97. * @return a Java object <tt>o</tt> for which it holds that <tt>type.isInstance(o)</tt>
  98. * @throws XTypeMismatch if the coercion fails
  99. */
  100. public static final Object coerce(ATObject object, Class type, Thread owningThread) throws XTypeMismatch {
  101. if (type.isInstance(object)) { // object instanceof type
  102. return object; // no need to coerce
  103. } else if (type.isInterface()) {
  104. // note that the proxy implements both the required type
  105. // and the Symbiotic object marker interface to identify it as a wrapper
  106. return Proxy.newProxyInstance(Thread.currentThread().getContextClassLoader(),
  107. new Class[] { type, SymbioticATObjectMarker.class },
  108. new Coercer(object, owningThread));
  109. } else {
  110. throw new XTypeMismatch(type, object);
  111. }
  112. }
  113. public Object invoke(Object receiver, final Method method, Object[] arguments) throws Throwable {
  114. Class methodImplementor = method.getDeclaringClass();
  115. // handle toString, hashCode and equals in a dedicated fashion
  116. // similarly, handle AT conversion methods by simply forwarding them to the native AT object
  117. if (methodImplementor == Object.class || methodImplementor == ATConversions.class) {
  118. // invoke these methods on the principal rather than on the proxy
  119. try {
  120. return method.invoke(principal_, arguments);
  121. } catch (InvocationTargetException e) {
  122. throw e.getTargetException();
  123. }
  124. // intercept access to the wrapped object for Java->AT value conversion
  125. // or for serialization purposes
  126. } else if (method.getDeclaringClass() == SymbioticATObjectMarker.class) {
  127. return principal_;
  128. } else {
  129. final ATObject[] symbioticArgs;
  130. // support for variable-arity invocations from within AmbientTalk
  131. if ((arguments != null) && (arguments.length == 1) && (arguments[0] instanceof ATObject[])) {
  132. // no need to convert arguments
  133. symbioticArgs = (ATObject[]) arguments[0];
  134. } else {
  135. symbioticArgs = new ATObject[(arguments == null) ? 0 : arguments.length];
  136. for (int i = 0; i < symbioticArgs.length; i++) {
  137. symbioticArgs[i] = Symbiosis.javaToAmbientTalk(arguments[i]);
  138. }
  139. }
  140. // if the current thread is not an actor thread, treat the Java invocation
  141. // as a message send instead and enqueue it in my actor's thread
  142. if (Thread.currentThread() != wrappingThread_) {
  143. if (Thread.currentThread() instanceof EventProcessor) {
  144. // another event loop has direct access to this object, this means
  145. // an AT object has been shared between actors via Java, signal an error
  146. throw new XIllegalOperation("Detected illegal invocation: sharing via Java level of object " + principal_);
  147. }
  148. ELActor owningActor = (ELActor) EventLoop.toEventLoop(wrappingThread_);
  149. // if the invoked method is part of an EventListener interface, treat the
  150. // invocation as a pure asynchronous message send, if the returntype is void
  151. if (Symbiosis.isEvent(method)) {
  152. owningActor.event_symbioticInvocation(principal_, method, symbioticArgs);
  153. return null; // void return type
  154. } else {
  155. // because a message send is asynchronous and Java threads work synchronously,
  156. // we'll have to make the Java thread wait for the result
  157. return owningActor.sync_event_symbioticInvocation(principal_, method, symbioticArgs);
  158. }
  159. } else {
  160. // perform a synchronous invocation
  161. ATObject result = Reflection.downInvocation(principal_, method, symbioticArgs);
  162. // properly 'cast' the returned object into the appropriate interface
  163. return Symbiosis.ambientTalkToJava(result, method.getReturnType());
  164. }
  165. }
  166. }
  167. /**
  168. * Upon deserialization, re-assign the thread to the actor deserializing this coercer
  169. */
  170. private void readObject(java.io.ObjectInputStream in) throws IOException, ClassNotFoundException {
  171. in.defaultReadObject();
  172. wrappingThread_ = Thread.currentThread();
  173. }
  174. }