Method store_to_args

wasmtime-jni/src/wasm_value.rs:235–294

(
        self,
        env: &JNIEnv<'j>,
        args: &mut Vec<Val>,
        wasm_alloc: Option<&'w WasmAlloc>,
        mut store: S,
    )

    }

    pub fn store_to_args<'w, S: AsContextMut>(
        self,
        env: &JNIEnv<'j>,
        args: &mut Vec<Val>,
        wasm_alloc: Option<&'w WasmAlloc>,
        mut store: S,
    ) -> Result<Option<WasmSliceWrapper<'w>>, anyhow::Error> {
        match self {
            // WasmVal::ByteBuffer(buffer) => {
            //     let direct_bytes: &[u8] = env.get_direct_buffer_address(buffer)?;

            //     // the module might not have the memory exported
            //     let wasm_alloc = wasm_alloc
            //         .ok_or_else(|| anyhow!("no memory or allocator supplied from module"))?;
            //     let wasm_slice = wasm_alloc.alloc_bytes(direct_bytes)?;
            //     wasm_slice.store_to_args(args);
            //     return Ok(Some(wasm_slice));
            // }
            WasmVal::ByteArray { jarray, .. } => {
                // This is should be safe, it's copied into while borrowed the WASM context.
                let len = env.get_array_length(jarray)?;
                let jbytes = env.get_byte_array_elements(jarray, ReleaseMode::CopyBack)?;
                let byte_array: &[u8] =
                    unsafe { slice::from_raw_parts(jbytes.as_ptr() as *const u8, len as usize) };

                // the module might not have the memory exported
                let wasm_alloc = wasm_alloc
                    .ok_or_else(|| anyhow!("no memory or allocator supplied from module"))?;
                let wasm_slice = wasm_alloc.alloc_bytes(byte_array, &mut store)?;

                wasm_slice.store_to_args(args);
                return Ok(Some(wasm_slice));
            }
            WasmVal::String(string) => {
                // This is should be safe, it's copied into while borrowed the WASM context.

                let jstr = env.get_string(string)?;
                let cow = Cow::from(&jstr);
                debug!("String from Java going to WASM: {}", cow);

                let cow_bytes = cow.as_bytes();

                // the module might not have the memory exported
                let wasm_alloc = wasm_alloc
                    .ok_or_else(|| anyhow!("no memory or allocator supplied from module"))?;
                let wasm_slice = wasm_alloc.alloc_bytes(cow_bytes, store)?;

                // release the array reference, CopyBack is following the JNI guidelines
                wasm_slice.store_to_args(args);
                return Ok(Some(wasm_slice));
            }
            WasmVal::Val(val @ Val::I32(_)) => val.unwrap_i32().store_to_args(args),
            WasmVal::Val(val @ Val::I64(_)) => val.unwrap_i64().store_to_args(args),
            WasmVal::Val(val @ Val::F32(_)) => val.unwrap_f32().store_to_args(args),
            WasmVal::Val(val @ Val::F64(_)) => val.unwrap_f64().store_to_args(args),
            WasmVal::Val(v) => unimplemented!("type not yet supported as an arg: {:?}", v),
        }