Module: Rjb

Defined in:

lib/rjb.rb,
lib/rjb/list.rb,
lib/rjb/version.rb,
ext/rjb.c

Defined Under Namespace

Modules: Iterable, Iterator, JMethod, MODIFIER Classes: Rjb_JavaBridge, Rjb_JavaClass, Rjb_JavaProxy

Constant Summary

JIterable =

import('java.lang.Iterable')

JIterator =

import('java.util.Iterator')

VERSION =

rb_str_new2(RJB_VERSION)

Class Method Summary

• .add_classpath(jarname) ⇒ Object

  Rjb::add_classpath(jarname).

• .add_jar(jarname) ⇒ Object

  Rjb::add_jar(jarname).

• .bind(rbobj, itfname) ⇒ Object

  jclass Rjb::bind(rbobj, interface_name).

• .classes ⇒ Object

  return all classes that were already loaded.

• .import(clsname) ⇒ Object

  Jclass Rjb::import(classname).

• .load(*args) ⇒ Object

  load Java Virtual Machine def load(class_path = ”, vmargs = []) class_path: passes for the class dir and jar name vmargs: strng array of vmarg (such as -Xrs).

• .loaded? ⇒ Boolean
• .primitive_conversion ⇒ Object

  For JRuby conpatible option.

• .primitive_conversion=(val) ⇒ Object

  For JRuby conpatible option.

• .throw ⇒ Object
• .unbind(rbobj) ⇒ Object

  jclass Rjb::bind(rbobj, interface_name).

• .unload(*args) ⇒ Object
• .urls ⇒ Object

Class Method Details

.add_classpath(jarname) ⇒ Object

Rjb::add_classpath(jarname)

# File 'ext/rjb.c', line 2616

static VALUE rjb_s_add_classpath(VALUE self, VALUE jarname)
{
    VALUE cpath = rb_cvar_get(self, cvar_classpath);
    SafeStringValue(jarname);
    rb_ary_push(cpath, jarname);
    return cpath;
}

.add_jar(jarname) ⇒ Object

Rjb::add_jar(jarname)

# File 'ext/rjb.c', line 2627

static VALUE rjb_s_add_jar(VALUE self, VALUE jarname)
{
    size_t i;
    JNIEnv* jenv;
    size_t count;
    jvalue args[2];

    if (rb_type(jarname) != T_ARRAY)
    {
        SafeStringValue(jarname);
        count = 0;
    }
    else
    {
        count = RARRAY_LEN(jarname);
    }
    jenv = rjb_prelude();
    if (!j_url_loader)
    {
        j_url_loader = (*jenv)->NewGlobalRef(jenv,
                                             (*jenv)->FindClass(jenv, "java/net/URLClassLoader"));
        RJB_LOAD_METHOD(rjb_load_class, j_url_loader, "loadClass",
                        "(Ljava/lang/String;)Ljava/lang/Class;");
        RJB_LOAD_METHOD(url_loader_new, j_url_loader, "<init>",
                        "([Ljava/net/URL;Ljava/lang/ClassLoader;)V");
        RJB_LOAD_METHOD(url_geturls, j_url_loader, "getURLs",
                        "()[Ljava/net/URL;");
        RJB_LOAD_METHOD(url_add_url, j_url_loader, "addURL",
                        "(Ljava/net/URL;)V");
    }
    if (!url_loader)
    {
        args[0].l = (*jenv)->NewObjectArray(jenv, (jsize)((count == 0) ? 1 : count), j_url, NULL);
        rjb_check_exception(jenv, 0);
        if (!count)
        {
            (*jenv)->SetObjectArrayElement(jenv, args[0].l, 0,
                                       conv_jarname_to_url(jenv, jarname));
        }
        else
        {
            for (i = 0; i < count; i++) {
                (*jenv)->SetObjectArrayElement(jenv, args[0].l, (jint)i,
                                       conv_jarname_to_url(jenv, rb_ary_entry(jarname, i)));
            }
        }
        rjb_check_exception(jenv, 0);
        args[1].l = get_class_loader(jenv);
        url_loader = (*jenv)->NewObjectA(jenv, j_url_loader, url_loader_new, args);
        rjb_check_exception(jenv, 0);
        (*jenv)->NewGlobalRef(jenv, url_loader);
        (*jenv)->DeleteLocalRef(jenv, args[0].l);
    }
    else
    {
        jvalue v;
        if (count)
        {
            for (i = 0; i < count; i++)
            {
                v.l = conv_jarname_to_url(jenv, rb_ary_entry(jarname, i));
                (*jenv)->CallObjectMethod(jenv, url_loader, url_add_url, v);
                rjb_check_exception(jenv, 0);
                (*jenv)->DeleteLocalRef(jenv, v.l);
            }
        }
        else
        {
            v.l = conv_jarname_to_url(jenv, jarname);
            (*jenv)->CallObjectMethod(jenv, url_loader, url_add_url, v);
            rjb_check_exception(jenv, 0);
            (*jenv)->DeleteLocalRef(jenv, v.l);
        }
    }
    return Qtrue;
}

