env.go

// Code generated by jnigen. DO NOT EDIT.

package jni

import (
	"unsafe"

	"github.com/AndroidGoLab/jni/capi"
	"github.com/AndroidGoLab/jni/internal/jnierr"
)

// Env wraps a JNIEnv pointer. It is only valid on the OS thread where it
// was obtained. Use VM.Do() to get a valid Env.
type Env struct {
	ptr *capi.Env
}

// Ptr returns the raw JNIEnv pointer for interop with other CGo code.
func (e *Env) Ptr() unsafe.Pointer {
	return unsafe.Pointer(e.ptr)
}

// EnvFromPtr creates an Env from a raw JNIEnv pointer.
func EnvFromPtr(ptr unsafe.Pointer) *Env {
	return &Env{ptr: (*capi.Env)(ptr)}
}

// AllocObject wraps the JNI AllocObject function.
func (e *Env) AllocObject(cls *Class) (*Object, error) {
	_ret := capi.AllocObject(e.ptr, capi.Class(cls.Ref()))
	if err := jnierr.CheckException(e.ptr); err != nil {
		return nil, err
	}
	if _ret == 0 {
		return nil, nil
	}
	return &Object{ref: _ret}, nil
}

// CallBooleanMethod wraps the JNI CallBooleanMethodA function.
func (e *Env) CallBooleanMethod(
	obj *Object,
	method MethodID,
	args ...Value,
) (uint8, error) {
	// _dummyJvalue ensures a non-nil jvalue pointer for zero-argument calls.
	// The JNI spec does not guarantee NULL is valid for the const jvalue*
	// parameter of Call<Type>MethodA; OpenJ9 rejects it as an error
	// (eclipse-openj9/openj9#10480). The dummy is never read by the JVM
	// when the method takes no arguments.
	var _dummyJvalue capi.Jvalue
	cArgs := &_dummyJvalue
	if len(args) > 0 {
		cArgs = &args[0].val
	}
	_ret := capi.CallBooleanMethodA(e.ptr, obj.Ref(), method, cArgs)
	if err := jnierr.CheckException(e.ptr); err != nil {
		return 0, err
	}
	return uint8(_ret), nil
}

// CallByteMethod wraps the JNI CallByteMethodA function.
func (e *Env) CallByteMethod(
	obj *Object,
	method MethodID,
	args ...Value,
) (int8, error) {
	// _dummyJvalue ensures a non-nil jvalue pointer for zero-argument calls.
	// The JNI spec does not guarantee NULL is valid for the const jvalue*
	// parameter of Call<Type>MethodA; OpenJ9 rejects it as an error
	// (eclipse-openj9/openj9#10480). The dummy is never read by the JVM
	// when the method takes no arguments.
	var _dummyJvalue capi.Jvalue
	cArgs := &_dummyJvalue
	if len(args) > 0 {
		cArgs = &args[0].val
	}
	_ret := capi.CallByteMethodA(e.ptr, obj.Ref(), method, cArgs)
	if err := jnierr.CheckException(e.ptr); err != nil {
		return 0, err
	}
	return int8(_ret), nil
}

// CallCharMethod wraps the JNI CallCharMethodA function.
func (e *Env) CallCharMethod(
	obj *Object,
	method MethodID,
	args ...Value,
) (uint16, error) {
	// _dummyJvalue ensures a non-nil jvalue pointer for zero-argument calls.
	// The JNI spec does not guarantee NULL is valid for the const jvalue*
	// parameter of Call<Type>MethodA; OpenJ9 rejects it as an error
	// (eclipse-openj9/openj9#10480). The dummy is never read by the JVM
	// when the method takes no arguments.
	var _dummyJvalue capi.Jvalue
	cArgs := &_dummyJvalue
	if len(args) > 0 {
		cArgs = &args[0].val
	}
	_ret := capi.CallCharMethodA(e.ptr, obj.Ref(), method, cArgs)
	if err := jnierr.CheckException(e.ptr); err != nil {
		return 0, err
	}
	return uint16(_ret), nil
}

// CallDoubleMethod wraps the JNI CallDoubleMethodA function.
func (e *Env) CallDoubleMethod(
	obj *Object,
	method MethodID,
	args ...Value,
) (float64, error) {
	// _dummyJvalue ensures a non-nil jvalue pointer for zero-argument calls.
	// The JNI spec does not guarantee NULL is valid for the const jvalue*
	// parameter of Call<Type>MethodA; OpenJ9 rejects it as an error
	// (eclipse-openj9/openj9#10480). The dummy is never read by the JVM
	// when the method takes no arguments.
	var _dummyJvalue capi.Jvalue
	cArgs := &_dummyJvalue
	if len(args) > 0 {
		cArgs = &args[0].val
	}
	_ret := capi.CallDoubleMethodA(e.ptr, obj.Ref(), method, cArgs)
	if err := jnierr.CheckException(e.ptr); err != nil {
		return 0, err
	}
	return float64(_ret), nil
}

// CallFloatMethod wraps the JNI CallFloatMethodA function.
func (e *Env) CallFloatMethod(
	obj *Object,
	method MethodID,
	args ...Value,
) (float32, error) {
	// _dummyJvalue ensures a non-nil jvalue pointer for zero-argument calls.
	// The JNI spec does not guarantee NULL is valid for the const jvalue*
	// parameter of Call<Type>MethodA; OpenJ9 rejects it as an error
	// (eclipse-openj9/openj9#10480). The dummy is never read by the JVM
	// when the method takes no arguments.
	var _dummyJvalue capi.Jvalue
	cArgs := &_dummyJvalue
	if len(args) > 0 {
		cArgs = &args[0].val
	}
	_ret := capi.CallFloatMethodA(e.ptr, obj.Ref(), method, cArgs)
	if err := jnierr.CheckException(e.ptr); err != nil {
		return 0, err
	}
	return float32(_ret), nil
}

// CallIntMethod wraps the JNI CallIntMethodA function.
func (e *Env) CallIntMethod(
	obj *Object,
	method MethodID,
	args ...Value,
) (int32, error) {
	// _dummyJvalue ensures a non-nil jvalue pointer for zero-argument calls.
	// The JNI spec does not guarantee NULL is valid for the const jvalue*
	// parameter of Call<Type>MethodA; OpenJ9 rejects it as an error
	// (eclipse-openj9/openj9#10480). The dummy is never read by the JVM
	// when the method takes no arguments.
	var _dummyJvalue capi.Jvalue
	cArgs := &_dummyJvalue
	if len(args) > 0 {
		cArgs = &args[0].val
	}
	_ret := capi.CallIntMethodA(e.ptr, obj.Ref(), method, cArgs)
	if err := jnierr.CheckException(e.ptr); err != nil {
		return 0, err
	}
	return int32(_ret), nil
}

// CallLongMethod wraps the JNI CallLongMethodA function.
func (e *Env) CallLongMethod(
	obj *Object,
	method MethodID,
	args ...Value,
) (int64, error) {
	// _dummyJvalue ensures a non-nil jvalue pointer for zero-argument calls.
	// The JNI spec does not guarantee NULL is valid for the const jvalue*
	// parameter of Call<Type>MethodA; OpenJ9 rejects it as an error
	// (eclipse-openj9/openj9#10480). The dummy is never read by the JVM
	// when the method takes no arguments.
	var _dummyJvalue capi.Jvalue
	cArgs := &_dummyJvalue
	if len(args) > 0 {
		cArgs = &args[0].val
	}
	_ret := capi.CallLongMethodA(e.ptr, obj.Ref(), method, cArgs)
	if err := jnierr.CheckException(e.ptr); err != nil {
		return 0, err
	}
	return int64(_ret), nil
}

// CallNonvirtualBooleanMethod wraps the JNI CallNonvirtualBooleanMethodA function.
func (e *Env) CallNonvirtualBooleanMethod(
	obj *Object,
	cls *Class,
	method MethodID,
	args ...Value,
) (uint8, error) {
	// _dummyJvalue ensures a non-nil jvalue pointer for zero-argument calls.
	// The JNI spec does not guarantee NULL is valid for the const jvalue*
	// parameter of Call<Type>MethodA; OpenJ9 rejects it as an error
	// (eclipse-openj9/openj9#10480). The dummy is never read by the JVM
	// when the method takes no arguments.
	var _dummyJvalue capi.Jvalue
	cArgs := &_dummyJvalue
	if len(args) > 0 {
		cArgs = &args[0].val
	}
	_ret := capi.CallNonvirtualBooleanMethodA(e.ptr, obj.Ref(), capi.Class(cls.Ref()), method, cArgs)
	if err := jnierr.CheckException(e.ptr); err != nil {
		return 0, err
	}
	return uint8(_ret), nil
}

// CallNonvirtualByteMethod wraps the JNI CallNonvirtualByteMethodA function.
func (e *Env) CallNonvirtualByteMethod(
	obj *Object,
	cls *Class,
	method MethodID,
	args ...Value,
) (int8, error) {
	// _dummyJvalue ensures a non-nil jvalue pointer for zero-argument calls.
	// The JNI spec does not guarantee NULL is valid for the const jvalue*
	// parameter of Call<Type>MethodA; OpenJ9 rejects it as an error
	// (eclipse-openj9/openj9#10480). The dummy is never read by the JVM
	// when the method takes no arguments.
	var _dummyJvalue capi.Jvalue
	cArgs := &_dummyJvalue
	if len(args) > 0 {
		cArgs = &args[0].val
	}
	_ret := capi.CallNonvirtualByteMethodA(e.ptr, obj.Ref(), capi.Class(cls.Ref()), method, cArgs)
	if err := jnierr.CheckException(e.ptr); err != nil {
		return 0, err
	}
	return int8(_ret), nil
}

