Struct swim_jvm::JEnv

pub struct JEnv { /* fields omitted */ }

Methods

impl JEnv

pub fn new(env: *mut JNIEnv) -> Self

pub fn get_version(&self) -> jint

pub fn define_class<S, O>(
    &self,
    name: S,
    loader: O,
    buf: &[u8]
) -> Result<JClass> where
    S: AsRef<CStr>,
    O: Into<jobject>, 

pub fn find_class<S>(&self, name: S) -> Result<JClass> where
    S: AsRef<CStr>, 

pub fn get_superclass<T>(&self, class: T) -> Result<JClass> where
    T: TryIntoJava<jclass>, 

pub fn is_assignable_from<T, U>(&self, sub: T, sup: U) -> Result<bool> where
    T: TryIntoJava<jclass>,
    U: TryIntoJava<jclass>, 

pub fn throw<T>(&self, throwable: T) where
    T: Into<jthrowable>, 

pub fn throw_new<C, S>(&self, class: C, msg: S) where
    C: IntoJava<jclass>,
    S: AsRef<CStr>, 

pub fn exception_occurred(&self) -> Option<JThrowable>

pub fn exception_describe(&self)

pub fn exception_clear(&self)

pub fn exception_check(&self) -> bool

pub fn fatal_error<S>(&self, msg: S) -> ! where
    S: AsRef<CStr>, 

pub fn new_global_ref<O>(&self, obj: O) -> Result<JGlobalRef> where
    O: Into<jobject>, 

pub unsafe fn delete_global_ref<R>(&self, gref: R) where
    R: Into<jobject>, 

pub fn new_local_ref<O>(&self, obj: O) -> Result<JLocalRef> where
    O: Into<jobject>, 

pub unsafe fn delete_local_ref<R>(&self, lref: R) where
    R: Into<jobject>, 

pub fn ensure_local_capacity(&self, capacity: jint) -> Result<()>

pub fn is_same_object<O1, O2>(&self, obj1: O1, obj2: O2) -> bool where
    O1: Into<jobject>,
    O2: Into<jobject>, 

pub fn alloc_object<C>(&self, cls: C) -> Result<JObject> where
    C: TryIntoJava<jclass>, 

pub fn get_object_class<O>(&self, obj: O) -> Result<JClass> where
    O: Into<jobject>, 

pub fn is_instance_of<O, C>(&self, obj: O, cls: C) -> bool where
    O: Into<jobject>,
    C: Into<jclass>, 

pub fn get_method_id<C, S, T>(&self, cls: C, name: S, sig: T) -> Result<JMethod> where
    C: TryIntoJava<jclass>,
    S: AsRef<CStr>,
    T: AsRef<CStr>, 

pub fn get_static_method_id<C, S, T>(
    &self,
    cls: C,
    name: S,
    sig: T
) -> Result<JMethod> where
    C: TryIntoJava<jclass>,
    S: AsRef<CStr>,
    T: AsRef<CStr>, 

pub fn call_method<O, M, R>(
    &self,
    obj: O,
    mid: M,
    ret: R,
    args: &[JValue]
) -> Result<JValue> where
    O: Into<jobject>,
    M: Into<jmethodID>,
    R: AsRef<JType>, 

pub fn call_nonvirtual_method<O, C, M, R>(
    &self,
    obj: O,
    cls: C,
    mid: M,
    ret: R,
    args: &[JValue]
) -> Result<JValue> where
    O: Into<jobject>,
    C: Into<jclass>,
    M: Into<jmethodID>,
    R: AsRef<JType>, 

pub fn call_static_method<C, M, R>(
    &self,
    cls: C,
    mid: M,
    ret: R,
    args: &[JValue]
) -> Result<JValue> where
    C: Into<jclass>,
    M: Into<jmethodID>,
    R: AsRef<JType>, 

pub fn new_object<C, M>(
    &self,
    cls: C,
    mid: M,
    args: &[JValue]
) -> Result<JObject> where
    C: Into<jclass>,
    M: Into<jmethodID>, 

pub fn get_field_id<C, S, T>(&self, cls: C, name: S, sig: T) -> Result<JField> where
    C: TryIntoJava<jclass>,
    S: AsRef<CStr>,
    T: AsRef<CStr>, 