.bind(rbobj, itfname) ⇒ Object

jclass Rjb::bind(rbobj, interface_name)

# File 'ext/rjb.c', line 2453

static VALUE rjb_s_bind(VALUE self, VALUE rbobj, VALUE itfname)
{
    VALUE result = Qnil;
    jclass itf;
    JNIEnv* jenv = rjb_prelude();

    itf = rjb_find_class(jenv, itfname);
    rjb_check_exception(jenv, 1);
    if (itf)
    {
	struct rj_bridge* ptr = ALLOC(struct rj_bridge);
	memset(ptr, 0, sizeof(struct rj_bridge));
	ptr->bridge = (*jenv)->NewGlobalRef(jenv,
                                   (*jenv)->AllocObject(jenv, rjb_rbridge));
	if (!ptr->bridge)
	{
	    free(ptr);
	    rjb_check_exception(jenv, 1);
	    return Qnil;
	}
	ptr->proxy = (*jenv)->CallObjectMethod(jenv, ptr->bridge,
					       rjb_register_bridge, itf);
        ptr->proxy = (*jenv)->NewGlobalRef(jenv, ptr->proxy);
	ptr->wrapped = rbobj;
	result = Data_Wrap_Struct(rjbb, rj_bridge_mark, rj_bridge_free, ptr);
	rb_ary_push(proxies, result);
        rb_ivar_set(result, rb_intern("@wrapped"), rbobj);
    }
    return result;
}

.classes ⇒ Object

return all classes that were already loaded. this method simply returns the global hash, but it’s safe because the hash was frozen.

# File 'ext/rjb.c', line 1933

static VALUE rjb_s_classes(VALUE self)
{
    return rjb_loaded_classes;
}

.import(clsname) ⇒ Object

Jclass Rjb::import(classname)

# File 'ext/rjb.c', line 2522

static VALUE rjb_s_import(VALUE self, VALUE clsname)
{
    JNIEnv* jenv;
    jclass jcls;
    VALUE v = rb_hash_aref(rjb_loaded_classes, clsname);
    if (v != Qnil)
    {
	return v;
    }

    jenv = rjb_prelude();
    jcls = rjb_find_class(jenv, clsname);
    if (!jcls)
    {
	rjb_check_exception(jenv, 0);
	rb_raise(rb_eRuntimeError, "`%s' not found", StringValueCStr(clsname));
    }
    v = import_class(jenv, jcls, clsname);
    return v;
}

.load(*args) ⇒ Object

load Java Virtual Machine def load(class_path = ”, vmargs = []) class_path: passes for the class dir and jar name vmargs: strng array of vmarg (such as -Xrs)

change in rjb 0.1.7, omit first argument for JNI version.

because I misunderstood the number means (JVM but JNI).

