RubyToJavaInvoker.java

  1. package org.jruby.java.invokers;

  3. import java.lang.reflect.AccessibleObject;
  4. import java.lang.reflect.Array;
  5. import java.lang.reflect.Member;
  6. import java.lang.reflect.Method;
  7. import java.lang.reflect.Modifier;
  8. import java.util.ArrayList;
  9. import java.util.Arrays;
  10. import java.util.HashMap;
  11. import java.util.List;
  12. import java.util.Map;
  13. import java.util.concurrent.ConcurrentHashMap;
  14. import org.jruby.Ruby;
  15. import org.jruby.RubyModule;
  16. import org.jruby.internal.runtime.methods.CallConfiguration;
  17. import org.jruby.internal.runtime.methods.JavaMethod;
  18. import org.jruby.java.dispatch.CallableSelector;
  19. import org.jruby.java.proxies.ArrayJavaProxy;
  20. import org.jruby.java.proxies.JavaProxy;
  21. import org.jruby.javasupport.JavaCallable;
  22. import org.jruby.runtime.Arity;
  23. import org.jruby.runtime.Visibility;
  24. import org.jruby.runtime.builtin.IRubyObject;

  26. public abstract class RubyToJavaInvoker extends JavaMethod {
  27.     protected static final Object[] EMPTY_OBJECT_ARRAY = new Object[0];
  28.     protected final JavaCallable javaCallable;
  29.     protected final JavaCallable[][] javaCallables;
  30.     protected final JavaCallable[] javaVarargsCallables;
  31.     protected final int minVarargsArity;
  32.     protected final Map cache;
  33.     protected final Ruby runtime;
  34.     private Member[] members;
  35.     
  36.     RubyToJavaInvoker(RubyModule host, Member[] members) {
  37.         super(host, Visibility.PUBLIC, CallConfiguration.FrameNoneScopeNone);
  38.         this.members = members;
  39.         this.runtime = host.getRuntime();
  40.         // we set all Java methods to optional, since many/most have overloads
  41.         setArity(Arity.OPTIONAL);

  43.         Ruby runtime = host.getRuntime();

  45.         // initialize all the callables for this method
  46.         JavaCallable callable = null;
  47.         JavaCallable[][] callables = null;
  48.         JavaCallable[] varargsCallables = null;
  49.         int varargsArity = Integer.MAX_VALUE;
  50.         
  51.         if (members.length == 1) {
  52.             callable = createCallable(runtime, members[0]);
  53.             if (callable.isVarArgs()) {
  54.                 varargsCallables = createCallableArray(callable);
  55.             }
  56.         } else {
  57.             Map<Integer, List<JavaCallable>> methodsMap = new HashMap<Integer, List<JavaCallable>>();
  58.             List<JavaCallable> varargsMethods = new ArrayList();
  59.             int maxArity = 0;
  60.             for (Member method: members) {
  61.                 int currentArity = getMemberParameterTypes(method).length;
  62.                 maxArity = Math.max(currentArity, maxArity);
  63.                 List<JavaCallable> methodsForArity = methodsMap.get(currentArity);
  64.                 if (methodsForArity == null) {
  65.                     methodsForArity = new ArrayList<JavaCallable>();
  66.                     methodsMap.put(currentArity,methodsForArity);
  67.                 }
  68.                 JavaCallable javaMethod = createCallable(runtime,method);
  69.                 methodsForArity.add(javaMethod);

  71.                 if (isMemberVarArgs(method)) {
  72.                     varargsArity = Math.min(currentArity - 1, varargsArity);
  73.                     varargsMethods.add(javaMethod);
  74.                 }
  75.             }

  77.             callables = createCallableArrayArray(maxArity + 1);
  78.             for (Map.Entry<Integer,List<JavaCallable>> entry : methodsMap.entrySet()) {
  79.                 List<JavaCallable> methodsForArity = (List<JavaCallable>)entry.getValue();

  81.                 JavaCallable[] methodsArray = methodsForArity.toArray(createCallableArray(methodsForArity.size()));
  82.                 callables[((Integer)entry.getKey()).intValue()] = methodsArray;
  83.             }

  85.             if (varargsMethods.size() > 0) {
  86.                 // have at least one varargs, build that map too
  87.                 varargsCallables = createCallableArray(varargsMethods.size());
  88.                 varargsMethods.toArray(varargsCallables);
  89.             }
  90.         }
  91.         members = null;

  93.         // initialize cache of parameter types to method
  94.         // FIXME: No real reason to use CHM, is there?
  95.         cache = new ConcurrentHashMap(0, 0.75f, 1);

  97.         this.javaCallable = callable;
  98.         this.javaCallables = callables;
  99.         this.javaVarargsCallables = varargsCallables;
  100.         this.minVarargsArity = varargsArity;
  101.         
  102.         // if it's not overloaded, set up a NativeCall
  103.         if (javaCallable != null) {
  104.             // no constructor support yet
  105.             if (javaCallable instanceof org.jruby.javasupport.JavaMethod) {
  106.                 org.jruby.javasupport.JavaMethod javaMethod = (org.jruby.javasupport.JavaMethod)javaCallable;
  107.                 Method method = (Method)javaMethod.getValue();
  108.                 // only public, since non-public don't bind
  109.                 if (Modifier.isPublic(method.getModifiers()) && Modifier.isPublic(method.getDeclaringClass().getModifiers())) {
  110.                     setNativeCall(method.getDeclaringClass(), method.getName(), method.getReturnType(), method.getParameterTypes(), Modifier.isStatic(method.getModifiers()), true);
  111.                 }
  112.             }
  113.         } else {
  114.             // use the lowest-arity non-overload
  115.             for (JavaCallable[] callablesForArity : javaCallables) {
  116.                 if (callablesForArity != null
  117.                         && callablesForArity.length == 1
  118.                         && callablesForArity[0] instanceof org.jruby.javasupport.JavaMethod) {
  119.                     Method method = (Method)((org.jruby.javasupport.JavaMethod)callablesForArity[0]).getValue();
  120.                     // only public, since non-public don't bind
  121.                     if (Modifier.isPublic(method.getModifiers()) && Modifier.isPublic(method.getDeclaringClass().getModifiers())) {
  122.                         setNativeCall(method.getDeclaringClass(), method.getName(), method.getReturnType(), method.getParameterTypes(), Modifier.isStatic(method.getModifiers()), true);
  123.                     }
  124.                 }
  125.             }
  126.         }
  127.     }

  129.     protected Member[] getMembers() {
  130.         return members;
  131.     }

  133.     protected AccessibleObject[] getAccessibleObjects() {
  134.         return (AccessibleObject[])getMembers();
  135.     }

  137.     protected abstract JavaCallable createCallable(Ruby ruby, Member member);

  139.     protected abstract JavaCallable[] createCallableArray(JavaCallable callable);

  141.     protected abstract JavaCallable[] createCallableArray(int size);

  143.     protected abstract JavaCallable[][] createCallableArrayArray(int size);

  145.     protected abstract Class[] getMemberParameterTypes(Member member);

  147.     protected abstract boolean isMemberVarArgs(Member member);

  149.     static Object convertArg(IRubyObject arg, JavaCallable method, int index) {
  150.         return arg.toJava(method.getParameterTypes()[index]);
  151.     }

  153.     static Object convertVarargs(IRubyObject[] args, JavaCallable method) {
  154.         Class[] types = method.getParameterTypes();
  155.         Class varargArrayType = types[types.length - 1];
  156.         Class varargType = varargArrayType.getComponentType();
  157.         int varargsStart = types.length - 1;
  158.         int varargsCount = args.length - varargsStart;

  160.         Object varargs;
  161.         if (args.length == 0) {
  162.             return Array.newInstance(varargType, 0);
  163.         } else if (varargsCount == 1 && args[varargsStart] instanceof ArrayJavaProxy) {
  164.             // we may have a pre-created array to pass; try that first
  165.             varargs = args[varargsStart].toJava(varargArrayType);
  166.         } else {
  167.             varargs = Array.newInstance(varargType, varargsCount);

  169.             for (int i = 0; i < varargsCount; i++) {
  170.                 Array.set(varargs, i, args[varargsStart + i].toJava(varargType));
  171.             }
  172.         }
  173.         return varargs;
  174.     }

  176.     static JavaProxy castJavaProxy(IRubyObject self) {
  177.         assert self instanceof JavaProxy : "Java methods can only be invoked on Java objects";
  178.         return (JavaProxy)self;
  179.     }

  181.     static void trySetAccessible(AccessibleObject[] accObjs) {
  182.         if (!Ruby.isSecurityRestricted()) {
  183.             try {
  184.                 AccessibleObject.setAccessible(accObjs, true);
  185.             } catch(SecurityException e) {}
  186.         }
  187.     }

  189.     void raiseNoMatchingCallableError(String name, IRubyObject proxy, Object... args) {
  190.         int len = args.length;
  191.         Class[] argTypes = new Class[args.length];
  192.         for (int i = 0; i < len; i++) {
  193.             argTypes[i] = args[i].getClass();
  194.         }
  195.         throw proxy.getRuntime().newArgumentError("no " + name + " with arguments matching " + Arrays.toString(argTypes) + " on object " + proxy.getMetaClass());
  196.     }

  198.     protected JavaCallable findCallable(IRubyObject self, String name, IRubyObject[] args, int arity) {
  199.         JavaCallable callable;
  200.         if ((callable = javaCallable) == null) {
  201.             JavaCallable[] callablesForArity = null;
  202.             if (arity >= javaCallables.length || (callablesForArity = javaCallables[arity]) == null) {
  203.                 if (javaVarargsCallables != null) {
  204.                     callable = CallableSelector.matchingCallableArityN(runtime, cache, javaVarargsCallables, args, arity);
  205.                     if (callable == null) {
  206.                         throw CallableSelector.argTypesDoNotMatch(self.getRuntime(), self, javaVarargsCallables, (Object[])args);
  207.                     }
  208.                     return callable;
  209.                 } else {
  210.                     throw self.getRuntime().newArgumentError(args.length, javaCallables.length - 1);
  211.                 }
  212.             }
  213.             callable = CallableSelector.matchingCallableArityN(runtime, cache, callablesForArity, args, arity);
  214.             if (callable == null && javaVarargsCallables != null) {
  215.                 callable = CallableSelector.matchingCallableArityN(runtime, cache, javaVarargsCallables, args, arity);
  216.                 if (callable == null) {
  217.                     throw CallableSelector.argTypesDoNotMatch(self.getRuntime(), self, javaVarargsCallables, (Object[])args);
  218.                 }
  219.                 return callable;
  220.             }
  221.             if (callable == null) {
  222.                 throw CallableSelector.argTypesDoNotMatch(self.getRuntime(), self, callablesForArity, (Object[])args);
  223.             }
  224.         } else {
  225.             if (!callable.isVarArgs() && callable.getParameterTypes().length != args.length) {
  226.                 throw self.getRuntime().newArgumentError(args.length, callable.getParameterTypes().length);
  227.             }
  228.         }
  229.         return callable;
  230.     }

  232.     protected JavaCallable findCallableArityZero(IRubyObject self, String name) {
  233.         JavaCallable callable;
  234.         if ((callable = javaCallable) == null) {
  235.             // TODO: varargs?
  236.             JavaCallable[] callablesForArity = null;
  237.             if (javaCallables.length == 0 || (callablesForArity = javaCallables[0]) == null) {
  238.                 raiseNoMatchingCallableError(name, self, EMPTY_OBJECT_ARRAY);
  239.             }
  240.             callable = callablesForArity[0];
  241.         } else {
  242.             if (callable.getParameterTypes().length != 0) {
  243.                 throw self.getRuntime().newArgumentError(0, callable.getParameterTypes().length);
  244.             }
  245.         }
  246.         return callable;
  247.     }

  249.     protected JavaCallable findCallableArityOne(IRubyObject self, String name, IRubyObject arg0) {
  250.         JavaCallable callable;
  251.         if ((callable = javaCallable) == null) {
  252.             // TODO: varargs?
  253.             JavaCallable[] callablesForArity = null;
  254.             if (javaCallables.length <= 1 || (callablesForArity = javaCallables[1]) == null) {
  255.                 throw self.getRuntime().newArgumentError(1, javaCallables.length - 1);
  256.             }
  257.             callable = CallableSelector.matchingCallableArityOne(runtime, cache, callablesForArity, arg0);
  258.             if (callable == null) {
  259.                 throw CallableSelector.argTypesDoNotMatch(self.getRuntime(), self, callablesForArity, arg0);
  260.             }
  261.         } else {
  262.             if (callable.getParameterTypes().length != 1) {
  263.                 throw self.getRuntime().newArgumentError(1, callable.getParameterTypes().length);
  264.             }
  265.         }
  266.         return callable;
  267.     }

  269.     protected JavaCallable findCallableArityTwo(IRubyObject self, String name, IRubyObject arg0, IRubyObject arg1) {
  270.         JavaCallable callable;
  271.         if ((callable = javaCallable) == null) {
  272.             // TODO: varargs?
  273.             JavaCallable[] callablesForArity = null;
  274.             if (javaCallables.length <= 2 || (callablesForArity = javaCallables[2]) == null) {
  275.                 throw self.getRuntime().newArgumentError(2, javaCallables.length - 1);
  276.             }
  277.             callable = CallableSelector.matchingCallableArityTwo(runtime, cache, callablesForArity, arg0, arg1);
  278.             if (callable == null) {
  279.                 throw CallableSelector.argTypesDoNotMatch(self.getRuntime(), self, callablesForArity, arg0, arg1);
  280.             }
  281.         } else {
  282.             if (callable.getParameterTypes().length != 2) {
  283.                 throw self.getRuntime().newArgumentError(2, callable.getParameterTypes().length);
  284.             }
  285.         }
  286.         return callable;
  287.     }

  289.     protected JavaCallable findCallableArityThree(IRubyObject self, String name, IRubyObject arg0, IRubyObject arg1, IRubyObject arg2) {
  290.         JavaCallable callable;
  291.         if ((callable = javaCallable) == null) {
  292.             // TODO: varargs?
  293.             JavaCallable[] callablesForArity = null;
  294.             if (javaCallables.length <= 3 || (callablesForArity = javaCallables[3]) == null) {
  295.                 throw self.getRuntime().newArgumentError(3, javaCallables.length - 1);
  296.             }
  297.             callable = CallableSelector.matchingCallableArityThree(runtime, cache, callablesForArity, arg0, arg1, arg2);
  298.             if (callable == null) {
  299.                 throw CallableSelector.argTypesDoNotMatch(self.getRuntime(), self, callablesForArity, arg0, arg1, arg2);
  300.             }
  301.         } else {
  302.             if (callable.getParameterTypes().length != 3) {
  303.                 throw self.getRuntime().newArgumentError(3, callable.getParameterTypes().length);
  304.             }
  305.         }
  306.         return callable;
  307.     }

  309.     protected JavaCallable findCallableArityFour(IRubyObject self, String name, IRubyObject arg0, IRubyObject arg1, IRubyObject arg2, IRubyObject arg3) {
  310.         JavaCallable callable;
  311.         if ((callable = javaCallable) == null) {
  312.             // TODO: varargs?
  313.             JavaCallable[] callablesForArity = null;
  314.             if (javaCallables.length <= 4 || (callablesForArity = javaCallables[4]) == null) {
  315.                 throw self.getRuntime().newArgumentError(4, javaCallables.length - 1);
  316.             }
  317.             callable = CallableSelector.matchingCallableArityFour(runtime, cache, callablesForArity, arg0, arg1, arg2, arg3);
  318.             if (callable == null) {
  319.                 throw CallableSelector.argTypesDoNotMatch(self.getRuntime(), self, callablesForArity, arg0, arg1, arg2, arg3);
  320.             }
  321.         } else {
  322.             if (callable.getParameterTypes().length != 4) {
  323.                 throw self.getRuntime().newArgumentError(4, callable.getParameterTypes().length);
  324.             }
  325.         }
  326.         return callable;
  327.     }
  328. }
Created with JaCoCo 0.7.3.201501050207