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; }
private IRubyObject initializeCommon(ThreadContext context, RubyClass superClazz, Block block, boolean ruby1_9 /*callInheritBeforeSuper*/) { setSuperClass(superClazz); allocator = superClazz.allocator; makeMetaClass(superClazz.getMetaClass()); marshal = superClazz.marshal; superClazz.addSubclass(this); if (ruby1_9) { inherit(superClazz); super.initialize(context, block); } else { super.initialize(context, block); inherit(superClazz); } return this; }
private IRubyObject initializeCommon(ThreadContext context, RubyClass superClazz, Block block, boolean ruby1_9 /*callInheritBeforeSuper*/) { setSuperClass(superClazz); allocator = superClazz.allocator; makeMetaClass(superClazz.getMetaClass()); marshal = superClazz.marshal; superClazz.addSubclass(this); if (ruby1_9) { inherit(superClazz); super.initialize(context, block); } else { super.initialize(context, block); inherit(superClazz); } return this; }
private RubyClass initializeCommon(ThreadContext context, RubyClass superClazz, Block block) { setSuperClass(superClazz); allocator = superClazz.allocator; makeMetaClass(superClazz.getMetaClass()); marshal = superClazz.marshal; superClazz.addSubclass(this); inherit(superClazz); super.initialize(context, block); return this; }
private RubyClass initializeCommon(ThreadContext context, RubyClass superClazz, Block block) { setSuperClass(superClazz); allocator = superClazz.allocator; makeMetaClass(superClazz.getMetaClass()); marshal = superClazz.marshal; superClazz.addSubclass(this); inherit(superClazz); super.initialize(context, block); return this; }
/** * 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; }
private static RubyClass createProxyClass(final Ruby runtime, final RubyClass proxyClass, final Class<?> javaClass, final RubyClass superClass, boolean invokeInherited) { proxyClass.makeMetaClass( superClass.getMetaClass() ); if ( Map.class.isAssignableFrom( javaClass ) ) { proxyClass.setAllocator( runtime.getJavaSupport().getMapJavaProxyClass().getAllocator() ); proxyClass.defineAnnotatedMethods( MapJavaProxy.class ); proxyClass.includeModule( runtime.getEnumerable() ); } else { proxyClass.setAllocator( superClass.getAllocator() ); } proxyClass.defineAnnotatedMethods( JavaProxy.ClassMethods.class ); if ( invokeInherited ) proxyClass.inherit(superClass); Initializer.setupProxyClass(runtime, javaClass, proxyClass); return proxyClass; }
private static RubyClass createProxyClass(final Ruby runtime, final RubyClass proxyClass, final Class<?> javaClass, final RubyClass superClass, boolean invokeInherited) { proxyClass.makeMetaClass( superClass.getMetaClass() ); if ( Map.class.isAssignableFrom( javaClass ) ) { proxyClass.setAllocator( runtime.getJavaSupport().getMapJavaProxyClass().getAllocator() ); proxyClass.defineAnnotatedMethods( MapJavaProxy.class ); proxyClass.includeModule( runtime.getEnumerable() ); } else { proxyClass.setAllocator( superClass.getAllocator() ); } proxyClass.defineAnnotatedMethods( JavaProxy.ClassMethods.class ); if ( invokeInherited ) proxyClass.inherit(superClass); Initializer.setupProxyClass(runtime, javaClass, proxyClass); 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; }
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; }
newStruct.setAllocator(STRUCT_INSTANCE_ALLOCATOR); newStruct.makeMetaClass(superClass.getMetaClass()); newStruct.inherit(superClass); } else { if (!IdUtil.isConstant(name)) {
newStruct.setAllocator(STRUCT_INSTANCE_ALLOCATOR); newStruct.makeMetaClass(superClass.getMetaClass()); newStruct.inherit(superClass); } else { if (!IdUtil.isConstant(name)) {
newStruct.setAllocator(STRUCT_INSTANCE_ALLOCATOR); newStruct.makeMetaClass(superClass.getMetaClass()); newStruct.inherit(superClass); } else { if (!IdUtil.isConstant(name)) {