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; }
@Override protected RubyClass getSuperClass(RubyClass definingModule) { return definingModule.getMetaClass().getMetaClass().getSuperClass(); }
private MethodInvoker getMethodInvoker(Method method) { if (Modifier.isStatic(method.getModifiers())) { return new StaticMethodInvoker(metaClass.getMetaClass(), method, method.getName()); } else { return new InstanceMethodInvoker(metaClass, method, method.getName()); } }
public static RubyClass createJavaObjectClass(Ruby runtime, RubyModule javaModule) { // FIXME: Ideally JavaObject instances should be marshallable, which means that // the JavaObject metaclass should have an appropriate allocator. JRUBY-414 RubyClass JavaObject = javaModule.defineClassUnder("JavaObject", runtime.getObject(), JAVA_OBJECT_ALLOCATOR); registerRubyMethods(runtime, JavaObject); JavaObject.getMetaClass().undefineMethod("new"); JavaObject.getMetaClass().undefineMethod("allocate"); return JavaObject; }
public IRubyObject invokeInherited(ThreadContext context, IRubyObject self, IRubyObject subclass) { DynamicMethod method = getMetaClass().searchMethod("inherited"); if (method.isUndefined()) { return Helpers.callMethodMissing(context, self, method.getVisibility(), "inherited", CallType.FUNCTIONAL, Block.NULL_BLOCK); } return method.call(context, self, getMetaClass(), "inherited", subclass, Block.NULL_BLOCK); }
private RubyClass getSuperSingletonMetaClass() { if (attached instanceof RubyClass) { RubyClass superClass = ((RubyClass) attached).getSuperClass(); if (superClass != null) superClass = superClass.getRealClass(); // #<Class:BasicObject>'s singleton class == Class.singleton_class if (superClass == null) return runtime.getClassClass().getSingletonClass(); return superClass.getMetaClass().getSingletonClass(); } return getSuperClass().getRealClass().getMetaClass(); // NOTE: is this correct? }
private RubyClass getSuperSingletonMetaClass() { if (attached instanceof RubyClass) { RubyClass superClass = ((RubyClass) attached).getSuperClass(); if (superClass != null) superClass = superClass.getRealClass(); // #<Class:BasicObject>'s singleton class == Class.singleton_class if (superClass == null) return runtime.getClassClass().getSingletonClass(); return superClass.getMetaClass().getSingletonClass(); } return getSuperClass().getRealClass().getMetaClass(); // NOTE: is this correct? }
@Override public IRubyObject allocate(Ruby runtime, RubyClass klass) { Set<String> foundVariables = klass.discoverInstanceVariables(); if (Options.DUMP_INSTANCE_VARS.load()) { System.err.println(klass + ";" + foundVariables); } ObjectAllocator allocator = RubyObjectSpecializer.specializeForVariables(klass, foundVariables); // invalidate metaclass so new allocator is picked up for specialized .new klass.getMetaClass().invalidateCacheDescendants(); return allocator.allocate(runtime, klass); } };
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; }
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; }
private static IRubyObject invokeProxyClassInherited(final ThreadContext context, final IRubyObject clazz, final IRubyObject subclazz) { final JavaSupport javaSupport = context.runtime.getJavaSupport(); RubyClass javaProxyClass = javaSupport.getJavaProxyClass().getMetaClass(); Helpers.invokeAs(context, javaProxyClass, clazz, "inherited", subclazz, Block.NULL_BLOCK); if ( ! ( subclazz instanceof RubyClass ) ) { throw context.runtime.newTypeError(subclazz, context.runtime.getClassClass()); } setupJavaSubclass(context, (RubyClass) subclazz); return context.nil; }
public static IRubyObject concrete_proxy_inherited(IRubyObject recv, IRubyObject subclass) { Ruby runtime = recv.getRuntime(); ThreadContext tc = runtime.getCurrentContext(); JavaSupport javaSupport = runtime.getJavaSupport(); RubyClass javaProxyClass = javaSupport.getJavaProxyClass().getMetaClass(); Helpers.invokeAs(tc, javaProxyClass, recv, "inherited", subclass, Block.NULL_BLOCK); return setupJavaSubclass(tc, subclass, recv.callMethod(tc, "java_class")); }
public static RubyClass createNilClass(Ruby runtime) { RubyClass nilClass = runtime.defineClass("NilClass", runtime.getObject(), NIL_ALLOCATOR); runtime.setNilClass(nilClass); nilClass.setClassIndex(ClassIndex.NIL); nilClass.setReifiedClass(RubyNil.class); nilClass.defineAnnotatedMethods(RubyNil.class); nilClass.getMetaClass().undefineMethod("new"); // FIXME: This is causing a verification error for some reason //nilClass.dispatcher = callbackFactory.createDispatcher(nilClass); return nilClass; }
public static RubyClass createFalseClass(Ruby runtime) { RubyClass falseClass = runtime.defineClass("FalseClass", runtime.getObject(), ObjectAllocator.NOT_ALLOCATABLE_ALLOCATOR); runtime.setFalseClass(falseClass); falseClass.setClassIndex(ClassIndex.FALSE); falseClass.setReifiedClass(RubyBoolean.class); falseClass.defineAnnotatedMethods(False.class); falseClass.defineAnnotatedMethods(RubyBoolean.class); falseClass.getMetaClass().undefineMethod("new"); return falseClass; }
public static RubyClass createTrueClass(Ruby runtime) { RubyClass trueClass = runtime.defineClass("TrueClass", runtime.getObject(), ObjectAllocator.NOT_ALLOCATABLE_ALLOCATOR); runtime.setTrueClass(trueClass); trueClass.setClassIndex(ClassIndex.TRUE); trueClass.setReifiedClass(RubyBoolean.class); trueClass.defineAnnotatedMethods(True.class); trueClass.defineAnnotatedMethods(RubyBoolean.class); trueClass.getMetaClass().undefineMethod("new"); return trueClass; }
public static RubyClass createMatchDataClass(Ruby runtime) { RubyClass matchDataClass = runtime.defineClass("MatchData", runtime.getObject(), MATCH_DATA_ALLOCATOR); runtime.setMatchData(matchDataClass); matchDataClass.setClassIndex(ClassIndex.MATCHDATA); matchDataClass.setReifiedClass(RubyMatchData.class); runtime.defineGlobalConstant("MatchingData", matchDataClass); matchDataClass.kindOf = new RubyModule.JavaClassKindOf(RubyMatchData.class); matchDataClass.getMetaClass().undefineMethod("new"); matchDataClass.defineAnnotatedMethods(RubyMatchData.class); return matchDataClass; }
public static RubyClass createMatchDataClass(Ruby runtime) { RubyClass matchDataClass = runtime.defineClass("MatchData", runtime.getObject(), MATCH_DATA_ALLOCATOR); runtime.setMatchData(matchDataClass); matchDataClass.setClassIndex(ClassIndex.MATCHDATA); matchDataClass.setReifiedClass(RubyMatchData.class); runtime.defineGlobalConstant("MatchingData", matchDataClass); matchDataClass.kindOf = new RubyModule.JavaClassKindOf(RubyMatchData.class); matchDataClass.getMetaClass().undefineMethod("new"); matchDataClass.defineAnnotatedMethods(RubyMatchData.class); return matchDataClass; }
public static RubyClass createSymbolClass(Ruby runtime) { RubyClass symbolClass = runtime.defineClass("Symbol", runtime.getObject(), ObjectAllocator.NOT_ALLOCATABLE_ALLOCATOR); runtime.setSymbol(symbolClass); RubyClass symbolMetaClass = symbolClass.getMetaClass(); symbolClass.setClassIndex(ClassIndex.SYMBOL); symbolClass.setReifiedClass(RubySymbol.class); symbolClass.kindOf = new RubyModule.JavaClassKindOf(RubySymbol.class); symbolClass.defineAnnotatedMethods(RubySymbol.class); symbolMetaClass.undefineMethod("new"); symbolClass.includeModule(runtime.getComparable()); return symbolClass; }
public static RubyClass createSymbolClass(Ruby runtime) { RubyClass symbolClass = runtime.defineClass("Symbol", runtime.getObject(), ObjectAllocator.NOT_ALLOCATABLE_ALLOCATOR); runtime.setSymbol(symbolClass); RubyClass symbolMetaClass = symbolClass.getMetaClass(); symbolClass.setClassIndex(ClassIndex.SYMBOL); symbolClass.setReifiedClass(RubySymbol.class); symbolClass.kindOf = new RubyModule.JavaClassKindOf(RubySymbol.class); symbolClass.defineAnnotatedMethods(RubySymbol.class); symbolMetaClass.undefineMethod("new"); symbolClass.includeModule(runtime.getComparable()); return symbolClass; }