pub fn get_field<O, F, T>(&self, obj: O, fid: F, ret: T) -> JValue where
    O: Into<jobject>,
    F: Into<jfieldID>,
    T: AsRef<JType>, 

pub fn get_boolean_field<O, F>(&self, obj: O, fid: F) -> bool where
    O: Into<jobject>,
    F: Into<jfieldID>, 

pub fn get_byte_field<O, F>(&self, obj: O, fid: F) -> jbyte where
    O: Into<jobject>,
    F: Into<jfieldID>, 

pub fn get_char_field<O, F>(&self, obj: O, fid: F) -> jchar where
    O: Into<jobject>,
    F: Into<jfieldID>, 

pub fn get_short_field<O, F>(&self, obj: O, fid: F) -> jshort where
    O: Into<jobject>,
    F: Into<jfieldID>, 

pub fn get_int_field<O, F>(&self, obj: O, fid: F) -> jint where
    O: Into<jobject>,
    F: Into<jfieldID>, 

pub fn get_long_field<O, F>(&self, obj: O, fid: F) -> jlong where
    O: Into<jobject>,
    F: Into<jfieldID>, 

pub fn get_float_field<O, F>(&self, obj: O, fid: F) -> jfloat where
    O: Into<jobject>,
    F: Into<jfieldID>, 

pub fn get_double_field<O, F>(&self, obj: O, fid: F) -> jdouble where
    O: Into<jobject>,
    F: Into<jfieldID>, 

pub fn get_object_field<O, F>(&self, obj: O, fid: F) -> JObject where
    O: Into<jobject>,
    F: Into<jfieldID>, 

pub fn set_field<O, F, V>(&self, obj: O, fid: F, val: V) where
    O: Into<jobject>,
    F: Into<jfieldID>,
    V: IntoJava<JValue>, 

pub fn set_boolean_field<O, F, V>(&self, obj: O, fid: F, val: V) where
    O: Into<jobject>,
    F: Into<jfieldID>,
    V: Into<bool>, 

pub fn set_byte_field<O, F, V>(&self, obj: O, fid: F, val: V) where
    O: Into<jobject>,
    F: Into<jfieldID>,
    V: Into<jbyte>, 

pub fn set_char_field<O, F, V>(&self, obj: O, fid: F, val: V) where
    O: Into<jobject>,
    F: Into<jfieldID>,
    V: Into<jchar>, 

pub fn set_short_field<O, F, V>(&self, obj: O, fid: F, val: V) where
    O: Into<jobject>,
    F: Into<jfieldID>,
    V: Into<jshort>, 

pub fn set_int_field<O, F, V>(&self, obj: O, fid: F, val: V) where
    O: Into<jobject>,
    F: Into<jfieldID>,
    V: Into<jint>, 

pub fn set_long_field<O, F, V>(&self, obj: O, fid: F, val: V) where
    O: Into<jobject>,
    F: Into<jfieldID>,
    V: Into<jlong>, 

pub fn set_float_field<O, F, V>(&self, obj: O, fid: F, val: V) where
    O: Into<jobject>,
    F: Into<jfieldID>,
    V: Into<jfloat>, 

pub fn set_double_field<O, F, V>(&self, obj: O, fid: F, val: V) where
    O: Into<jobject>,
    F: Into<jfieldID>,
    V: Into<jdouble>, 

pub fn set_object_field<O, F, V>(&self, obj: O, fid: F, val: V) where
    O: Into<jobject>,
    F: Into<jfieldID>,
    V: Into<jobject>, 

pub fn get_static_field_id<C, S, T>(
    &self,
    cls: C,
    name: S,
    sig: T
) -> Result<JField> where
    C: TryIntoJava<jclass>,
    S: AsRef<CStr>,
    T: AsRef<CStr>, 

pub fn get_static_field<C, F, T>(&self, cls: C, fid: F, ret: T) -> JValue where
    C: Into<jclass>,
    F: Into<jfieldID>,
    T: AsRef<JType>, 

pub fn get_static_boolean_field<C, F>(&self, cls: C, fid: F) -> bool where
    C: Into<jclass>,
    F: Into<jfieldID>, 

pub fn get_static_byte_field<C, F>(&self, cls: C, fid: F) -> jbyte where
    C: Into<jclass>,
    F: Into<jfieldID>, 

pub fn get_static_char_field<C, F>(&self, cls: C, fid: F) -> jchar where
    C: Into<jclass>,
    F: Into<jfieldID>, 