// CallNonvirtualCharMethod wraps the JNI CallNonvirtualCharMethodA function.
func (e *Env) CallNonvirtualCharMethod(
	obj *Object,
	cls *Class,
	method MethodID,
	args ...Value,
) (uint16, error) {
	// _dummyJvalue ensures a non-nil jvalue pointer for zero-argument calls.
	// The JNI spec does not guarantee NULL is valid for the const jvalue*
	// parameter of Call<Type>MethodA; OpenJ9 rejects it as an error
	// (eclipse-openj9/openj9#10480). The dummy is never read by the JVM
	// when the method takes no arguments.
	var _dummyJvalue capi.Jvalue
	cArgs := &_dummyJvalue
	if len(args) > 0 {
		cArgs = &args[0].val
	}
	_ret := capi.CallNonvirtualCharMethodA(e.ptr, obj.Ref(), capi.Class(cls.Ref()), method, cArgs)
	if err := jnierr.CheckException(e.ptr); err != nil {
		return 0, err
	}
	return uint16(_ret), nil
}

// CallNonvirtualDoubleMethod wraps the JNI CallNonvirtualDoubleMethodA function.
func (e *Env) CallNonvirtualDoubleMethod(
	obj *Object,
	cls *Class,
	method MethodID,
	args ...Value,
) (float64, error) {
	// _dummyJvalue ensures a non-nil jvalue pointer for zero-argument calls.
	// The JNI spec does not guarantee NULL is valid for the const jvalue*
	// parameter of Call<Type>MethodA; OpenJ9 rejects it as an error
	// (eclipse-openj9/openj9#10480). The dummy is never read by the JVM
	// when the method takes no arguments.
	var _dummyJvalue capi.Jvalue
	cArgs := &_dummyJvalue
	if len(args) > 0 {
		cArgs = &args[0].val
	}
	_ret := capi.CallNonvirtualDoubleMethodA(e.ptr, obj.Ref(), capi.Class(cls.Ref()), method, cArgs)
	if err := jnierr.CheckException(e.ptr); err != nil {
		return 0, err
	}
	return float64(_ret), nil
}

// CallNonvirtualFloatMethod wraps the JNI CallNonvirtualFloatMethodA function.
func (e *Env) CallNonvirtualFloatMethod(
	obj *Object,
	cls *Class,
	method MethodID,
	args ...Value,
) (float32, error) {
	// _dummyJvalue ensures a non-nil jvalue pointer for zero-argument calls.
	// The JNI spec does not guarantee NULL is valid for the const jvalue*
	// parameter of Call<Type>MethodA; OpenJ9 rejects it as an error
	// (eclipse-openj9/openj9#10480). The dummy is never read by the JVM
	// when the method takes no arguments.
	var _dummyJvalue capi.Jvalue
	cArgs := &_dummyJvalue
	if len(args) > 0 {
		cArgs = &args[0].val
	}
	_ret := capi.CallNonvirtualFloatMethodA(e.ptr, obj.Ref(), capi.Class(cls.Ref()), method, cArgs)
	if err := jnierr.CheckException(e.ptr); err != nil {
		return 0, err
	}
	return float32(_ret), nil
}

// CallNonvirtualIntMethod wraps the JNI CallNonvirtualIntMethodA function.
func (e *Env) CallNonvirtualIntMethod(
	obj *Object,
	cls *Class,
	method MethodID,
	args ...Value,
) (int32, error) {
	// _dummyJvalue ensures a non-nil jvalue pointer for zero-argument calls.
	// The JNI spec does not guarantee NULL is valid for the const jvalue*
	// parameter of Call<Type>MethodA; OpenJ9 rejects it as an error
	// (eclipse-openj9/openj9#10480). The dummy is never read by the JVM
	// when the method takes no arguments.
	var _dummyJvalue capi.Jvalue
	cArgs := &_dummyJvalue
	if len(args) > 0 {
		cArgs = &args[0].val
	}
	_ret := capi.CallNonvirtualIntMethodA(e.ptr, obj.Ref(), capi.Class(cls.Ref()), method, cArgs)
	if err := jnierr.CheckException(e.ptr); err != nil {
		return 0, err
	}
	return int32(_ret), nil
}

// CallNonvirtualLongMethod wraps the JNI CallNonvirtualLongMethodA function.
func (e *Env) CallNonvirtualLongMethod(
	obj *Object,
	cls *Class,
	method MethodID,
	args ...Value,
) (int64, error) {
	// _dummyJvalue ensures a non-nil jvalue pointer for zero-argument calls.
	// The JNI spec does not guarantee NULL is valid for the const jvalue*
	// parameter of Call<Type>MethodA; OpenJ9 rejects it as an error
	// (eclipse-openj9/openj9#10480). The dummy is never read by the JVM
	// when the method takes no arguments.
	var _dummyJvalue capi.Jvalue
	cArgs := &_dummyJvalue
	if len(args) > 0 {
		cArgs = &args[0].val
	}
	_ret := capi.CallNonvirtualLongMethodA(e.ptr, obj.Ref(), capi.Class(cls.Ref()), method, cArgs)
	if err := jnierr.CheckException(e.ptr); err != nil {
		return 0, err
	}
	return int64(_ret), nil
}

// CallNonvirtualObjectMethod wraps the JNI CallNonvirtualObjectMethodA function.
func (e *Env) CallNonvirtualObjectMethod(
	obj *Object,
	cls *Class,
	method MethodID,
	args ...Value,
) (*Object, error) {
	// _dummyJvalue ensures a non-nil jvalue pointer for zero-argument calls.
	// The JNI spec does not guarantee NULL is valid for the const jvalue*
	// parameter of Call<Type>MethodA; OpenJ9 rejects it as an error
	// (eclipse-openj9/openj9#10480). The dummy is never read by the JVM
	// when the method takes no arguments.
	var _dummyJvalue capi.Jvalue
	cArgs := &_dummyJvalue
	if len(args) > 0 {
		cArgs = &args[0].val
	}
	_ret := capi.CallNonvirtualObjectMethodA(e.ptr, obj.Ref(), capi.Class(cls.Ref()), method, cArgs)
	if err := jnierr.CheckException(e.ptr); err != nil {
		return nil, err
	}
	if _ret == 0 {
		return nil, nil
	}
	return &Object{ref: _ret}, nil
}

// CallNonvirtualShortMethod wraps the JNI CallNonvirtualShortMethodA function.
func (e *Env) CallNonvirtualShortMethod(
	obj *Object,
	cls *Class,
	method MethodID,
	args ...Value,
) (int16, error) {
	// _dummyJvalue ensures a non-nil jvalue pointer for zero-argument calls.
	// The JNI spec does not guarantee NULL is valid for the const jvalue*
	// parameter of Call<Type>MethodA; OpenJ9 rejects it as an error
	// (eclipse-openj9/openj9#10480). The dummy is never read by the JVM
	// when the method takes no arguments.
	var _dummyJvalue capi.Jvalue
	cArgs := &_dummyJvalue
	if len(args) > 0 {
		cArgs = &args[0].val
	}
	_ret := capi.CallNonvirtualShortMethodA(e.ptr, obj.Ref(), capi.Class(cls.Ref()), method, cArgs)
	if err := jnierr.CheckException(e.ptr); err != nil {
		return 0, err
	}
	return int16(_ret), nil
}

// CallNonvirtualVoidMethod wraps the JNI CallNonvirtualVoidMethodA function.
func (e *Env) CallNonvirtualVoidMethod(
	obj *Object,
	cls *Class,
	method MethodID,
	args ...Value,
) error {
	// _dummyJvalue ensures a non-nil jvalue pointer for zero-argument calls.
	// The JNI spec does not guarantee NULL is valid for the const jvalue*
	// parameter of Call<Type>MethodA; OpenJ9 rejects it as an error
	// (eclipse-openj9/openj9#10480). The dummy is never read by the JVM
	// when the method takes no arguments.
	var _dummyJvalue capi.Jvalue
	cArgs := &_dummyJvalue
	if len(args) > 0 {
		cArgs = &args[0].val
	}
	capi.CallNonvirtualVoidMethodA(e.ptr, obj.Ref(), capi.Class(cls.Ref()), method, cArgs)
	if err := jnierr.CheckException(e.ptr); err != nil {
		return err
	}
	return nil
}

// CallObjectMethod wraps the JNI CallObjectMethodA function.
func (e *Env) CallObjectMethod(
	obj *Object,
	method MethodID,
	args ...Value,
) (*Object, error) {
	// _dummyJvalue ensures a non-nil jvalue pointer for zero-argument calls.
	// The JNI spec does not guarantee NULL is valid for the const jvalue*
	// parameter of Call<Type>MethodA; OpenJ9 rejects it as an error
	// (eclipse-openj9/openj9#10480). The dummy is never read by the JVM
	// when the method takes no arguments.
	var _dummyJvalue capi.Jvalue
	cArgs := &_dummyJvalue
	if len(args) > 0 {
		cArgs = &args[0].val
	}
	_ret := capi.CallObjectMethodA(e.ptr, obj.Ref(), method, cArgs)
	if err := jnierr.CheckException(e.ptr); err != nil {
		return nil, err
	}
	if _ret == 0 {
		return nil, nil
	}
	return &Object{ref: _ret}, nil
}

