@JRubyMethod public JavaClass component_type() { if ( ! javaClass().isArray() ) { throw getRuntime().newTypeError("not a java array-class"); } return JavaClass.get(getRuntime(), javaClass().getComponentType()); }
public static RubyClass toRubyClass(Ruby rubyRuntime, Class<?> rubyClass) { return JavaClass.get(rubyRuntime, rubyClass).getProxyClass(); }
@Override public JavaClass computeValue(Class<?> cls) { return new JavaClass(runtime, cls); } });
public final boolean isAssignableFrom(final Class<?> clazz) { return assignable(javaClass(), clazz); }
@JRubyMethod public RubyArray constructors() { final RubyArray constructors = this.constructors; if ( constructors != null) return constructors; return this.constructors = buildConstructors(getRuntime(), javaClass().getConstructors()); }
@JRubyMethod public RubyArray fields() { return buildFieldResults(getRuntime(), javaClass().getFields()); }
private Class<?>[] buildClassArgs(IRubyObject[] args) { Class<?>[] parameterTypes = new Class<?>[args.length]; for (int i = 0; i < args.length; i++) { JavaClass type; if (args[i] instanceof JavaClass) { type = (JavaClass)args[i]; } else if (args[i].respondsTo("java_class")) { type = (JavaClass)args[i].callMethod(getRuntime().getCurrentContext(), "java_class"); } else { type = for_name(this, args[i]); } parameterTypes[i] = type.javaClass(); } return parameterTypes; }
javaClass.lockProxy(); try { if ((proxyClass = javaClass.getProxyClass()) == null) { JavaClass ifc = JavaClass.get(runtime, interfaces[i]); javaClass.unlockProxy();
JavaClass.createJavaClassClass(runtime, javaModule); JavaMethod.createJavaMethodClass(runtime, javaModule); JavaConstructor.createJavaConstructorClass(runtime, javaModule); runtime.getJavaSupport().setObjectJavaClass(JavaClass.get(runtime, Object.class));
public static RubyArray toRubyArray(final Ruby runtime, final Class<?>[] classes) { IRubyObject[] javaClasses = new IRubyObject[classes.length]; for ( int i = classes.length; --i >= 0; ) { javaClasses[i] = get(runtime, classes[i]); } return RubyArray.newArrayMayCopy(runtime, javaClasses); }
@JRubyMethod(name = "assignable_from?", required = 1) public RubyBoolean assignable_from_p(IRubyObject other) { if (! (other instanceof JavaClass)) { throw getRuntime().newTypeError("assignable_from requires JavaClass (" + other.getType() + " given)"); } Class<?> otherClass = ((JavaClass) other).javaClass(); return assignable(javaClass(), otherClass) ? getRuntime().getTrue() : getRuntime().getFalse(); }
private static RubyClass createProxyClass(Ruby runtime, RubyClass baseType, JavaClass javaClass, boolean invokeInherited) { // JRUBY-2938 the proxy class might already exist RubyClass proxyClass = javaClass.getProxyClass(); if (proxyClass != null) return proxyClass; // this needs to be split, since conditional calling #inherited doesn't fit standard ruby semantics RubyClass.checkInheritable(baseType); RubyClass superClass = (RubyClass) baseType; proxyClass = RubyClass.newClass(runtime, superClass); proxyClass.makeMetaClass(superClass.getMetaClass()); try { javaClass.javaClass().asSubclass(java.util.Map.class); proxyClass.setAllocator(runtime.getJavaSupport().getMapJavaProxyClass().getAllocator()); proxyClass.defineAnnotatedMethods(MapJavaProxy.class); proxyClass.includeModule(runtime.getEnumerable()); } catch (ClassCastException e) { proxyClass.setAllocator(superClass.getAllocator()); } if (invokeInherited) { proxyClass.inherit(superClass); } proxyClass.callMethod(runtime.getCurrentContext(), "java_class=", javaClass); javaClass.setupProxy(proxyClass); // add java_method for unbound use proxyClass.defineAnnotatedMethods(JavaProxyClassMethods.class); return proxyClass; }
static JavaClass for_name(IRubyObject recv, String name) { return forNameVerbose(recv.getRuntime(), name); }
@JRubyMethod public RubyArray constructors() { RubyArray ctors; if ((ctors = constructors) != null) return ctors; return constructors = buildConstructors(javaClass().getConstructors()); }
@JRubyMethod public RubyArray fields() { return buildFieldResults(javaClass().getFields()); }
@JRubyMethod(name = "for_name", required = 1, meta = true) public static JavaClass for_name(IRubyObject recv, IRubyObject name) { return for_name(recv, name.asJavaString()); }
public void load(Ruby runtime, boolean wrap) throws IOException { createJavaModule(runtime); RubyModule jpmt = runtime.defineModule("JavaPackageModuleTemplate"); jpmt.getSingletonClass().setSuperClass(new BlankSlateWrapper(runtime, jpmt.getMetaClass().getSuperClass(), runtime.getKernel())); runtime.getLoadService().require("jruby/java"); // rewite ArrayJavaProxy superclass to point at Object, so it inherits Object behaviors RubyClass ajp = runtime.getClass("ArrayJavaProxy"); ajp.setSuperClass(runtime.getJavaSupport().getObjectJavaClass().getProxyClass()); ajp.includeModule(runtime.getEnumerable()); RubyClassPathVariable.createClassPathVariable(runtime); runtime.setJavaProxyClassFactory(JavaProxyClassFactory.createFactory()); // modify ENV_JAVA to be a read/write version Map systemProps = new SystemPropertiesMap(); runtime.getObject().setConstantQuiet( "ENV_JAVA", new MapJavaProxy( runtime, (RubyClass)Java.getProxyClass(runtime, SystemPropertiesMap.class), systemProps)); }
@JRubyMethod(required = 1) public IRubyObject extend_proxy(IRubyObject extender) { addProxyExtender(extender); return getRuntime().getNil(); }
private static boolean assignable(Class<?> type, final IRubyObject arg) { return JavaClass.assignable(type, getJavaClass(arg)) || // handle 'native' signatures e.g. method with a (org.jruby.RubyArray arg) ( arg != null && type.isAssignableFrom(arg.getClass()) ); }
static RubyClass createJavaClassClass(final Ruby runtime, final RubyModule Java, final RubyClass JavaObject) { // TODO: Determine if a real allocator is needed here. Do people want to extend // JavaClass? Do we want them to do that? Can you Class.new(JavaClass)? Should you be able to? // NOTE: NOT_ALLOCATABLE_ALLOCATOR is probably OK here, since we don't intend for people to monkey with // this type and it can't be marshalled. Confirm. JRUBY-415 RubyClass JavaClass = Java.defineClassUnder("JavaClass", JavaObject, ObjectAllocator.NOT_ALLOCATABLE_ALLOCATOR); JavaClass.includeModule(runtime.getModule("Comparable")); JavaClass.defineAnnotatedMethods(JavaClass.class); JavaClass.getMetaClass().undefineMethod("new"); JavaClass.getMetaClass().undefineMethod("allocate"); return JavaClass; }