public JavaProxyConstructor[] getConstructors() { JavaProxyConstructor[] constructors = this.constructors; if ( constructors != null ) return constructors; final Ruby runtime = getRuntime(); final Constructor[] ctors = proxyClass.getConstructors(); constructors = new JavaProxyConstructor[ ctors.length ]; for ( int i = 0; i < ctors.length; i++ ) { constructors[i] = new JavaProxyConstructor(runtime, this, ctors[i]); } return this.constructors = constructors; }
protected String nameOnInspection() { return getDeclaringClass().nameOnInspection(); }
public IRubyObject inspect() { StringBuilder result = new StringBuilder(); result.append(nameOnInspection()); Class<?>[] parameterTypes = getParameterTypes(); for (int i = 0; i < parameterTypes.length; i++) { result.append(parameterTypes[i].getName()); if (i < parameterTypes.length - 1) { result.append(','); } } result.append(")>"); return getRuntime().newString(result.toString()); }
@JRubyMethod public final RubyArray argument_types() { return toRubyArray(getParameterTypes()); }
@JRubyMethod public RubyArray argument_types() { return buildRubyArray(getParameterTypes()); }
public JavaObject newInstance(final IRubyObject self, Object[] args) throws RaiseException { final Ruby runtime = getRuntime(); JavaProxyInvocationHandler handler = new MethodInvocationHandler(runtime, self); try { return JavaObject.wrap(runtime, newInstance(args, handler)); } catch (Throwable ex) { throw mapInstantiationException(runtime, ex); } }
@JRubyMethod(required = 1, optional = 1) public RubyObject new_instance(IRubyObject[] args, Block block) { int size = Arity.checkArgumentCount(getRuntime(), args, 1, 2) - 1; final RubyProc proc; proc = (RubyProc) args[size]; } else { proc = getRuntime().newProc(Block.Type.PROC,block); size++; Class<?>[] parameterTypes = getParameterTypes(); for (int i = 0; i < count; i++) { IRubyObject ith = constructor_args.aref(getRuntime().newFixnum(i)); converted[i] = ith.toJava(parameterTypes[i]); result = newInstance(converted, handler); } catch (Exception e) { RaiseException ex = getRuntime().newArgumentError( "Constructor invocation failed: " + e.getMessage()); ex.initCause(e); return JavaObject.wrap(getRuntime(), result);
@JRubyMethod(rest = true) public RubyObject new_instance2(IRubyObject[] args, Block unusedBlock) { final Ruby runtime = getRuntime(); Arity.checkArgumentCount(runtime, args, 2, 2); final IRubyObject self = args[0]; final Object[] convertedArgs = convertArguments((RubyArray) args[1]); // constructor arguments JavaProxyInvocationHandler handler = new MethodInvocationHandler(runtime, self); try { return JavaObject.wrap(runtime, newInstance(convertedArgs, handler)); } catch (Exception ex) { throw mapInstantiationException(runtime, ex); } }
public final JavaObject newInstance(final IRubyObject self, IRubyObject[] args) throws RaiseException { final Ruby runtime = getRuntime(); final Object[] javaArgsPlus1 = RubyToJavaInvoker.convertArguments(this, args, +1); JavaProxyInvocationHandler handler = new MethodInvocationHandler(runtime, self); try { return JavaObject.wrap(runtime, newInstanceImpl(javaArgsPlus1, handler)); } catch (Throwable ex) { throw mapInstantiationException(runtime, ex); } }
@JRubyMethod(required = 1, optional = 1) public RubyObject new_instance(IRubyObject[] args, Block block) { final Ruby runtime = getRuntime(); final int last = Arity.checkArgumentCount(runtime, args, 1, 2) - 1; final RubyProc proc; // Is there a supplied proc arg or do we assume a block was supplied if (args[last] instanceof RubyProc) { proc = (RubyProc) args[last]; } else { proc = runtime.newProc(Block.Type.PROC, block); } final Object[] convertedArgs = convertArguments((RubyArray) args[0]); JavaProxyInvocationHandler handler = new ProcInvocationHandler(runtime, proc); try { return JavaObject.wrap(runtime, newInstance(convertedArgs, handler)); } catch (Exception e) { RaiseException ex = runtime.newArgumentError("Constructor invocation failed: " + e.getMessage()); ex.initCause(e); throw ex; } }
public static Object newProxyInstance(Ruby runtime, Class superClass, Class[] interfaces, Class[] constructorParameters, Object[] constructorArgs, JavaProxyInvocationHandler handler) throws IllegalArgumentException, InstantiationException, IllegalAccessException, InvocationTargetException, SecurityException, NoSuchMethodException { JavaProxyClass proxyClass = newProxyClass(runtime, superClass, interfaces); JavaProxyConstructor constructor = proxyClass.getConstructor( constructorParameters == null ? EMPTY_CLASS_ARRAY : constructorParameters ); return constructor.newInstance(constructorArgs, handler); }
@Override @JRubyMethod public RubyString inspect() { StringBuilder str = new StringBuilder(); str.append("#<"); str.append( getDeclaringClass().nameOnInspection() ); inspectParameterTypes(str, this); str.append('>'); return RubyString.newString(getRuntime(), str); }
@JRubyMethod public RubyFixnum arity() { return getRuntime().newFixnum(getParameterTypes().length); }
for (int i = 0; i < constructors.size(); i++) { JavaProxyConstructor constructor = (JavaProxyConstructor)constructors.eltInternal(i); if (constructor.getParameterTypes().length == args.length) { forArity.add(constructor); Class[] parameterTypes = matching.getParameterTypes(); for (int i = 0; i < args.length; i++) { newArgs[i] = args[i].toJava(parameterTypes[i]); JavaObject newObject = matching.newInstance(self, newArgs); return JavaUtilities.set_java_object(self, self, newObject);
return JavaObject.wrap(getRuntime(), newInstance(args, handler)); } catch (Throwable t) { while (t.getCause() != null) { t = t.getCause(); RaiseException ex = getRuntime().newArgumentError( "Constructor invocation failed: " + t.getMessage()); ex.initCause(t);
@JRubyMethod public RubyFixnum arity() { return getRuntime().newFixnum(getArity()); }
public final int getArity() { return getParameterTypes().length; }
public static void createJavaProxyClasses(final Ruby runtime, final RubyModule Java) { JavaProxyClass.createJavaProxyClassClass(runtime, Java); ProxyMethodImpl.createJavaProxyMethodClass(runtime, Java); JavaProxyConstructor.createJavaProxyConstructorClass(runtime, Java); }
public Object invoke(Object proxy, JavaProxyMethod method, Object[] nargs) throws Throwable { int length = nargs == null ? 0 : nargs.length; IRubyObject[] rubyArgs = new IRubyObject[length + 2]; rubyArgs[0] = JavaObject.wrap(recv.getRuntime(), proxy); rubyArgs[1] = method; for (int i = 0; i < length; i++) { rubyArgs[i + 2] = JavaUtil.convertJavaToRuby(getRuntime(), nargs[i]); } IRubyObject call_result = proc.call(getRuntime().getCurrentContext(), rubyArgs); Object converted_result = call_result.toJava(method.getReturnType()); return converted_result; }
@Override public String toString() { return inspect().toString(); }