// CallShortMethod wraps the JNI CallShortMethodA function.
func (e *Env) CallShortMethod(
	obj *Object,
	method MethodID,
	args ...Value,
) (int16, error) {
	// _dummyJvalue ensures a non-nil jvalue pointer for zero-argument calls.
	// The JNI spec does not guarantee NULL is valid for the const jvalue*
	// parameter of Call<Type>MethodA; OpenJ9 rejects it as an error
	// (eclipse-openj9/openj9#10480). The dummy is never read by the JVM
	// when the method takes no arguments.
	var _dummyJvalue capi.Jvalue
	cArgs := &_dummyJvalue
	if len(args) > 0 {
		cArgs = &args[0].val
	}
	_ret := capi.CallShortMethodA(e.ptr, obj.Ref(), method, cArgs)
	if err := jnierr.CheckException(e.ptr); err != nil {
		return 0, err
	}
	return int16(_ret), nil
}

// CallStaticBooleanMethod wraps the JNI CallStaticBooleanMethodA function.
func (e *Env) CallStaticBooleanMethod(
	cls *Class,
	method MethodID,
	args ...Value,
) (uint8, error) {
	// _dummyJvalue ensures a non-nil jvalue pointer for zero-argument calls.
	// The JNI spec does not guarantee NULL is valid for the const jvalue*
	// parameter of Call<Type>MethodA; OpenJ9 rejects it as an error
	// (eclipse-openj9/openj9#10480). The dummy is never read by the JVM
	// when the method takes no arguments.
	var _dummyJvalue capi.Jvalue
	cArgs := &_dummyJvalue
	if len(args) > 0 {
		cArgs = &args[0].val
	}
	_ret := capi.CallStaticBooleanMethodA(e.ptr, capi.Class(cls.Ref()), method, cArgs)
	if err := jnierr.CheckException(e.ptr); err != nil {
		return 0, err
	}
	return uint8(_ret), nil
}

// CallStaticByteMethod wraps the JNI CallStaticByteMethodA function.
func (e *Env) CallStaticByteMethod(
	cls *Class,
	method MethodID,
	args ...Value,
) (int8, error) {
	// _dummyJvalue ensures a non-nil jvalue pointer for zero-argument calls.
	// The JNI spec does not guarantee NULL is valid for the const jvalue*
	// parameter of Call<Type>MethodA; OpenJ9 rejects it as an error
	// (eclipse-openj9/openj9#10480). The dummy is never read by the JVM
	// when the method takes no arguments.
	var _dummyJvalue capi.Jvalue
	cArgs := &_dummyJvalue
	if len(args) > 0 {
		cArgs = &args[0].val
	}
	_ret := capi.CallStaticByteMethodA(e.ptr, capi.Class(cls.Ref()), method, cArgs)
	if err := jnierr.CheckException(e.ptr); err != nil {
		return 0, err
	}
	return int8(_ret), nil
}

// CallStaticCharMethod wraps the JNI CallStaticCharMethodA function.
func (e *Env) CallStaticCharMethod(
	cls *Class,
	method MethodID,
	args ...Value,
) (uint16, error) {
	// _dummyJvalue ensures a non-nil jvalue pointer for zero-argument calls.
	// The JNI spec does not guarantee NULL is valid for the const jvalue*
	// parameter of Call<Type>MethodA; OpenJ9 rejects it as an error
	// (eclipse-openj9/openj9#10480). The dummy is never read by the JVM
	// when the method takes no arguments.
	var _dummyJvalue capi.Jvalue
	cArgs := &_dummyJvalue
	if len(args) > 0 {
		cArgs = &args[0].val
	}
	_ret := capi.CallStaticCharMethodA(e.ptr, capi.Class(cls.Ref()), method, cArgs)
	if err := jnierr.CheckException(e.ptr); err != nil {
		return 0, err
	}
	return uint16(_ret), nil
}

// CallStaticDoubleMethod wraps the JNI CallStaticDoubleMethodA function.
func (e *Env) CallStaticDoubleMethod(
	cls *Class,
	method MethodID,
	args ...Value,
) (float64, error) {
	// _dummyJvalue ensures a non-nil jvalue pointer for zero-argument calls.
	// The JNI spec does not guarantee NULL is valid for the const jvalue*
	// parameter of Call<Type>MethodA; OpenJ9 rejects it as an error
	// (eclipse-openj9/openj9#10480). The dummy is never read by the JVM
	// when the method takes no arguments.
	var _dummyJvalue capi.Jvalue
	cArgs := &_dummyJvalue
	if len(args) > 0 {
		cArgs = &args[0].val
	}
	_ret := capi.CallStaticDoubleMethodA(e.ptr, capi.Class(cls.Ref()), method, cArgs)
	if err := jnierr.CheckException(e.ptr); err != nil {
		return 0, err
	}
	return float64(_ret), nil
}

// CallStaticFloatMethod wraps the JNI CallStaticFloatMethodA function.
func (e *Env) CallStaticFloatMethod(
	cls *Class,
	method MethodID,
	args ...Value,
) (float32, error) {
	// _dummyJvalue ensures a non-nil jvalue pointer for zero-argument calls.
	// The JNI spec does not guarantee NULL is valid for the const jvalue*
	// parameter of Call<Type>MethodA; OpenJ9 rejects it as an error
	// (eclipse-openj9/openj9#10480). The dummy is never read by the JVM
	// when the method takes no arguments.
	var _dummyJvalue capi.Jvalue
	cArgs := &_dummyJvalue
	if len(args) > 0 {
		cArgs = &args[0].val
	}
	_ret := capi.CallStaticFloatMethodA(e.ptr, capi.Class(cls.Ref()), method, cArgs)
	if err := jnierr.CheckException(e.ptr); err != nil {
		return 0, err
	}
	return float32(_ret), nil
}

// CallStaticIntMethod wraps the JNI CallStaticIntMethodA function.
func (e *Env) CallStaticIntMethod(
	cls *Class,
	method MethodID,
	args ...Value,
) (int32, error) {
	// _dummyJvalue ensures a non-nil jvalue pointer for zero-argument calls.
	// The JNI spec does not guarantee NULL is valid for the const jvalue*
	// parameter of Call<Type>MethodA; OpenJ9 rejects it as an error
	// (eclipse-openj9/openj9#10480). The dummy is never read by the JVM
	// when the method takes no arguments.
	var _dummyJvalue capi.Jvalue
	cArgs := &_dummyJvalue
	if len(args) > 0 {
		cArgs = &args[0].val
	}
	_ret := capi.CallStaticIntMethodA(e.ptr, capi.Class(cls.Ref()), method, cArgs)
	if err := jnierr.CheckException(e.ptr); err != nil {
		return 0, err
	}
	return int32(_ret), nil
}

// CallStaticLongMethod wraps the JNI CallStaticLongMethodA function.
func (e *Env) CallStaticLongMethod(
	cls *Class,
	method MethodID,
	args ...Value,
) (int64, error) {
	// _dummyJvalue ensures a non-nil jvalue pointer for zero-argument calls.
	// The JNI spec does not guarantee NULL is valid for the const jvalue*
	// parameter of Call<Type>MethodA; OpenJ9 rejects it as an error
	// (eclipse-openj9/openj9#10480). The dummy is never read by the JVM
	// when the method takes no arguments.
	var _dummyJvalue capi.Jvalue
	cArgs := &_dummyJvalue
	if len(args) > 0 {
		cArgs = &args[0].val
	}
	_ret := capi.CallStaticLongMethodA(e.ptr, capi.Class(cls.Ref()), method, cArgs)
	if err := jnierr.CheckException(e.ptr); err != nil {
		return 0, err
	}
	return int64(_ret), nil
}

// CallStaticObjectMethod wraps the JNI CallStaticObjectMethodA function.
func (e *Env) CallStaticObjectMethod(
	cls *Class,
	method MethodID,
	args ...Value,
) (*Object, error) {
	// _dummyJvalue ensures a non-nil jvalue pointer for zero-argument calls.
	// The JNI spec does not guarantee NULL is valid for the const jvalue*
	// parameter of Call<Type>MethodA; OpenJ9 rejects it as an error
	// (eclipse-openj9/openj9#10480). The dummy is never read by the JVM
	// when the method takes no arguments.
	var _dummyJvalue capi.Jvalue
	cArgs := &_dummyJvalue
	if len(args) > 0 {
		cArgs = &args[0].val
	}
	_ret := capi.CallStaticObjectMethodA(e.ptr, capi.Class(cls.Ref()), method, cArgs)
	if err := jnierr.CheckException(e.ptr); err != nil {
		return nil, err
	}
	if _ret == 0 {
		return nil, nil
	}
	return &Object{ref: _ret}, nil
}

// CallStaticShortMethod wraps the JNI CallStaticShortMethodA function.
func (e *Env) CallStaticShortMethod(
	cls *Class,
	method MethodID,
	args ...Value,
) (int16, error) {
	// _dummyJvalue ensures a non-nil jvalue pointer for zero-argument calls.
	// The JNI spec does not guarantee NULL is valid for the const jvalue*
	// parameter of Call<Type>MethodA; OpenJ9 rejects it as an error
	// (eclipse-openj9/openj9#10480). The dummy is never read by the JVM
	// when the method takes no arguments.
	var _dummyJvalue capi.Jvalue
	cArgs := &_dummyJvalue
	if len(args) > 0 {
		cArgs = &args[0].val
	}
	_ret := capi.CallStaticShortMethodA(e.ptr, capi.Class(cls.Ref()), method, cArgs)
	if err := jnierr.CheckException(e.ptr); err != nil {
		return 0, err
	}
	return int16(_ret), nil
}