pub fn get_static_short_field<C, F>(&self, cls: C, fid: F) -> jshort where
    C: Into<jclass>,
    F: Into<jfieldID>, 

pub fn get_static_int_field<C, F>(&self, cls: C, fid: F) -> jint where
    C: Into<jclass>,
    F: Into<jfieldID>, 

pub fn get_static_long_field<C, F>(&self, cls: C, fid: F) -> jlong where
    C: Into<jclass>,
    F: Into<jfieldID>, 

pub fn get_static_float_field<C, F>(&self, cls: C, fid: F) -> jfloat where
    C: Into<jclass>,
    F: Into<jfieldID>, 

pub fn get_static_double_field<C, F>(&self, cls: C, fid: F) -> jdouble where
    C: Into<jclass>,
    F: Into<jfieldID>, 

pub fn get_static_object_field<C, F>(&self, cls: C, fid: F) -> JObject where
    C: Into<jclass>,
    F: Into<jfieldID>, 

pub fn set_static_field<C, F, V>(&self, cls: C, fid: F, val: V) where
    C: Into<jclass>,
    F: Into<jfieldID>,
    V: IntoJava<JValue>, 

pub fn set_static_boolean_field<C, F, V>(&self, cls: C, fid: F, val: V) where
    C: Into<jclass>,
    F: Into<jfieldID>,
    V: Into<bool>, 

pub fn set_static_byte_field<C, F, V>(&self, cls: C, fid: F, val: V) where
    C: Into<jclass>,
    F: Into<jfieldID>,
    V: Into<jbyte>, 

pub fn set_static_char_field<C, F, V>(&self, cls: C, fid: F, val: V) where
    C: Into<jclass>,
    F: Into<jfieldID>,
    V: Into<jchar>, 

pub fn set_static_short_field<C, F, V>(&self, cls: C, fid: F, val: V) where
    C: Into<jclass>,
    F: Into<jfieldID>,
    V: Into<jshort>, 

pub fn set_static_int_field<C, F, V>(&self, cls: C, fid: F, val: V) where
    C: Into<jclass>,
    F: Into<jfieldID>,
    V: Into<jint>, 

pub fn set_static_long_field<C, F, V>(&self, cls: C, fid: F, val: V) where
    C: Into<jclass>,
    F: Into<jfieldID>,
    V: Into<jlong>, 

pub fn set_static_float_field<C, F, V>(&self, cls: C, fid: F, val: V) where
    C: Into<jclass>,
    F: Into<jfieldID>,
    V: Into<jfloat>, 

pub fn set_static_double_field<C, F, V>(&self, cls: C, fid: F, val: V) where
    C: Into<jclass>,
    F: Into<jfieldID>,
    V: Into<jdouble>, 

pub fn set_static_object_field<C, F, V>(&self, cls: C, fid: F, val: V) where
    C: Into<jclass>,
    F: Into<jfieldID>,
    V: Into<jobject>, 

pub fn new_string_utf<'b, S>(&self, utf: S) -> Result<JString> where
    S: Into<&'b CStr>, 

pub fn get_string_length<S>(&self, str: S) -> jsize where
    S: Into<jstring>, 

pub fn get_string_utf_length<S>(&self, str: S) -> jsize where
    S: Into<jstring>, 

pub unsafe fn get_string_utf_chars<S>(
    &self,
    str: S,
    is_copy: &mut bool
) -> &CStr where
    S: Into<jstring>, 

pub unsafe fn release_string_utf_chars<S>(&self, str: S, cstr: &CStr) where
    S: Into<jstring>, 

pub fn get_string_utf_region<S>(
    &self,
    str: S,
    start: jsize,
    len: jsize,
    buf: &mut [cchar]
) where
    S: Into<jstring>, 

pub fn get_array_length<A>(&self, array: A) -> jsize where
    A: Into<jarray>, 

pub fn new_array<T>(&self, len: jsize, typ: T) -> Result<JArray> where
    T: AsRef<JType>, 

pub fn new_boolean_array(&self, len: jsize) -> Result<JArray>

pub fn new_byte_array(&self, len: jsize) -> Result<JArray>

pub fn new_char_array(&self, len: jsize) -> Result<JArray>

pub fn new_short_array(&self, len: jsize) -> Result<JArray>

pub fn new_int_array(&self, len: jsize) -> Result<JArray>