# File 'ext/rjb.c', line 1733

static VALUE rjb_s_load(int argc, VALUE* argv, VALUE self)
{
    JNIEnv* jenv;
    JavaVMInitArgs vm_args;
    jint res;
    VALUE classpath;
    VALUE user_path;
    VALUE vm_argv;
    char* userpath;
    ID stradd = rb_intern("<<");
    ID pathsep = rb_intern("PATH_SEPARATOR");
    int i;
    jclass jmethod;
    jclass jfield;
    jclass jconstructor;

    if (rjb_jvm)
    {
	return Qnil;
    }

    memset(&vm_args, 0, sizeof(vm_args));
    vm_args.version = JNI_VERSION_1_4;
    rb_scan_args(argc, argv, "02", &user_path, &vm_argv);
    if (!NIL_P(user_path))
    {
        Check_Type(user_path, T_STRING);
    }
    else
    {
	user_path = rb_str_new2(".");
    }
    classpath = rb_cvar_get(rjb, cvar_classpath);
    for (i = 0; i < RARRAY_LEN(classpath); i++)
    {
        rb_funcall(user_path, stradd, 1, rb_const_get(rb_cFile, pathsep));
        rb_funcall(user_path, stradd, 1, rb_ary_entry(classpath, 0));
    }
    userpath = StringValueCStr(user_path);

    if (!NIL_P(vm_argv))
    {
        Check_Type(vm_argv, T_ARRAY);
    }
    jenv = NULL;
    res = rjb_create_jvm(&jenv, &vm_args, userpath, vm_argv);
    if (res < 0)
    {
	rjb_jvm = NULL;
	rb_raise(rb_eRuntimeError, "can't create Java VM");
    } else {
        main_jenv = jenv;
    }

    RJB_FIND_CLASS(jconstructor, "java/lang/reflect/Constructor");
    RJB_LOAD_METHOD(ctrGetParameterTypes, jconstructor, "getParameterTypes", "()[Ljava/lang/Class;");
    RJB_FIND_CLASS(jmethod, "java/lang/reflect/Method");
    RJB_LOAD_METHOD(method_getModifiers, jmethod, "getModifiers", "()I");
    RJB_LOAD_METHOD(method_getName, jmethod, "getName", "()Ljava/lang/String;");
    RJB_LOAD_METHOD(getParameterTypes, jmethod, "getParameterTypes", "()[Ljava/lang/Class;");
    RJB_LOAD_METHOD(getReturnType, jmethod, "getReturnType", "()Ljava/lang/Class;");
    rjb_check_exception(jenv, 1);

    RJB_FIND_CLASS(jfield, "java/lang/reflect/Field");
    RJB_LOAD_METHOD(field_getModifiers, jfield, "getModifiers", "()I");
    RJB_LOAD_METHOD(field_getName, jfield, "getName", "()Ljava/lang/String;");
    RJB_LOAD_METHOD(field_getType, jfield, "getType", "()Ljava/lang/Class;");
    rjb_check_exception(jenv, 1);

    RJB_HOLD_CLASS(j_class, "java/lang/Class");
    RJB_LOAD_METHOD(rjb_class_getName, j_class, "getName", "()Ljava/lang/String;");
    rjb_check_exception(jenv, 1);

    RJB_HOLD_CLASS(rjb_j_throwable, "java/lang/Throwable");
    RJB_LOAD_METHOD(rjb_throwable_getMessage, rjb_j_throwable, "getMessage", "()Ljava/lang/String;");
    rjb_check_exception(jenv, 1);

    RJB_HOLD_CLASS(j_string, "java/lang/String");
    RJB_LOAD_METHOD(str_tostring, j_string, "toString", "()Ljava/lang/String;");
    rjb_check_exception(jenv, 1);

    RJB_HOLD_CLASS(j_object, "java/lang/Object");
    rjb_check_exception(jenv, 1);

    RJB_HOLD_CLASS(j_url, "java/net/URL");
    RJB_LOAD_METHOD(url_new, j_url, "<init>", "(Ljava/lang/String;)V");
    rjb_check_exception(jenv, 1);

    for (i = PRM_INT; i < PRM_LAST; i++)
    {
	jclass klass;
        RJB_FIND_CLASS(klass, jpcvt[i].classname);
	if (i == PRM_BOOLEAN)
	{
            RJB_LOAD_STATIC_METHOD(jpcvt[i].ctr_id, klass, "valueOf", jpcvt[i].ctrsig);
	}
	else if (jpcvt[i].ctrsig)
	{
            RJB_LOAD_METHOD(jpcvt[i].ctr_id, klass, "<init>", jpcvt[i].ctrsig);
	}
        RJB_LOAD_METHOD(jpcvt[i].to_prim_id, klass,
				   jpcvt[i].to_prim_method, jpcvt[i].prmsig);

        jpcvt[i].klass = (*jenv)->NewGlobalRef(jenv, klass);
    }

    jklass = import_class(jenv, j_class, rb_str_new2("java.lang.Class"));
    rb_define_method(rb_singleton_class(jklass), "forName", rjb_class_forname, -1);
    rb_define_alias(rb_singleton_class(jklass), "for_name", "forName");
    rb_gc_register_address(&jklass);

    return Qnil;
}