// CallStaticVoidMethod wraps the JNI CallStaticVoidMethodA function.
func (e *Env) CallStaticVoidMethod(
	cls *Class,
	method MethodID,
	args ...Value,
) error {
	// _dummyJvalue ensures a non-nil jvalue pointer for zero-argument calls.
	// The JNI spec does not guarantee NULL is valid for the const jvalue*
	// parameter of Call<Type>MethodA; OpenJ9 rejects it as an error
	// (eclipse-openj9/openj9#10480). The dummy is never read by the JVM
	// when the method takes no arguments.
	var _dummyJvalue capi.Jvalue
	cArgs := &_dummyJvalue
	if len(args) > 0 {
		cArgs = &args[0].val
	}
	capi.CallStaticVoidMethodA(e.ptr, capi.Class(cls.Ref()), method, cArgs)
	if err := jnierr.CheckException(e.ptr); err != nil {
		return err
	}
	return nil
}

// CallVoidMethod wraps the JNI CallVoidMethodA function.
func (e *Env) CallVoidMethod(
	obj *Object,
	method MethodID,
	args ...Value,
) error {
	// _dummyJvalue ensures a non-nil jvalue pointer for zero-argument calls.
	// The JNI spec does not guarantee NULL is valid for the const jvalue*
	// parameter of Call<Type>MethodA; OpenJ9 rejects it as an error
	// (eclipse-openj9/openj9#10480). The dummy is never read by the JVM
	// when the method takes no arguments.
	var _dummyJvalue capi.Jvalue
	cArgs := &_dummyJvalue
	if len(args) > 0 {
		cArgs = &args[0].val
	}
	capi.CallVoidMethodA(e.ptr, obj.Ref(), method, cArgs)
	if err := jnierr.CheckException(e.ptr); err != nil {
		return err
	}
	return nil
}

// DefineClass wraps the JNI DefineClass function.
func (e *Env) DefineClass(
	name string,
	loader *Object,
	buf []byte,
) (*Class, error) {
	cName := append([]byte(name), 0)
	_ret := capi.DefineClass(e.ptr, (*capi.Cchar)(unsafe.Pointer(&cName[0])), loader.Ref(), (*capi.Jbyte)(unsafe.Pointer(&buf[0])), capi.Jint(len(buf)))
	if err := jnierr.CheckException(e.ptr); err != nil {
		return nil, err
	}
	if _ret == 0 {
		return nil, nil
	}
	return &Class{Object{ref: capi.Object(_ret)}}, nil
}

// DeleteGlobalRef wraps the JNI DeleteGlobalRef function.
func (e *Env) DeleteGlobalRef(globalRef *Object) {
	capi.DeleteGlobalRef(e.ptr, globalRef.Ref())
}

// DeleteLocalRef wraps the JNI DeleteLocalRef function.
func (e *Env) DeleteLocalRef(localRef *Object) {
	capi.DeleteLocalRef(e.ptr, localRef.Ref())
}

// DeleteWeakGlobalRef wraps the JNI DeleteWeakGlobalRef function.
func (e *Env) DeleteWeakGlobalRef(ref *WeakRef) {
	capi.DeleteWeakGlobalRef(e.ptr, capi.WeakRef(ref.Ref()))
}

// EnsureLocalCapacity wraps the JNI EnsureLocalCapacity function.
func (e *Env) EnsureLocalCapacity(capacity int32) error {
	rc := capi.EnsureLocalCapacity(e.ptr, capi.Jint(capacity))
	if rc != capi.JNI_OK {
		return Error(rc)
	}
	return nil
}

// ExceptionCheck wraps the JNI ExceptionCheck function.
func (e *Env) ExceptionCheck() bool {
	_ret := capi.ExceptionCheck(e.ptr)
	return _ret != 0
}

// ExceptionClear wraps the JNI ExceptionClear function.
func (e *Env) ExceptionClear() {
	capi.ExceptionClear(e.ptr)
}

// ExceptionDescribe wraps the JNI ExceptionDescribe function.
func (e *Env) ExceptionDescribe() {
	capi.ExceptionDescribe(e.ptr)
}

// ExceptionOccurred wraps the JNI ExceptionOccurred function.
func (e *Env) ExceptionOccurred() *Throwable {
	_ret := capi.ExceptionOccurred(e.ptr)
	if _ret == 0 {
		return nil
	}
	return &Throwable{Object{ref: capi.Object(_ret)}}
}

// FatalError wraps the JNI FatalError function.
func (e *Env) FatalError(msg string) {
	cMsg := append([]byte(msg), 0)
	capi.FatalError(e.ptr, (*capi.Cchar)(unsafe.Pointer(&cMsg[0])))
}

// FindClass wraps the JNI FindClass function.
func (e *Env) FindClass(name string) (*Class, error) {
	cName := append([]byte(name), 0)
	_ret := capi.FindClass(e.ptr, (*capi.Cchar)(unsafe.Pointer(&cName[0])))
	if err := jnierr.CheckException(e.ptr); err != nil {
		return nil, err
	}
	if _ret == 0 {
		return nil, nil
	}
	return &Class{Object{ref: capi.Object(_ret)}}, nil
}

// FromReflectedField wraps the JNI FromReflectedField function.
func (e *Env) FromReflectedField(field *Object) FieldID {
	_ret := capi.FromReflectedField(e.ptr, field.Ref())
	return _ret
}

// FromReflectedMethod wraps the JNI FromReflectedMethod function.
func (e *Env) FromReflectedMethod(method *Object) MethodID {
	_ret := capi.FromReflectedMethod(e.ptr, method.Ref())
	return _ret
}

// GetArrayLength wraps the JNI GetArrayLength function.
func (e *Env) GetArrayLength(array *Array) int32 {
	_ret := capi.GetArrayLength(e.ptr, capi.Array(array.Ref()))
	return int32(_ret)
}

// GetBooleanArrayElements wraps the JNI GetBooleanArrayElements function.
func (e *Env) GetBooleanArrayElements(array *BooleanArray, isCopy *uint8) unsafe.Pointer {
	_ret := capi.GetBooleanArrayElements(e.ptr, capi.BooleanArray(array.Ref()), (*capi.Jboolean)(isCopy))
	return unsafe.Pointer(_ret)
}

// GetBooleanArrayRegion wraps the JNI GetBooleanArrayRegion function.
func (e *Env) GetBooleanArrayRegion(
	array *BooleanArray,
	start int32,
	len int32,
	buf unsafe.Pointer,
) {
	capi.GetBooleanArrayRegion(e.ptr, capi.BooleanArray(array.Ref()), capi.Jint(start), capi.Jint(len), (*capi.Jboolean)(buf))
}

// GetBooleanField wraps the JNI GetBooleanField function.
func (e *Env) GetBooleanField(obj *Object, field FieldID) uint8 {
	_ret := capi.GetBooleanField(e.ptr, obj.Ref(), field)
	return uint8(_ret)
}

// GetByteArrayElements wraps the JNI GetByteArrayElements function.
func (e *Env) GetByteArrayElements(array *ByteArray, isCopy *uint8) unsafe.Pointer {
	_ret := capi.GetByteArrayElements(e.ptr, capi.ByteArray(array.Ref()), (*capi.Jboolean)(isCopy))
	return unsafe.Pointer(_ret)
}

// GetByteArrayRegion wraps the JNI GetByteArrayRegion function.
func (e *Env) GetByteArrayRegion(
	array *ByteArray,
	start int32,
	len int32,
	buf unsafe.Pointer,
) {
	capi.GetByteArrayRegion(e.ptr, capi.ByteArray(array.Ref()), capi.Jint(start), capi.Jint(len), (*capi.Jbyte)(buf))
}

// GetByteField wraps the JNI GetByteField function.
func (e *Env) GetByteField(obj *Object, field FieldID) int8 {
	_ret := capi.GetByteField(e.ptr, obj.Ref(), field)
	return int8(_ret)
}

// GetCharArrayElements wraps the JNI GetCharArrayElements function.
func (e *Env) GetCharArrayElements(array *CharArray, isCopy *uint8) unsafe.Pointer {
	_ret := capi.GetCharArrayElements(e.ptr, capi.CharArray(array.Ref()), (*capi.Jboolean)(isCopy))
	return unsafe.Pointer(_ret)
}

// GetCharArrayRegion wraps the JNI GetCharArrayRegion function.
func (e *Env) GetCharArrayRegion(
	array *CharArray,
	start int32,
	len int32,
	buf unsafe.Pointer,
) {
	capi.GetCharArrayRegion(e.ptr, capi.CharArray(array.Ref()), capi.Jint(start), capi.Jint(len), (*capi.Jchar)(buf))
}

// GetCharField wraps the JNI GetCharField function.
func (e *Env) GetCharField(obj *Object, field FieldID) uint16 {
	_ret := capi.GetCharField(e.ptr, obj.Ref(), field)
	return uint16(_ret)
}

// GetDirectBufferAddress wraps the JNI GetDirectBufferAddress function.
func (e *Env) GetDirectBufferAddress(buf *Object) unsafe.Pointer {
	_ret := capi.GetDirectBufferAddress(e.ptr, buf.Ref())
	return unsafe.Pointer(_ret)
}

// GetDirectBufferCapacity wraps the JNI GetDirectBufferCapacity function.
func (e *Env) GetDirectBufferCapacity(buf *Object) int64 {
	_ret := capi.GetDirectBufferCapacity(e.ptr, buf.Ref())
	return int64(_ret)
}

// GetDoubleArrayElements wraps the JNI GetDoubleArrayElements function.
func (e *Env) GetDoubleArrayElements(array *DoubleArray, isCopy *uint8) unsafe.Pointer {
	_ret := capi.GetDoubleArrayElements(e.ptr, capi.DoubleArray(array.Ref()), (*capi.Jboolean)(isCopy))
	return unsafe.Pointer(_ret)
}