pub fn new_long_array(&self, len: jsize) -> Result<JArray>

pub fn new_float_array(&self, len: jsize) -> Result<JArray>

pub fn new_double_array(&self, len: jsize) -> Result<JArray>

pub fn new_object_array<C, O>(
    &self,
    len: jsize,
    cls: C,
    init: O
) -> Result<JArray> where
    C: Into<jclass>,
    O: Into<jobject>, 

pub fn get_object_array_element<A>(&self, array: A, index: jsize) -> JObject where
    A: Into<jobjectArray>, 

pub fn set_object_array_element<A, O>(&self, array: A, index: jsize, val: O) where
    A: Into<jobjectArray>,
    O: Into<jobject>, 

pub unsafe fn get_boolean_array_elements<A>(
    &self,
    array: A,
    is_copy: &mut bool
) -> &mut [jboolean] where
    A: Into<jbooleanArray>, 

pub unsafe fn release_boolean_array_elements<A>(
    &self,
    array: A,
    elems: &mut [jboolean],
    mode: jint
) where
    A: Into<jbooleanArray>, 

pub unsafe fn get_byte_array_elements<A>(
    &self,
    array: A,
    is_copy: &mut bool
) -> &mut [jbyte] where
    A: Into<jbyteArray>, 

pub unsafe fn release_byte_array_elements<A>(
    &self,
    array: A,
    elems: &mut [jbyte],
    mode: jint
) where
    A: Into<jbyteArray>, 

pub unsafe fn get_char_array_elements<A>(
    &self,
    array: A,
    is_copy: &mut bool
) -> &mut [jchar] where
    A: Into<jcharArray>, 

pub unsafe fn release_char_array_elements<A>(
    &self,
    array: A,
    elems: &mut [jchar],
    mode: jint
) where
    A: Into<jcharArray>, 

pub unsafe fn get_short_array_elements<A>(
    &self,
    array: A,
    is_copy: &mut bool
) -> &mut [jshort] where
    A: Into<jshortArray>, 

pub unsafe fn release_short_array_elements<A>(
    &self,
    array: A,
    elems: &mut [jshort],
    mode: jint
) where
    A: Into<jshortArray>, 

pub unsafe fn get_int_array_elements<A>(
    &self,
    array: A,
    is_copy: &mut bool
) -> &mut [jint] where
    A: Into<jintArray>, 

pub unsafe fn release_int_array_elements<A>(
    &self,
    array: A,
    elems: &mut [jint],
    mode: jint
) where
    A: Into<jintArray>, 

pub unsafe fn get_long_array_elements<A>(
    &self,
    array: A,
    is_copy: &mut bool
) -> &mut [jlong] where
    A: Into<jlongArray>, 

pub unsafe fn release_long_array_elements<A>(
    &self,
    array: A,
    elems: &mut [jlong],
    mode: jint
) where
    A: Into<jlongArray>, 

pub unsafe fn get_float_array_elements<A>(
    &self,
    array: A,
    is_copy: &mut bool
) -> &mut [jfloat] where
    A: Into<jfloatArray>, 

pub unsafe fn release_float_array_elements<A>(
    &self,
    array: A,
    elems: &mut [jfloat],
    mode: jint
) where
    A: Into<jfloatArray>, 

pub unsafe fn get_double_array_elements<A>(
    &self,
    array: A,
    is_copy: &mut bool
) -> &mut [jdouble] where
    A: Into<jdoubleArray>, 

pub unsafe fn release_double_array_elements<A>(
    &self,
    array: A,
    elems: &mut [jdouble],
    mode: jint
) where
    A: Into<jdoubleArray>, 

pub fn get_boolean_array_region<A>(
    &self,
    array: A,
    start: jsize,
    len: jsize,
    buf: &mut [jboolean]
) where
    A: Into<jbooleanArray>, 

pub fn set_boolean_array_region<A>(
    &self,
    array: A,
    start: jsize,
    len: jsize,
    buf: &[jboolean]
) where
    A: Into<jbooleanArray>, 

pub fn get_byte_array_region<A>(
    &self,
    array: A,
    start: jsize,
    len: jsize,
    buf: &mut [jbyte]
) where
    A: Into<jbyteArray>, 

pub fn set_byte_array_region<A>(
    &self,
    array: A,
    start: jsize,
    len: jsize,
    buf: &[jbyte]
) where
    A: Into<jbyteArray>, 

