public static void createRubyDescriptor(Ruby runtime) { RubyModule protobuf = runtime.getClassFromPath("Google::Protobuf"); RubyClass cDescriptor = protobuf.defineClassUnder("Descriptor", runtime.getObject(), new ObjectAllocator() { @Override public IRubyObject allocate(Ruby runtime, RubyClass klazz) { return new RubyDescriptor(runtime, klazz); } }); cDescriptor.includeModule(runtime.getEnumerable()); cDescriptor.defineAnnotatedMethods(RubyDescriptor.class); }
public static void createRubyEnumDescriptor(Ruby runtime) { RubyModule mProtobuf = runtime.getClassFromPath("Google::Protobuf"); RubyClass cEnumDescriptor = mProtobuf.defineClassUnder("EnumDescriptor", runtime.getObject(), new ObjectAllocator() { @Override public IRubyObject allocate(Ruby runtime, RubyClass klazz) { return new RubyEnumDescriptor(runtime, klazz); } }); cEnumDescriptor.includeModule(runtime.getEnumerable()); cEnumDescriptor.defineAnnotatedMethods(RubyEnumDescriptor.class); }
public static void createRubyRepeatedField(Ruby runtime) { RubyModule mProtobuf = runtime.getClassFromPath("Google::Protobuf"); RubyClass cRepeatedField = mProtobuf.defineClassUnder("RepeatedField", runtime.getObject(), new ObjectAllocator() { @Override public IRubyObject allocate(Ruby runtime, RubyClass klazz) { return new RubyRepeatedField(runtime, klazz); } }); cRepeatedField.defineAnnotatedMethods(RubyRepeatedField.class); cRepeatedField.includeModule(runtime.getEnumerable()); }
public static void createRubyMap(Ruby runtime) { RubyModule protobuf = runtime.getClassFromPath("Google::Protobuf"); RubyClass cMap = protobuf.defineClassUnder("Map", runtime.getObject(), new ObjectAllocator() { @Override public IRubyObject allocate(Ruby ruby, RubyClass rubyClass) { return new RubyMap(ruby, rubyClass); } }); cMap.includeModule(runtime.getEnumerable()); cMap.defineAnnotatedMethods(RubyMap.class); }
public static void createRubyOneofDescriptor(Ruby runtime) { RubyModule protobuf = runtime.getClassFromPath("Google::Protobuf"); RubyClass cRubyOneofDescriptor = protobuf.defineClassUnder("OneofDescriptor", runtime.getObject(), new ObjectAllocator() { @Override public IRubyObject allocate(Ruby ruby, RubyClass rubyClass) { return new RubyOneofDescriptor(ruby, rubyClass); } }); cRubyOneofDescriptor.defineAnnotatedMethods(RubyOneofDescriptor.class); cRubyOneofDescriptor.includeModule(runtime.getEnumerable()); }
static RubyClass define(final Ruby runtime, final RubyClass proxy) { proxy.includeModule( runtime.getComparable() ); // include Comparable proxy.defineAnnotatedMethods(Class.class); return proxy; }
private static void includeModule(RubyClass clazz, String moduleName, String... moduleNames) { RubyModule module = clazz.getRuntime().getModule(moduleName); if (moduleNames != null && moduleNames.length > 0) { for (String submoduleName: moduleNames) { module = module.defineOrGetModuleUnder(submoduleName); } } clazz.includeModule(module); }
public static RubyClass createEnumsClass(Ruby runtime, RubyModule ffiModule) { RubyClass enumsClass = ffiModule.defineClassUnder("Enums", runtime.getObject(), Allocator.INSTANCE); enumsClass.defineAnnotatedMethods(Enums.class); enumsClass.defineAnnotatedConstants(Enums.class); enumsClass.includeModule(ffiModule.getConstant("DataConverter")); return enumsClass; }
public static RubyClass createStructByReferenceClass(Ruby runtime, RubyModule ffiModule) { RubyClass sbrClass = ffiModule.defineClassUnder("StructByReference", runtime.getObject(), ObjectAllocator.NOT_ALLOCATABLE_ALLOCATOR); sbrClass.defineAnnotatedMethods(StructByReference.class); sbrClass.defineAnnotatedConstants(StructByReference.class); sbrClass.includeModule(ffiModule.getConstant("DataConverter")); return sbrClass; }
public static RubyClass createFileStatClass(Ruby runtime) { // TODO: NOT_ALLOCATABLE_ALLOCATOR is probably ok here. Confirm. JRUBY-415 final RubyClass fileStatClass = runtime.getFile().defineClassUnder("Stat",runtime.getObject(), ALLOCATOR); runtime.setFileStat(fileStatClass); fileStatClass.includeModule(runtime.getModule("Comparable")); fileStatClass.defineAnnotatedMethods(RubyFileStat.class); return fileStatClass; }
public static void createGeneratorClass(Ruby runtime) { RubyClass genc = runtime.defineClassUnder("Generator", runtime.getObject(), new ObjectAllocator() { @Override public IRubyObject allocate(Ruby runtime, RubyClass klazz) { return new RubyGenerator(runtime, klazz); } }, runtime.getEnumerator()); genc.includeModule(runtime.getEnumerable()); genc.defineAnnotatedMethods(RubyGenerator.class); runtime.setGenerator(genc); }
static void createUDPSocket(Ruby runtime) { RubyClass rb_cUDPSocket = runtime.defineClass("UDPSocket", runtime.getClass("IPSocket"), UDPSOCKET_ALLOCATOR); rb_cUDPSocket.includeModule(runtime.getClass("Socket").getConstant("Constants")); rb_cUDPSocket.defineAnnotatedMethods(RubyUDPSocket.class); runtime.getObject().setConstant("UDPsocket", rb_cUDPSocket); }
public static void defineEnumerator(Ruby runtime) { final RubyModule Enumerable = runtime.getModule("Enumerable"); final RubyClass Enumerator; Enumerator = runtime.defineClass("Enumerator", runtime.getObject(), ALLOCATOR); Enumerator.includeModule(Enumerable); Enumerator.defineAnnotatedMethods(RubyEnumerator.class); runtime.setEnumerator(Enumerator); RubyGenerator.createGeneratorClass(runtime); RubyYielder.createYielderClass(runtime); }
public static RubyClass createDirClass(Ruby runtime) { RubyClass dirClass = runtime.defineClass("Dir", runtime.getObject(), DIR_ALLOCATOR); runtime.setDir(dirClass); dirClass.setClassIndex(ClassIndex.DIR); dirClass.setReifiedClass(RubyDir.class); dirClass.includeModule(runtime.getEnumerable()); dirClass.defineAnnotatedMethods(RubyDir.class); return dirClass; }
/** rb_mod_extend_object * */ @JRubyMethod(name = "extend_object", required = 1, visibility = PRIVATE) public IRubyObject extend_object(IRubyObject obj) { if (!isModule()) { throw getRuntime().newTypeError(this, getRuntime().getModule()); } obj.getSingletonClass().includeModule(this); return obj; }
public static RubyClass createNumericClass(Ruby runtime) { RubyClass numeric = runtime.defineClass("Numeric", runtime.getObject(), NUMERIC_ALLOCATOR); runtime.setNumeric(numeric); numeric.setClassIndex(ClassIndex.NUMERIC); numeric.setReifiedClass(RubyNumeric.class); numeric.kindOf = new RubyModule.JavaClassKindOf(RubyNumeric.class); numeric.includeModule(runtime.getComparable()); numeric.defineAnnotatedMethods(RubyNumeric.class); return numeric; }
public static RubyClass createArrayJavaProxy(ThreadContext context) { Ruby runtime = context.runtime; RubyClass arrayJavaProxy = runtime.defineClass("ArrayJavaProxy", runtime.getJavaSupport().getJavaProxyClass(), ObjectAllocator.NOT_ALLOCATABLE_ALLOCATOR); RubyClass singleton = arrayJavaProxy.getSingletonClass(); singleton.addMethod("new", new ArrayNewMethod(singleton, Visibility.PUBLIC)); arrayJavaProxy.defineAnnotatedMethods(ArrayJavaProxy.class); arrayJavaProxy.includeModule(runtime.getEnumerable()); return arrayJavaProxy; }
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; }
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 void initArgsFile(final Ruby runtime) { RubyClass argfClass = runtime.defineClass("ARGFClass", runtime.getObject(), ARGF_ALLOCATOR); argfClass.includeModule(runtime.getEnumerable()); argfClass.defineAnnotatedMethods(RubyArgsFile.class); IRubyObject argsFile = argfClass.newInstance(runtime.getCurrentContext(), new IRubyObject[] { null }, (Block) null); runtime.setArgsFile(argsFile); runtime.getGlobalVariables().defineReadonly("$<", new ArgsFileAccessor(runtime), GlobalVariable.Scope.GLOBAL); runtime.defineGlobalConstant("ARGF", argsFile); runtime.defineReadonlyVariable("$FILENAME", runtime.newString("-"), GlobalVariable.Scope.GLOBAL); }