// GetDoubleArrayRegion wraps the JNI GetDoubleArrayRegion function.
func (e *Env) GetDoubleArrayRegion(
	array *DoubleArray,
	start int32,
	len int32,
	buf unsafe.Pointer,
) {
	capi.GetDoubleArrayRegion(e.ptr, capi.DoubleArray(array.Ref()), capi.Jint(start), capi.Jint(len), (*capi.Jdouble)(buf))
}

// GetDoubleField wraps the JNI GetDoubleField function.
func (e *Env) GetDoubleField(obj *Object, field FieldID) float64 {
	_ret := capi.GetDoubleField(e.ptr, obj.Ref(), field)
	return float64(_ret)
}

// GetFieldID wraps the JNI GetFieldID function.
func (e *Env) GetFieldID(
	cls *Class,
	name string,
	sig string,
) (FieldID, error) {
	cName := append([]byte(name), 0)
	cSig := append([]byte(sig), 0)
	_ret := capi.GetFieldID(e.ptr, capi.Class(cls.Ref()), (*capi.Cchar)(unsafe.Pointer(&cName[0])), (*capi.Cchar)(unsafe.Pointer(&cSig[0])))
	if err := jnierr.CheckException(e.ptr); err != nil {
		return nil, err
	}
	return _ret, nil
}

// GetFloatArrayElements wraps the JNI GetFloatArrayElements function.
func (e *Env) GetFloatArrayElements(array *FloatArray, isCopy *uint8) unsafe.Pointer {
	_ret := capi.GetFloatArrayElements(e.ptr, capi.FloatArray(array.Ref()), (*capi.Jboolean)(isCopy))
	return unsafe.Pointer(_ret)
}

// GetFloatArrayRegion wraps the JNI GetFloatArrayRegion function.
func (e *Env) GetFloatArrayRegion(
	array *FloatArray,
	start int32,
	len int32,
	buf unsafe.Pointer,
) {
	capi.GetFloatArrayRegion(e.ptr, capi.FloatArray(array.Ref()), capi.Jint(start), capi.Jint(len), (*capi.Jfloat)(buf))
}

// GetFloatField wraps the JNI GetFloatField function.
func (e *Env) GetFloatField(obj *Object, field FieldID) float32 {
	_ret := capi.GetFloatField(e.ptr, obj.Ref(), field)
	return float32(_ret)
}

// GetIntArrayElements wraps the JNI GetIntArrayElements function.
func (e *Env) GetIntArrayElements(array *IntArray, isCopy *uint8) unsafe.Pointer {
	_ret := capi.GetIntArrayElements(e.ptr, capi.IntArray(array.Ref()), (*capi.Jboolean)(isCopy))
	return unsafe.Pointer(_ret)
}

// GetIntArrayRegion wraps the JNI GetIntArrayRegion function.
func (e *Env) GetIntArrayRegion(
	array *IntArray,
	start int32,
	len int32,
	buf unsafe.Pointer,
) {
	capi.GetIntArrayRegion(e.ptr, capi.IntArray(array.Ref()), capi.Jint(start), capi.Jint(len), (*capi.Jint)(buf))
}

// GetIntField wraps the JNI GetIntField function.
func (e *Env) GetIntField(obj *Object, field FieldID) int32 {
	_ret := capi.GetIntField(e.ptr, obj.Ref(), field)
	return int32(_ret)
}

// GetLongArrayElements wraps the JNI GetLongArrayElements function.
func (e *Env) GetLongArrayElements(array *LongArray, isCopy *uint8) unsafe.Pointer {
	_ret := capi.GetLongArrayElements(e.ptr, capi.LongArray(array.Ref()), (*capi.Jboolean)(isCopy))
	return unsafe.Pointer(_ret)
}

// GetLongArrayRegion wraps the JNI GetLongArrayRegion function.
func (e *Env) GetLongArrayRegion(
	array *LongArray,
	start int32,
	len int32,
	buf unsafe.Pointer,
) {
	capi.GetLongArrayRegion(e.ptr, capi.LongArray(array.Ref()), capi.Jint(start), capi.Jint(len), (*capi.Jlong)(buf))
}

// GetLongField wraps the JNI GetLongField function.
func (e *Env) GetLongField(obj *Object, field FieldID) int64 {
	_ret := capi.GetLongField(e.ptr, obj.Ref(), field)
	return int64(_ret)
}

// GetMethodID wraps the JNI GetMethodID function.
func (e *Env) GetMethodID(
	cls *Class,
	name string,
	sig string,
) (MethodID, error) {
	cName := append([]byte(name), 0)
	cSig := append([]byte(sig), 0)
	_ret := capi.GetMethodID(e.ptr, capi.Class(cls.Ref()), (*capi.Cchar)(unsafe.Pointer(&cName[0])), (*capi.Cchar)(unsafe.Pointer(&cSig[0])))
	if err := jnierr.CheckException(e.ptr); err != nil {
		return nil, err
	}
	return _ret, nil
}

// GetObjectArrayElement wraps the JNI GetObjectArrayElement function.
func (e *Env) GetObjectArrayElement(array *ObjectArray, index int32) (*Object, error) {
	_ret := capi.GetObjectArrayElement(e.ptr, capi.ObjectArray(array.Ref()), capi.Jint(index))
	if err := jnierr.CheckException(e.ptr); err != nil {
		return nil, err
	}
	if _ret == 0 {
		return nil, nil
	}
	return &Object{ref: _ret}, nil
}

// GetObjectClass wraps the JNI GetObjectClass function.
func (e *Env) GetObjectClass(obj *Object) *Class {
	_ret := capi.GetObjectClass(e.ptr, obj.Ref())
	if _ret == 0 {
		return nil
	}
	return &Class{Object{ref: capi.Object(_ret)}}
}

// GetObjectField wraps the JNI GetObjectField function.
func (e *Env) GetObjectField(obj *Object, field FieldID) *Object {
	_ret := capi.GetObjectField(e.ptr, obj.Ref(), field)
	if _ret == 0 {
		return nil
	}
	return &Object{ref: _ret}
}

// GetObjectRefType wraps the JNI GetObjectRefType function.
func (e *Env) GetObjectRefType(obj *Object) ObjectRefType {
	_ret := capi.GetObjectRefType(e.ptr, obj.Ref())
	return ObjectRefType(_ret)
}

// GetPrimitiveArrayCritical wraps the JNI GetPrimitiveArrayCritical function.
func (e *Env) GetPrimitiveArrayCritical(array *Array, isCopy *uint8) unsafe.Pointer {
	_ret := capi.GetPrimitiveArrayCritical(e.ptr, capi.Array(array.Ref()), (*capi.Jboolean)(isCopy))
	return unsafe.Pointer(_ret)
}

// GetShortArrayElements wraps the JNI GetShortArrayElements function.
func (e *Env) GetShortArrayElements(array *ShortArray, isCopy *uint8) unsafe.Pointer {
	_ret := capi.GetShortArrayElements(e.ptr, capi.ShortArray(array.Ref()), (*capi.Jboolean)(isCopy))
	return unsafe.Pointer(_ret)
}

// GetShortArrayRegion wraps the JNI GetShortArrayRegion function.
func (e *Env) GetShortArrayRegion(
	array *ShortArray,
	start int32,
	len int32,
	buf unsafe.Pointer,
) {
	capi.GetShortArrayRegion(e.ptr, capi.ShortArray(array.Ref()), capi.Jint(start), capi.Jint(len), (*capi.Jshort)(buf))
}

// GetShortField wraps the JNI GetShortField function.
func (e *Env) GetShortField(obj *Object, field FieldID) int16 {
	_ret := capi.GetShortField(e.ptr, obj.Ref(), field)
	return int16(_ret)
}

// GetStaticBooleanField wraps the JNI GetStaticBooleanField function.
func (e *Env) GetStaticBooleanField(cls *Class, field FieldID) uint8 {
	_ret := capi.GetStaticBooleanField(e.ptr, capi.Class(cls.Ref()), field)
	return uint8(_ret)
}

// GetStaticByteField wraps the JNI GetStaticByteField function.
func (e *Env) GetStaticByteField(cls *Class, field FieldID) int8 {
	_ret := capi.GetStaticByteField(e.ptr, capi.Class(cls.Ref()), field)
	return int8(_ret)
}

// GetStaticCharField wraps the JNI GetStaticCharField function.
func (e *Env) GetStaticCharField(cls *Class, field FieldID) uint16 {
	_ret := capi.GetStaticCharField(e.ptr, capi.Class(cls.Ref()), field)
	return uint16(_ret)
}

// GetStaticDoubleField wraps the JNI GetStaticDoubleField function.
func (e *Env) GetStaticDoubleField(cls *Class, field FieldID) float64 {
	_ret := capi.GetStaticDoubleField(e.ptr, capi.Class(cls.Ref()), field)
	return float64(_ret)
}

// GetStaticFieldID wraps the JNI GetStaticFieldID function.
func (e *Env) GetStaticFieldID(
	cls *Class,
	name string,
	sig string,
) (FieldID, error) {
	cName := append([]byte(name), 0)
	cSig := append([]byte(sig), 0)
	_ret := capi.GetStaticFieldID(e.ptr, capi.Class(cls.Ref()), (*capi.Cchar)(unsafe.Pointer(&cName[0])), (*capi.Cchar)(unsafe.Pointer(&cSig[0])))
	if err := jnierr.CheckException(e.ptr); err != nil {
		return nil, err
	}
	return _ret, nil
}

// GetStaticFloatField wraps the JNI GetStaticFloatField function.
func (e *Env) GetStaticFloatField(cls *Class, field FieldID) float32 {
	_ret := capi.GetStaticFloatField(e.ptr, capi.Class(cls.Ref()), field)
	return float32(_ret)
}