pub fn get_char_array_region<A>(
    &self,
    array: A,
    start: jsize,
    len: jsize,
    buf: &mut [jchar]
) where
    A: Into<jcharArray>, 

pub fn set_char_array_region<A>(
    &self,
    array: A,
    start: jsize,
    len: jsize,
    buf: &[jchar]
) where
    A: Into<jcharArray>, 

pub fn get_short_array_region<A>(
    &self,
    array: A,
    start: jsize,
    len: jsize,
    buf: &mut [jshort]
) where
    A: Into<jshortArray>, 

pub fn set_short_array_region<A>(
    &self,
    array: A,
    start: jsize,
    len: jsize,
    buf: &[jshort]
) where
    A: Into<jshortArray>, 

pub fn get_int_array_region<A>(
    &self,
    array: A,
    start: jsize,
    len: jsize,
    buf: &mut [jint]
) where
    A: Into<jintArray>, 

pub fn set_int_array_region<A>(
    &self,
    array: A,
    start: jsize,
    len: jsize,
    buf: &[jint]
) where
    A: Into<jintArray>, 

pub fn get_long_array_region<A>(
    &self,
    array: A,
    start: jsize,
    len: jsize,
    buf: &mut [jlong]
) where
    A: Into<jlongArray>, 

pub fn set_long_array_region<A>(
    &self,
    array: A,
    start: jsize,
    len: jsize,
    buf: &[jlong]
) where
    A: Into<jlongArray>, 

pub fn get_float_array_region<A>(
    &self,
    array: A,
    start: jsize,
    len: jsize,
    buf: &mut [jfloat]
) where
    A: Into<jfloatArray>, 

pub fn set_float_array_region<A>(
    &self,
    array: A,
    start: jsize,
    len: jsize,
    buf: &[jfloat]
) where
    A: Into<jfloatArray>, 

pub fn get_double_array_region<A>(
    &self,
    array: A,
    start: jsize,
    len: jsize,
    buf: &mut [jdouble]
) where
    A: Into<jdoubleArray>, 

pub fn set_double_array_region<A>(
    &self,
    array: A,
    start: jsize,
    len: jsize,
    buf: &[jdouble]
) where
    A: Into<jdoubleArray>, 

pub unsafe fn register_natives<C>(&self, cls: C, methods: &[JNINativeMethod]) where
    C: Into<jclass>, 

pub unsafe fn unregister_natives<C>(&self, cls: C) where
    C: Into<jclass>, 

pub unsafe fn monitor_enter<O>(&self, obj: O) where
    O: Into<jobject>, 

pub unsafe fn monitor_exit<O>(&self, obj: O) where
    O: Into<jobject>, 

pub unsafe fn get_primitive_array_critical<A>(
    &self,
    array: A,
    is_copy: &mut bool
) -> *mut void where
    A: Into<jarray>, 

pub unsafe fn release_primitive_array_critical<A>(
    &self,
    array: A,
    carray: *mut void,
    mode: jint
) where
    A: Into<jarray>, 

pub fn new_direct_byte_buffer(
    &self,
    address: *mut void,
    capacity: jlong
) -> JObject

pub fn get_direct_buffer_address<O>(&self, buf: O) -> *mut void where
    O: Into<jobject>, 

pub fn get_direct_buffer_capacity<O>(&self, buf: O) -> jlong where
    O: Into<jobject>, 

pub fn get_object_ref_type<O>(&self, buf: O) -> jobjectRefType where
    O: Into<jobject>, 

Trait Implementations

impl PartialEq<JEnv> for JEnv

fn eq(&self, other: &JEnv) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &JEnv) -> bool

This method tests for !=.

impl Eq for JEnv

impl From<*mut *const JNINativeInterface_> for JEnv

fn from(env: *mut JNIEnv) -> JEnv

Performs the conversion.

impl Sync for JEnv

impl Send for JEnv

impl Copy for JEnv

impl Clone for JEnv

fn clone(&self) -> JEnv

Returns a copy of the value.

default fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Into<*mut *const JNINativeInterface_> for JEnv

fn into(self) -> *mut JNIEnv

Performs the conversion.

impl<'a> Into<*mut *const JNINativeInterface_> for &'a JEnv

fn into(self) -> *mut JNIEnv

Performs the conversion.