.loaded? ⇒ Boolean

Returns:

• (Boolean)

# File 'ext/rjb.c', line 1923

static VALUE rjb_s_loaded(VALUE self)
{
    return (rjb_jvm) ? Qtrue : Qfalse;
}

.primitive_conversion ⇒ Object

For JRuby conpatible option

# File 'ext/rjb.c', line 1950

static VALUE rjb_s_get_pconversion(VALUE self)
{
    return primitive_conversion;
}

.primitive_conversion=(val) ⇒ Object

For JRuby conpatible option

# File 'ext/rjb.c', line 1941

static VALUE rjb_s_set_pconversion(VALUE self, VALUE val)
{
    primitive_conversion = (RTEST(val)) ? Qtrue : Qfalse;
    return val;
}

.throw ⇒ Object

.unbind(rbobj) ⇒ Object

jclass Rjb::bind(rbobj, interface_name)

# File 'ext/rjb.c', line 2510

static VALUE rjb_s_unbind(VALUE self, VALUE rbobj)
{
#if defined(RUBINIUS)
    return rb_funcall(proxies, rb_intern("delete"), 1, rbobj);
#else
    return rb_ary_delete(proxies, rbobj);
#endif
}

.unload(*args) ⇒ Object

# File 'ext/rjb.c', line 1899

static VALUE rjb_s_unload(int argc, VALUE* argv, VALUE self)
{
    int result = 0;
#if defined(HAVE_RB_HASH_FOREACH) || defined(RUBINIUS)
	rb_hash_foreach(rjb_loaded_classes, clear_classes, 0);
#else
#if defined(RHASH_TBL)
    st_foreach(RHASH_TBL(rjb_loaded_classes), clear_classes, 0);
#else
    st_foreach(RHASH(rjb_loaded_classes)->tbl, clear_classes, 0);
#endif
#endif

    if (rjb_jvm)
    {
        JNIEnv* jenv = rjb_attach_current_thread();
        (*jenv)->ExceptionClear(jenv);
        result = (*rjb_jvm)->DestroyJavaVM(rjb_jvm);
        rjb_jvm = NULL;
        rjb_unload_vm();
    }
    return INT2NUM(result);
}

.urls ⇒ Object

# File 'ext/rjb.c', line 2704

static VALUE rjb_s_urls(VALUE self)
{
    JNIEnv* jenv;
    jvalue ret;
    if (!url_loader) return Qnil;
    jenv = rjb_prelude();
    ret.l = (*jenv)->CallObjectMethod(jenv, url_loader, url_geturls);
    return jarray2rv(jenv, ret);
}