// GetStaticIntField wraps the JNI GetStaticIntField function.
func (e *Env) GetStaticIntField(cls *Class, field FieldID) int32 {
	_ret := capi.GetStaticIntField(e.ptr, capi.Class(cls.Ref()), field)
	return int32(_ret)
}

// GetStaticLongField wraps the JNI GetStaticLongField function.
func (e *Env) GetStaticLongField(cls *Class, field FieldID) int64 {
	_ret := capi.GetStaticLongField(e.ptr, capi.Class(cls.Ref()), field)
	return int64(_ret)
}

// GetStaticMethodID wraps the JNI GetStaticMethodID function.
func (e *Env) GetStaticMethodID(
	cls *Class,
	name string,
	sig string,
) (MethodID, error) {
	cName := append([]byte(name), 0)
	cSig := append([]byte(sig), 0)
	_ret := capi.GetStaticMethodID(e.ptr, capi.Class(cls.Ref()), (*capi.Cchar)(unsafe.Pointer(&cName[0])), (*capi.Cchar)(unsafe.Pointer(&cSig[0])))
	if err := jnierr.CheckException(e.ptr); err != nil {
		return nil, err
	}
	return _ret, nil
}

// GetStaticObjectField wraps the JNI GetStaticObjectField function.
func (e *Env) GetStaticObjectField(cls *Class, field FieldID) *Object {
	_ret := capi.GetStaticObjectField(e.ptr, capi.Class(cls.Ref()), field)
	if _ret == 0 {
		return nil
	}
	return &Object{ref: _ret}
}

// GetStaticShortField wraps the JNI GetStaticShortField function.
func (e *Env) GetStaticShortField(cls *Class, field FieldID) int16 {
	_ret := capi.GetStaticShortField(e.ptr, capi.Class(cls.Ref()), field)
	return int16(_ret)
}

// GetStringChars wraps the JNI GetStringChars function.
func (e *Env) GetStringChars(str *String, isCopy *uint8) (unsafe.Pointer, error) {
	_ret := capi.GetStringChars(e.ptr, capi.String(str.Ref()), (*capi.Jboolean)(isCopy))
	if err := jnierr.CheckException(e.ptr); err != nil {
		return nil, err
	}
	return unsafe.Pointer(_ret), nil
}

// GetStringCritical wraps the JNI GetStringCritical function.
func (e *Env) GetStringCritical(str *String, isCopy *uint8) unsafe.Pointer {
	_ret := capi.GetStringCritical(e.ptr, capi.String(str.Ref()), (*capi.Jboolean)(isCopy))
	return unsafe.Pointer(_ret)
}

// GetStringLength wraps the JNI GetStringLength function.
func (e *Env) GetStringLength(str *String) int32 {
	_ret := capi.GetStringLength(e.ptr, capi.String(str.Ref()))
	return int32(_ret)
}

// GetStringRegion wraps the JNI GetStringRegion function.
func (e *Env) GetStringRegion(
	str *String,
	start int32,
	len int32,
	buf []uint16,
) error {
	capi.GetStringRegion(e.ptr, capi.String(str.Ref()), capi.Jint(start), capi.Jint(len), (*capi.Jchar)(unsafe.Pointer(&buf[0])))
	if err := jnierr.CheckException(e.ptr); err != nil {
		return err
	}
	return nil
}

// GetStringUTFChars wraps the JNI GetStringUTFChars function.
func (e *Env) GetStringUTFChars(str *String, isCopy *uint8) (unsafe.Pointer, error) {
	_ret := capi.GetStringUTFChars(e.ptr, capi.String(str.Ref()), (*capi.Jboolean)(isCopy))
	if err := jnierr.CheckException(e.ptr); err != nil {
		return nil, err
	}
	return unsafe.Pointer(_ret), nil
}

// GetStringUTFLength wraps the JNI GetStringUTFLength function.
func (e *Env) GetStringUTFLength(str *String) int32 {
	_ret := capi.GetStringUTFLength(e.ptr, capi.String(str.Ref()))
	return int32(_ret)
}

// GetStringUTFRegion wraps the JNI GetStringUTFRegion function.
func (e *Env) GetStringUTFRegion(
	str *String,
	start int32,
	len int32,
	buf []byte,
) error {
	capi.GetStringUTFRegion(e.ptr, capi.String(str.Ref()), capi.Jint(start), capi.Jint(len), (*capi.Cchar)(unsafe.Pointer(&buf[0])))
	if err := jnierr.CheckException(e.ptr); err != nil {
		return err
	}
	return nil
}

// GetSuperclass wraps the JNI GetSuperclass function.
func (e *Env) GetSuperclass(cls *Class) *Class {
	_ret := capi.GetSuperclass(e.ptr, capi.Class(cls.Ref()))
	if _ret == 0 {
		return nil
	}
	return &Class{Object{ref: capi.Object(_ret)}}
}

// GetVersion wraps the JNI GetVersion function.
func (e *Env) GetVersion() int32 {
	_ret := capi.GetVersion(e.ptr)
	return int32(_ret)
}

// IsAssignableFrom wraps the JNI IsAssignableFrom function.
func (e *Env) IsAssignableFrom(cls1 *Class, cls2 *Class) bool {
	_ret := capi.IsAssignableFrom(e.ptr, capi.Class(cls1.Ref()), capi.Class(cls2.Ref()))
	return _ret != 0
}

// IsInstanceOf wraps the JNI IsInstanceOf function.
func (e *Env) IsInstanceOf(obj *Object, cls *Class) bool {
	_ret := capi.IsInstanceOf(e.ptr, obj.Ref(), capi.Class(cls.Ref()))
	return _ret != 0
}

// IsSameObject wraps the JNI IsSameObject function.
func (e *Env) IsSameObject(ref1 *Object, ref2 *Object) bool {
	_ret := capi.IsSameObject(e.ptr, ref1.Ref(), ref2.Ref())
	return _ret != 0
}

// MonitorEnter wraps the JNI MonitorEnter function.
func (e *Env) MonitorEnter(obj *Object) error {
	rc := capi.MonitorEnter(e.ptr, obj.Ref())
	if rc != capi.JNI_OK {
		return Error(rc)
	}
	return nil
}

// MonitorExit wraps the JNI MonitorExit function.
func (e *Env) MonitorExit(obj *Object) error {
	rc := capi.MonitorExit(e.ptr, obj.Ref())
	if rc != capi.JNI_OK {
		return Error(rc)
	}
	return nil
}

// NewBooleanArray wraps the JNI NewBooleanArray function.
func (e *Env) NewBooleanArray(length int32) *BooleanArray {
	_ret := capi.NewBooleanArray(e.ptr, capi.Jint(length))
	if _ret == 0 {
		return nil
	}
	return &BooleanArray{Array{Object{ref: capi.Object(_ret)}}}
}

// NewByteArray wraps the JNI NewByteArray function.
func (e *Env) NewByteArray(length int32) *ByteArray {
	_ret := capi.NewByteArray(e.ptr, capi.Jint(length))
	if _ret == 0 {
		return nil
	}
	return &ByteArray{Array{Object{ref: capi.Object(_ret)}}}
}

// NewCharArray wraps the JNI NewCharArray function.
func (e *Env) NewCharArray(length int32) *CharArray {
	_ret := capi.NewCharArray(e.ptr, capi.Jint(length))
	if _ret == 0 {
		return nil
	}
	return &CharArray{Array{Object{ref: capi.Object(_ret)}}}
}

// NewDirectByteBuffer wraps the JNI NewDirectByteBuffer function.
func (e *Env) NewDirectByteBuffer(address unsafe.Pointer, capacity int64) *Object {
	_ret := capi.NewDirectByteBuffer(e.ptr, address, capi.Jlong(capacity))
	if _ret == 0 {
		return nil
	}
	return &Object{ref: _ret}
}

// NewDoubleArray wraps the JNI NewDoubleArray function.
func (e *Env) NewDoubleArray(length int32) *DoubleArray {
	_ret := capi.NewDoubleArray(e.ptr, capi.Jint(length))
	if _ret == 0 {
		return nil
	}
	return &DoubleArray{Array{Object{ref: capi.Object(_ret)}}}
}

// NewFloatArray wraps the JNI NewFloatArray function.
func (e *Env) NewFloatArray(length int32) *FloatArray {
	_ret := capi.NewFloatArray(e.ptr, capi.Jint(length))
	if _ret == 0 {
		return nil
	}
	return &FloatArray{Array{Object{ref: capi.Object(_ret)}}}
}

// NewGlobalRef wraps the JNI NewGlobalRef function.
func (e *Env) NewGlobalRef(obj *Object) *Object {
	_ret := capi.NewGlobalRef(e.ptr, obj.Ref())
	if _ret == 0 {
		return nil
	}
	return &Object{ref: _ret}
}

// NewIntArray wraps the JNI NewIntArray function.
func (e *Env) NewIntArray(length int32) *IntArray {
	_ret := capi.NewIntArray(e.ptr, capi.Jint(length))
	if _ret == 0 {
		return nil
	}
	return &IntArray{Array{Object{ref: capi.Object(_ret)}}}
}

// NewLocalRef wraps the JNI NewLocalRef function.
func (e *Env) NewLocalRef(obj *Object) *Object {
	_ret := capi.NewLocalRef(e.ptr, obj.Ref())
	if _ret == 0 {
		return nil
	}
	return &Object{ref: _ret}
}

// NewLongArray wraps the JNI NewLongArray function.
func (e *Env) NewLongArray(length int32) *LongArray {
	_ret := capi.NewLongArray(e.ptr, capi.Jint(length))
	if _ret == 0 {
		return nil
	}
	return &LongArray{Array{Object{ref: capi.Object(_ret)}}}
}

