private RubyModule buildClassFromDescriptor(ThreadContext context) { Ruby runtime = context.runtime; ObjectAllocator allocator = new ObjectAllocator() { @Override public IRubyObject allocate(Ruby runtime, RubyClass klazz) { return new RubyMessage(runtime, klazz, descriptor); } }; // rb_define_class_id RubyClass klass = RubyClass.newClass(runtime, runtime.getObject()); klass.setAllocator(allocator); klass.makeMetaClass(runtime.getObject().getMetaClass()); klass.inherit(runtime.getObject()); RubyModule messageExts = runtime.getClassFromPath("Google::Protobuf::MessageExts"); klass.include(new IRubyObject[] {messageExts}); klass.instance_variable_set(runtime.newString(Utils.DESCRIPTOR_INSTANCE_VAR), this); klass.defineAnnotatedMethods(RubyMessage.class); return klass; }
proxy = RubyClass.newClass(runtime, superClass);
@JRubyMethod(name = "new", rest = true) public static IRubyObject rbNew(ThreadContext context, IRubyObject self, IRubyObject[] args, Block block) { Ruby runtime = context.runtime; RubyClass implClass = (RubyClass)self.getInstanceVariables().getInstanceVariable("@__implementation"); if (implClass == null) { implClass = RubyClass.newClass(runtime, (RubyClass)runtime.getClass("InterfaceJavaProxy")); implClass.include(new IRubyObject[] {self}); Helpers.setInstanceVariable(implClass, self, "@__implementation"); } return Helpers.invoke(context, implClass, "new", args, block); } }
@JRubyMethod(name = "new", rest = true) public static IRubyObject rbNew(ThreadContext context, IRubyObject self, IRubyObject[] args, Block block) { Ruby runtime = context.runtime; RubyClass implClass = (RubyClass)self.getInstanceVariables().getInstanceVariable("@__implementation"); if (implClass == null) { implClass = RubyClass.newClass(runtime, (RubyClass)runtime.getClass("InterfaceJavaProxy")); implClass.include(new IRubyObject[] {self}); Helpers.setInstanceVariable(implClass, self, "@__implementation"); } return Helpers.invoke(context, implClass, "new", args, block); } }
/** * A variation on newClass that allows passing in an array of supplementary * call sites to improve dynamic invocation performance. */ public static RubyClass newClass(Ruby runtime, RubyClass superClass, String name, ObjectAllocator allocator, RubyModule parent, boolean setParent, CallSite[] extraCallSites) { RubyClass clazz = newClass(runtime, superClass, extraCallSites); clazz.setBaseName(name); clazz.setAllocator(allocator); clazz.makeMetaClass(superClass.getMetaClass()); if (setParent) clazz.setParent(parent); parent.setConstant(name, clazz); clazz.inherit(superClass); return clazz; }
/** * A variation on newClass that allows passing in an array of supplementary * call sites to improve dynamic invocation performance. */ public static RubyClass newClass(Ruby runtime, RubyClass superClass, String name, ObjectAllocator allocator, RubyModule parent, boolean setParent, CallSite[] extraCallSites) { RubyClass clazz = newClass(runtime, superClass, extraCallSites); clazz.setBaseName(name); clazz.setAllocator(allocator); clazz.makeMetaClass(superClass.getMetaClass()); if (setParent) clazz.setParent(parent); parent.setConstant(name, clazz); clazz.inherit(superClass); return clazz; }
/** * A variation on newClass that allows passing in an array of supplementary * call sites to improve dynamic invocation performance. */ public static RubyClass newClass(Ruby runtime, RubyClass superClass, String name, ObjectAllocator allocator, RubyModule parent, boolean setParent, CallSite[] extraCallSites) { RubyClass clazz = newClass(runtime, superClass, extraCallSites); clazz.setBaseName(name); clazz.setAllocator(allocator); clazz.makeMetaClass(superClass.getMetaClass()); if (setParent) clazz.setParent(parent); parent.setConstant(name, clazz); clazz.inherit(superClass); return clazz; }
/** * A variation on newClass that allows passing in an array of supplementary * call sites to improve dynamic invocation performance. */ public static RubyClass newClass(Ruby runtime, RubyClass superClass, String name, ObjectAllocator allocator, RubyModule parent, boolean setParent, CallSite[] extraCallSites) { RubyClass clazz = newClass(runtime, superClass, extraCallSites); clazz.setBaseName(name); clazz.setAllocator(allocator); clazz.makeMetaClass(superClass.getMetaClass()); if (setParent) clazz.setParent(parent); parent.setConstant(name, clazz); clazz.inherit(superClass); return clazz; }
/** * Construct a new class with the given name, allocator, parent class, * and containing class. If setParent is true, the class's parent will be * explicitly set to the provided parent (rather than the new class just * being assigned to a constant in that parent). * Corresponds to rb_class_new/rb_define_class_id/rb_name_class/rb_set_class_path * in MRI. */ public static RubyClass newClass(Ruby runtime, RubyClass superClass, String name, ObjectAllocator allocator, RubyModule parent, boolean setParent) { RubyClass clazz = newClass(runtime, superClass); clazz.setBaseName(name); clazz.setAllocator(allocator); clazz.makeMetaClass(superClass.getMetaClass()); if (setParent) clazz.setParent(parent); parent.setConstant(name, clazz); clazz.inherit(superClass); return clazz; }
/** * Construct a new class with the given name, allocator, parent class, * and containing class. If setParent is true, the class's parent will be * explicitly set to the provided parent (rather than the new class just * being assigned to a constant in that parent). * Corresponds to rb_class_new/rb_define_class_id/rb_name_class/rb_set_class_path * in MRI. */ public static RubyClass newClass(Ruby runtime, RubyClass superClass, String name, ObjectAllocator allocator, RubyModule parent, boolean setParent) { RubyClass clazz = newClass(runtime, superClass); clazz.setBaseName(name); clazz.setAllocator(allocator); clazz.makeMetaClass(superClass.getMetaClass()); if (setParent) clazz.setParent(parent); parent.setConstant(name, clazz); clazz.inherit(superClass); return clazz; }
/** * Construct a new class with the given name, allocator, parent class, * and containing class. If setParent is true, the class's parent will be * explicitly set to the provided parent (rather than the new class just * being assigned to a constant in that parent). * Corresponds to rb_class_new/rb_define_class_id/rb_name_class/rb_set_class_path * in MRI. */ public static RubyClass newClass(Ruby runtime, RubyClass superClass, String name, ObjectAllocator allocator, RubyModule parent, boolean setParent) { RubyClass clazz = newClass(runtime, superClass); clazz.setBaseName(name); clazz.setAllocator(allocator); clazz.makeMetaClass(superClass.getMetaClass()); if (setParent) clazz.setParent(parent); parent.setConstant(name, clazz); clazz.inherit(superClass); return clazz; }
/** * Construct a new class with the given name, allocator, parent class, * and containing class. If setParent is true, the class's parent will be * explicitly set to the provided parent (rather than the new class just * being assigned to a constant in that parent). * Corresponds to rb_class_new/rb_define_class_id/rb_name_class/rb_set_class_path * in MRI. */ public static RubyClass newClass(Ruby runtime, RubyClass superClass, String name, ObjectAllocator allocator, RubyModule parent, boolean setParent) { RubyClass clazz = newClass(runtime, superClass); clazz.setBaseName(name); clazz.setAllocator(allocator); clazz.makeMetaClass(superClass.getMetaClass()); if (setParent) clazz.setParent(parent); parent.setConstant(name, clazz); clazz.inherit(superClass); return clazz; }
@JRubyMethod(rest = true) public static IRubyObject impl(ThreadContext context, IRubyObject self, IRubyObject[] args, final Block implBlock) { Ruby runtime = context.runtime; if (!implBlock.isGiven()) throw runtime.newArgumentError("block required to call #impl on a Java interface"); final RubyArray methodNames = (args.length > 0) ? runtime.newArray(args) : null; RubyClass implClass = RubyClass.newClass(runtime, runtime.getObject()); implClass.include(new IRubyObject[] {self}); IRubyObject implObject = implClass.callMethod(context, "new"); implClass.addMethod("method_missing", new org.jruby.internal.runtime.methods.JavaMethod(implClass, Visibility.PUBLIC) { @Override public IRubyObject call(ThreadContext context, IRubyObject self, RubyModule clazz, String name, IRubyObject[] args, Block block) { Arity.checkArgumentCount(context.runtime, name, args.length, 1, -1); if (methodNames == null || methodNames.include_p(context, args[0]).isTrue()) { return implBlock.call(context, args); } else { return clazz.getSuperClass().callMethod(context, "method_missing", args, block); } } }); return implObject; }
@JRubyMethod(rest = true) public static IRubyObject impl(ThreadContext context, IRubyObject self, IRubyObject[] args, final Block implBlock) { Ruby runtime = context.runtime; if (!implBlock.isGiven()) throw runtime.newArgumentError("block required to call #impl on a Java interface"); final RubyArray methodNames = (args.length > 0) ? runtime.newArray(args) : null; RubyClass implClass = RubyClass.newClass(runtime, runtime.getObject()); implClass.include(new IRubyObject[] {self}); IRubyObject implObject = implClass.callMethod(context, "new"); implClass.addMethod("method_missing", new org.jruby.internal.runtime.methods.JavaMethod(implClass, Visibility.PUBLIC) { @Override public IRubyObject call(ThreadContext context, IRubyObject self, RubyModule clazz, String name, IRubyObject[] args, Block block) { Arity.checkArgumentCount(context.runtime, name, args.length, 1, -1); if (methodNames == null || methodNames.include_p(context, args[0]).isTrue()) { return implBlock.call(context, args); } else { return clazz.getSuperClass().callMethod(context, "method_missing", args, block); } } }); return implObject; }
static RubyModule createJavaPackageClass(final Ruby runtime, final RubyModule Java) { RubyClass superClass = new BlankSlateWrapper(runtime, runtime.getModule(), runtime.getKernel()); RubyClass JavaPackage = RubyClass.newClass(runtime, superClass); JavaPackage.setMetaClass(runtime.getModule()); JavaPackage.setAllocator(ObjectAllocator.NOT_ALLOCATABLE_ALLOCATOR); ((MetaClass) JavaPackage.makeMetaClass(superClass)).setAttached(JavaPackage); JavaPackage.setBaseName("JavaPackage"); JavaPackage.setParent(Java); Java.setConstant("JavaPackage", JavaPackage); // Java::JavaPackage // JavaPackage.setReifiedClass(JavaPackage.class); JavaPackage.defineAnnotatedMethods(JavaPackage.class); return JavaPackage; }
static RubyModule createJavaPackageClass(final Ruby runtime, final RubyModule Java) { RubyClass superClass = new BlankSlateWrapper(runtime, runtime.getModule(), runtime.getKernel()); RubyClass JavaPackage = RubyClass.newClass(runtime, superClass); JavaPackage.setMetaClass(runtime.getModule()); JavaPackage.setAllocator(ObjectAllocator.NOT_ALLOCATABLE_ALLOCATOR); ((MetaClass) JavaPackage.makeMetaClass(superClass)).setAttached(JavaPackage); JavaPackage.setBaseName("JavaPackage"); JavaPackage.setParent(Java); Java.setConstant("JavaPackage", JavaPackage); // Java::JavaPackage // JavaPackage.setReifiedClass(JavaPackage.class); JavaPackage.defineAnnotatedMethods(JavaPackage.class); return JavaPackage; }
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; }
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; }
clazz = RubyClass.newClass(runtime, superClazz, name, allocator, this, true);
return RubyClass.newClass(this, superClass, id, allocator, parent, !parentIsObject, callSites);