tomleavy
commented
2 years ago Here is my suggestion for how to handle Java binding generation
FFI Code from fixed_decimal.rs
#[diplomat::bridge]
pub mod ffi {
use diplomat_runtime::{DiplomatResult, DiplomatWriteable};
use fixed_decimal::FixedDecimal;
use writeable::Writeable;
#[diplomat::opaque]
#[diplomat::rust_link(fixed_decimal::FixedDecimal, Struct)]
pub struct ICU4XFixedDecimal(pub FixedDecimal);
impl ICU4XFixedDecimal {
/// Construct an [`ICU4XFixedDecimal`] from an integer.
pub fn new(v: i32) -> Box<ICU4XFixedDecimal> {
Box::new(ICU4XFixedDecimal(FixedDecimal::from(v)))
}
/// Multiply the [`ICU4XFixedDecimal`] by a given power of ten.
#[diplomat::rust_link(fixed_decimal::FixedDecimal::multiply_pow10, FnInStruct)]
pub fn multiply_pow10(&mut self, power: i16) {
self.0.multiply_pow10(power).unwrap();
}
/// Invert the sign of the [`ICU4XFixedDecimal`].
#[diplomat::rust_link(fixed_decimal::FixedDecimal::negate, FnInStruct)]
pub fn negate(&mut self) {
self.0.negate()
}
/// Format the [`ICU4XFixedDecimal`] as a string.
#[diplomat::rust_link(fixed_decimal::FixedDecimal::write_to, FnInStruct)]
pub fn to_string(&self, to: &mut DiplomatWriteable) -> DiplomatResult<(), ()> {
self.0.write_to(to).map_err(|_| ()).into()
}
}
}Generated JNI Glue
Runtime JNI type conversions
#[inline(always)]
pub fn jint_to_u32(val: jint) -> u32 {
val as u32 // jint is a type alias for i32
}
#[inline(always)]
pub fn jint_to_i16(val: jint) -> i16 {
val as i16
}
#[inline(always)]
pub fn jlong_to_mut_ptr<T>(val: jlong) -> *mut T {
&mut *(val as *mut T)
}
#[inline(always)]
pub fn jlong_to_ptr<T>(val: jlong) -> *T {
&*(val as *T)
}JNI Methods
pub extern "system" fn Java_org_icu4x_FixedDecimalJNI_new(env: JNIEnv, _class: JClass, v: jint) -> jlong {
// Convert each input from JNI type to FFI type
let v_ffi = jint_to_u32(v);
// Call FFI method
let res = ICU4XFixedDecimal_new(v_ffi);
// Return the FFI method result
res as jlong // return memory address of Box<T> to java
}
pub extern "system" fn Java_org_icu4x_FixedDecimalJNI_pow10(env: JNIEnv, _class: JClass, obj_addr: jlong, power: jint) {
// Convert the jlong back into a pointer
let obj = jlong_to_mut_ptr::<ICU4XFixedDecimal>(obj_addr);
// Convert each input from JNI type to FFI type
let power_ffi = jint_to_i16(power);
// Call the FFI method
ICU4XFixedDecimal_multiply_pow10(obj, power_ffi)
}
pub extern "system" fn Java_org_icu4x_FixedDecimalJNI_negate(env: JNIEnv, _class: JClass, obj_addr: jlong) {
// Convert the jlong back into a pointer
let obj_ptr = jlong_to_mut_ptr::<ICU4XFixedDecimal>(obj_addr);
// Call the FFI method
ICU4XFixedDecimal_negate(obj_ptr)
}
pub extern "system" fn Java_org_icu4x_FixedDecimalJNI_to_string(env: JNIEnv, _class: JClass, obj_addr: jlong, to_addr: jlong) {
let obj_ptr = jlong_to_ptr::<ICU4XFixedDecimal>(obj_addr);
let to_ptr = jlong_to_mut_ptr::<DiplomatWriteable>(to_addr);
let res = ICU4XFixedDecimal_to_string(obj_ptr, to_ptr);
if !res.is_ok {
env.throw("some error message".to_string()).unwrap() // have to think about how to handle errors here.
}
}
pub extern "system" fn Java_org_icu4x_FixedDecimalJNI_destroy(env: JNIEnv, _class: JClass, obj_addr: jlong) {
// Convert the jlong back into a pointer
let obj_ptr = jlong_to_mut_ptr::<ICU4XFixedDecimal>(obj_addr);
// Call the FFI method
ICU4XFixedDecimal_destroy(obj_ptr)
}Low Level Java (FixedDecimalJNI.java)
class FixedDecimalJNI {
public static native jlong new(int v);
public static native pow10(long addr, int power);
public static native negate(long addr);
public static native toString(long addr, long to_addr);
public static native destroy(long addr);
static {
System.loadLibrary("icu4x");
}
}High Level Java
class JniBase {
protected long addr;
public JniBase(int addr) {
this.addr = addr
}
public getAddr() {
return this.addr;
}
}
class DiplomatWriteable extends JniBase {
....
}
class FixedDecimal extends JniBase {
public FixedDecimal(int v) {
super(FixedDecimalJNI.new(v));
}
public void pow10(int power) {
FixedDecimalJNI.pow10(this.addr, power);
}
public void negate() {
FixedDecimalJNI.negate(this.addr);
}
public void toString(DiplomatWriteable to) throws Exception {
FixedDecimalJNI.toString(this.addr, to.getAddr())
}
@Override
public void finalize() {
FixedDecimalJNI.destroy(this.addr)
}
}
sffc
Manishearth
josh-hemphill
ExE-Boss
jcrist1
brainstorm
Same use case as #143 , except the Java version