// NewObject wraps the JNI NewObjectA function.
func (e *Env) NewObject(
	cls *Class,
	method MethodID,
	args ...Value,
) (*Object, error) {
	// _dummyJvalue ensures a non-nil jvalue pointer for zero-argument calls.
	// The JNI spec does not guarantee NULL is valid for the const jvalue*
	// parameter of Call<Type>MethodA; OpenJ9 rejects it as an error
	// (eclipse-openj9/openj9#10480). The dummy is never read by the JVM
	// when the method takes no arguments.
	var _dummyJvalue capi.Jvalue
	cArgs := &_dummyJvalue
	if len(args) > 0 {
		cArgs = &args[0].val
	}
	_ret := capi.NewObjectA(e.ptr, capi.Class(cls.Ref()), method, cArgs)
	if err := jnierr.CheckException(e.ptr); err != nil {
		return nil, err
	}
	if _ret == 0 {
		return nil, nil
	}
	return &Object{ref: _ret}, nil
}

// NewObjectArray wraps the JNI NewObjectArray function.
func (e *Env) NewObjectArray(
	length int32,
	elementClass *Class,
	initialElement *Object,
) (*ObjectArray, error) {
	_ret := capi.NewObjectArray(e.ptr, capi.Jint(length), capi.Class(elementClass.Ref()), initialElement.Ref())
	if err := jnierr.CheckException(e.ptr); err != nil {
		return nil, err
	}
	if _ret == 0 {
		return nil, nil
	}
	return &ObjectArray{Array{Object{ref: capi.Object(_ret)}}}, nil
}

// NewShortArray wraps the JNI NewShortArray function.
func (e *Env) NewShortArray(length int32) *ShortArray {
	_ret := capi.NewShortArray(e.ptr, capi.Jint(length))
	if _ret == 0 {
		return nil
	}
	return &ShortArray{Array{Object{ref: capi.Object(_ret)}}}
}

// NewString wraps the JNI NewString function.
func (e *Env) NewString(unicodeChars []uint16) (*String, error) {
	_ret := capi.NewString(e.ptr, (*capi.Jchar)(unsafe.Pointer(&unicodeChars[0])), capi.Jint(len(unicodeChars)))
	if err := jnierr.CheckException(e.ptr); err != nil {
		return nil, err
	}
	if _ret == 0 {
		return nil, nil
	}
	return &String{Object{ref: capi.Object(_ret)}}, nil
}

// NewStringUTF wraps the JNI NewStringUTF function.
func (e *Env) NewStringUTF(bytes string) (*String, error) {
	cBytes := append([]byte(bytes), 0)
	_ret := capi.NewStringUTF(e.ptr, (*capi.Cchar)(unsafe.Pointer(&cBytes[0])))
	if err := jnierr.CheckException(e.ptr); err != nil {
		return nil, err
	}
	if _ret == 0 {
		return nil, nil
	}
	return &String{Object{ref: capi.Object(_ret)}}, nil
}

// NewWeakGlobalRef wraps the JNI NewWeakGlobalRef function.
func (e *Env) NewWeakGlobalRef(obj *Object) *WeakRef {
	_ret := capi.NewWeakGlobalRef(e.ptr, obj.Ref())
	if _ret == 0 {
		return nil
	}
	return &WeakRef{Object{ref: capi.Object(_ret)}}
}

// PopLocalFrame wraps the JNI PopLocalFrame function.
func (e *Env) PopLocalFrame(result *Object) *Object {
	_ret := capi.PopLocalFrame(e.ptr, result.Ref())
	if _ret == 0 {
		return nil
	}
	return &Object{ref: _ret}
}

// PushLocalFrame wraps the JNI PushLocalFrame function.
func (e *Env) PushLocalFrame(capacity int32) error {
	rc := capi.PushLocalFrame(e.ptr, capi.Jint(capacity))
	if rc != capi.JNI_OK {
		return Error(rc)
	}
	return nil
}

// RegisterNatives wraps the JNI RegisterNatives function.
func (e *Env) RegisterNatives(
	cls *Class,
	methods unsafe.Pointer,
	nMethods int32,
) error {
	rc := capi.RegisterNatives(e.ptr, capi.Class(cls.Ref()), (*capi.JNINativeMethod)(methods), capi.Jint(nMethods))
	if rc != capi.JNI_OK {
		return Error(rc)
	}
	return nil
}

// ReleaseBooleanArrayElements wraps the JNI ReleaseBooleanArrayElements function.
func (e *Env) ReleaseBooleanArrayElements(
	array *BooleanArray,
	elems unsafe.Pointer,
	mode int32,
) {
	capi.ReleaseBooleanArrayElements(e.ptr, capi.BooleanArray(array.Ref()), (*capi.Jboolean)(elems), capi.Jint(mode))
}

// ReleaseByteArrayElements wraps the JNI ReleaseByteArrayElements function.
func (e *Env) ReleaseByteArrayElements(
	array *ByteArray,
	elems unsafe.Pointer,
	mode int32,
) {
	capi.ReleaseByteArrayElements(e.ptr, capi.ByteArray(array.Ref()), (*capi.Jbyte)(elems), capi.Jint(mode))
}

// ReleaseCharArrayElements wraps the JNI ReleaseCharArrayElements function.
func (e *Env) ReleaseCharArrayElements(
	array *CharArray,
	elems unsafe.Pointer,
	mode int32,
) {
	capi.ReleaseCharArrayElements(e.ptr, capi.CharArray(array.Ref()), (*capi.Jchar)(elems), capi.Jint(mode))
}

// ReleaseDoubleArrayElements wraps the JNI ReleaseDoubleArrayElements function.
func (e *Env) ReleaseDoubleArrayElements(
	array *DoubleArray,
	elems unsafe.Pointer,
	mode int32,
) {
	capi.ReleaseDoubleArrayElements(e.ptr, capi.DoubleArray(array.Ref()), (*capi.Jdouble)(elems), capi.Jint(mode))
}

// ReleaseFloatArrayElements wraps the JNI ReleaseFloatArrayElements function.
func (e *Env) ReleaseFloatArrayElements(
	array *FloatArray,
	elems unsafe.Pointer,
	mode int32,
) {
	capi.ReleaseFloatArrayElements(e.ptr, capi.FloatArray(array.Ref()), (*capi.Jfloat)(elems), capi.Jint(mode))
}

// ReleaseIntArrayElements wraps the JNI ReleaseIntArrayElements function.
func (e *Env) ReleaseIntArrayElements(
	array *IntArray,
	elems unsafe.Pointer,
	mode int32,
) {
	capi.ReleaseIntArrayElements(e.ptr, capi.IntArray(array.Ref()), (*capi.Jint)(elems), capi.Jint(mode))
}

// ReleaseLongArrayElements wraps the JNI ReleaseLongArrayElements function.
func (e *Env) ReleaseLongArrayElements(
	array *LongArray,
	elems unsafe.Pointer,
	mode int32,
) {
	capi.ReleaseLongArrayElements(e.ptr, capi.LongArray(array.Ref()), (*capi.Jlong)(elems), capi.Jint(mode))
}

// ReleasePrimitiveArrayCritical wraps the JNI ReleasePrimitiveArrayCritical function.
func (e *Env) ReleasePrimitiveArrayCritical(
	array *Array,
	carray unsafe.Pointer,
	mode int32,
) {
	capi.ReleasePrimitiveArrayCritical(e.ptr, capi.Array(array.Ref()), carray, capi.Jint(mode))
}

// ReleaseShortArrayElements wraps the JNI ReleaseShortArrayElements function.
func (e *Env) ReleaseShortArrayElements(
	array *ShortArray,
	elems unsafe.Pointer,
	mode int32,
) {
	capi.ReleaseShortArrayElements(e.ptr, capi.ShortArray(array.Ref()), (*capi.Jshort)(elems), capi.Jint(mode))
}

// ReleaseStringChars wraps the JNI ReleaseStringChars function.
func (e *Env) ReleaseStringChars(str *String, chars unsafe.Pointer) {
	capi.ReleaseStringChars(e.ptr, capi.String(str.Ref()), (*capi.Jchar)(chars))
}

// ReleaseStringCritical wraps the JNI ReleaseStringCritical function.
func (e *Env) ReleaseStringCritical(str *String, cstr unsafe.Pointer) {
	capi.ReleaseStringCritical(e.ptr, capi.String(str.Ref()), (*capi.Jchar)(cstr))
}

// ReleaseStringUTFChars wraps the JNI ReleaseStringUTFChars function.
func (e *Env) ReleaseStringUTFChars(str *String, utf unsafe.Pointer) {
	capi.ReleaseStringUTFChars(e.ptr, capi.String(str.Ref()), (*capi.Cchar)(utf))
}

// SetBooleanArrayRegion wraps the JNI SetBooleanArrayRegion function.
func (e *Env) SetBooleanArrayRegion(
	array *BooleanArray,
	start int32,
	len int32,
	buf unsafe.Pointer,
) {
	capi.SetBooleanArrayRegion(e.ptr, capi.BooleanArray(array.Ref()), capi.Jint(start), capi.Jint(len), (*capi.Jboolean)(buf))
}

// SetBooleanField wraps the JNI SetBooleanField function.
func (e *Env) SetBooleanField(
	obj *Object,
	field FieldID,
	value uint8,
) {
	capi.SetBooleanField(e.ptr, obj.Ref(), field, capi.Jboolean(value))
}

// SetByteArrayRegion wraps the JNI SetByteArrayRegion function.
func (e *Env) SetByteArrayRegion(
	array *ByteArray,
	start int32,
	len int32,
	buf unsafe.Pointer,
) {
	capi.SetByteArrayRegion(e.ptr, capi.ByteArray(array.Ref()), capi.Jint(start), capi.Jint(len), (*capi.Jbyte)(buf))
}

// SetByteField wraps the JNI SetByteField function.
func (e *Env) SetByteField(
	obj *Object,
	field FieldID,
	value int8,
) {
	capi.SetByteField(e.ptr, obj.Ref(), field, capi.Jbyte(value))
}

// SetCharArrayRegion wraps the JNI SetCharArrayRegion function.
func (e *Env) SetCharArrayRegion(
	array *CharArray,
	start int32,
	len int32,
	buf unsafe.Pointer,
) {
	capi.SetCharArrayRegion(e.ptr, capi.CharArray(array.Ref()), capi.Jint(start), capi.Jint(len), (*capi.Jchar)(buf))
}

// SetCharField wraps the JNI SetCharField function.
func (e *Env) SetCharField(
	obj *Object,
	field FieldID,
	value uint16,
) {
	capi.SetCharField(e.ptr, obj.Ref(), field, capi.Jchar(value))
}

// SetDoubleArrayRegion wraps the JNI SetDoubleArrayRegion function.
func (e *Env) SetDoubleArrayRegion(
	array *DoubleArray,
	start int32,
	len int32,
	buf unsafe.Pointer,
) {
	capi.SetDoubleArrayRegion(e.ptr, capi.DoubleArray(array.Ref()), capi.Jint(start), capi.Jint(len), (*capi.Jdouble)(buf))
}

// SetDoubleField wraps the JNI SetDoubleField function.
func (e *Env) SetDoubleField(
	obj *Object,
	field FieldID,
	value float64,
) {
	capi.SetDoubleField(e.ptr, obj.Ref(), field, capi.Jdouble(value))
}

// SetFloatArrayRegion wraps the JNI SetFloatArrayRegion function.
func (e *Env) SetFloatArrayRegion(
	array *FloatArray,
	start int32,
	len int32,
	buf unsafe.Pointer,
) {
	capi.SetFloatArrayRegion(e.ptr, capi.FloatArray(array.Ref()), capi.Jint(start), capi.Jint(len), (*capi.Jfloat)(buf))
}

// SetFloatField wraps the JNI SetFloatField function.
func (e *Env) SetFloatField(
	obj *Object,
	field FieldID,
	value float32,
) {
	capi.SetFloatField(e.ptr, obj.Ref(), field, capi.Jfloat(value))
}

// SetIntArrayRegion wraps the JNI SetIntArrayRegion function.
func (e *Env) SetIntArrayRegion(
	array *IntArray,
	start int32,
	len int32,
	buf unsafe.Pointer,
) {
	capi.SetIntArrayRegion(e.ptr, capi.IntArray(array.Ref()), capi.Jint(start), capi.Jint(len), (*capi.Jint)(buf))
}

// SetIntField wraps the JNI SetIntField function.
func (e *Env) SetIntField(
	obj *Object,
	field FieldID,
	value int32,
) {
	capi.SetIntField(e.ptr, obj.Ref(), field, capi.Jint(value))
}

// SetLongArrayRegion wraps the JNI SetLongArrayRegion function.
func (e *Env) SetLongArrayRegion(
	array *LongArray,
	start int32,
	len int32,
	buf unsafe.Pointer,
) {
	capi.SetLongArrayRegion(e.ptr, capi.LongArray(array.Ref()), capi.Jint(start), capi.Jint(len), (*capi.Jlong)(buf))
}

// SetLongField wraps the JNI SetLongField function.
func (e *Env) SetLongField(
	obj *Object,
	field FieldID,
	value int64,
) {
	capi.SetLongField(e.ptr, obj.Ref(), field, capi.Jlong(value))
}

// SetObjectArrayElement wraps the JNI SetObjectArrayElement function.
func (e *Env) SetObjectArrayElement(
	array *ObjectArray,
	index int32,
	value *Object,
) error {
	capi.SetObjectArrayElement(e.ptr, capi.ObjectArray(array.Ref()), capi.Jint(index), value.Ref())
	if err := jnierr.CheckException(e.ptr); err != nil {
		return err
	}
	return nil
}

// SetObjectField wraps the JNI SetObjectField function.
func (e *Env) SetObjectField(
	obj *Object,
	field FieldID,
	value *Object,
) {
	capi.SetObjectField(e.ptr, obj.Ref(), field, value.Ref())
}

// SetShortArrayRegion wraps the JNI SetShortArrayRegion function.
func (e *Env) SetShortArrayRegion(
	array *ShortArray,
	start int32,
	len int32,
	buf unsafe.Pointer,
) {
	capi.SetShortArrayRegion(e.ptr, capi.ShortArray(array.Ref()), capi.Jint(start), capi.Jint(len), (*capi.Jshort)(buf))
}

// SetShortField wraps the JNI SetShortField function.
func (e *Env) SetShortField(
	obj *Object,
	field FieldID,
	value int16,
) {
	capi.SetShortField(e.ptr, obj.Ref(), field, capi.Jshort(value))
}

// SetStaticBooleanField wraps the JNI SetStaticBooleanField function.
func (e *Env) SetStaticBooleanField(
	cls *Class,
	field FieldID,
	value uint8,
) {
	capi.SetStaticBooleanField(e.ptr, capi.Class(cls.Ref()), field, capi.Jboolean(value))
}

// SetStaticByteField wraps the JNI SetStaticByteField function.
func (e *Env) SetStaticByteField(
	cls *Class,
	field FieldID,
	value int8,
) {
	capi.SetStaticByteField(e.ptr, capi.Class(cls.Ref()), field, capi.Jbyte(value))
}

// SetStaticCharField wraps the JNI SetStaticCharField function.
func (e *Env) SetStaticCharField(
	cls *Class,
	field FieldID,
	value uint16,
) {
	capi.SetStaticCharField(e.ptr, capi.Class(cls.Ref()), field, capi.Jchar(value))
}

// SetStaticDoubleField wraps the JNI SetStaticDoubleField function.
func (e *Env) SetStaticDoubleField(
	cls *Class,
	field FieldID,
	value float64,
) {
	capi.SetStaticDoubleField(e.ptr, capi.Class(cls.Ref()), field, capi.Jdouble(value))
}

// SetStaticFloatField wraps the JNI SetStaticFloatField function.
func (e *Env) SetStaticFloatField(
	cls *Class,
	field FieldID,
	value float32,
) {
	capi.SetStaticFloatField(e.ptr, capi.Class(cls.Ref()), field, capi.Jfloat(value))
}

// SetStaticIntField wraps the JNI SetStaticIntField function.
func (e *Env) SetStaticIntField(
	cls *Class,
	field FieldID,
	value int32,
) {
	capi.SetStaticIntField(e.ptr, capi.Class(cls.Ref()), field, capi.Jint(value))
}

// SetStaticLongField wraps the JNI SetStaticLongField function.
func (e *Env) SetStaticLongField(
	cls *Class,
	field FieldID,
	value int64,
) {
	capi.SetStaticLongField(e.ptr, capi.Class(cls.Ref()), field, capi.Jlong(value))
}

// SetStaticObjectField wraps the JNI SetStaticObjectField function.
func (e *Env) SetStaticObjectField(
	cls *Class,
	field FieldID,
	value *Object,
) {
	capi.SetStaticObjectField(e.ptr, capi.Class(cls.Ref()), field, value.Ref())
}

// SetStaticShortField wraps the JNI SetStaticShortField function.
func (e *Env) SetStaticShortField(
	cls *Class,
	field FieldID,
	value int16,
) {
	capi.SetStaticShortField(e.ptr, capi.Class(cls.Ref()), field, capi.Jshort(value))
}

// Throw wraps the JNI Throw function.
func (e *Env) Throw(throwable *Throwable) error {
	rc := capi.Throw(e.ptr, capi.Throwable(throwable.Ref()))
	if rc != capi.JNI_OK {
		return Error(rc)
	}
	return nil
}

// ThrowNew wraps the JNI ThrowNew function.
func (e *Env) ThrowNew(cls *Class, message string) error {
	cMessage := append([]byte(message), 0)
	rc := capi.ThrowNew(e.ptr, capi.Class(cls.Ref()), (*capi.Cchar)(unsafe.Pointer(&cMessage[0])))
	if rc != capi.JNI_OK {
		return Error(rc)
	}
	return nil
}

// ToReflectedField wraps the JNI ToReflectedField function.
func (e *Env) ToReflectedField(
	cls *Class,
	field FieldID,
	isStatic bool,
) *Object {
	var cIsStatic capi.Jboolean
	if isStatic {
		cIsStatic = capi.JNI_TRUE
	}
	_ret := capi.ToReflectedField(e.ptr, capi.Class(cls.Ref()), field, cIsStatic)
	if _ret == 0 {
		return nil
	}
	return &Object{ref: _ret}
}

// ToReflectedMethod wraps the JNI ToReflectedMethod function.
func (e *Env) ToReflectedMethod(
	cls *Class,
	method MethodID,
	isStatic bool,
) *Object {
	var cIsStatic capi.Jboolean
	if isStatic {
		cIsStatic = capi.JNI_TRUE
	}
	_ret := capi.ToReflectedMethod(e.ptr, capi.Class(cls.Ref()), method, cIsStatic)
	if _ret == 0 {
		return nil
	}
	return &Object{ref: _ret}
}

// UnregisterNatives wraps the JNI UnregisterNatives function.
func (e *Env) UnregisterNatives(cls *Class) error {
	rc := capi.UnregisterNatives(e.ptr, capi.Class(cls.Ref()))
	if rc != capi.JNI_OK {
		return Error(rc)
	}
	return nil
}