Remove load_bytes, store_bytes, instead expose array raw buffer

Author: dlunch

java_runtime/src/classes/java/io/buffered_reader.rs

@@ -103,8 +103,6 @@ impl BufferedReader {
 
 #[cfg(test)]
 mod test {
-    use bytemuck::cast_vec;
-
     use jvm::{runtime::JavaLangString, ClassInstanceRef, Result};
 
     use crate::{classes::java::lang::String, test::test_jvm};
@@ -114,7 +112,7 @@ mod test {
         let jvm = test_jvm().await?;
 
         let mut buffer = jvm.instantiate_array("B", 11).await?;
-        jvm.store_byte_array(&mut buffer, 0, cast_vec(b"Hello\nWorld".to_vec())).await?;
+        jvm.array_raw_buffer_mut(&mut buffer).await?.write(0, b"Hello\nWorld")?;
 
         let is = jvm.new_class("java/io/ByteArrayInputStream", "([B)V", (buffer,)).await?;
         let isr = jvm.new_class("java/io/InputStreamReader", "(Ljava/io/InputStream;)V", (is,)).await?;

java_runtime/src/classes/java/io/byte_array_input_stream.rs

@@ -93,11 +93,11 @@ impl ByteArrayInputStream {
             return Ok(-1);
         }
 
-        let result = jvm.load_byte_array(&buf, pos as _, 1).await?[0] as u8;
+        let result: i8 = jvm.load_array(&buf, pos as _, 1).await?[0];
 
         jvm.put_field(&mut this, "pos", "I", pos + 1).await?;
 
-        Ok(result as _)
+        Ok(result as u8 as _)
     }
 
     async fn close(_: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<ByteArrayInputStream>) -> Result<()> {

java_runtime/src/classes/java/io/byte_array_output_stream.rs

@@ -1,4 +1,4 @@
-use alloc::{vec, vec::Vec};
+use alloc::vec;
 
 use java_class_proto::{JavaFieldProto, JavaMethodProto};
 use jvm::{Array, ClassInstanceRef, Jvm, Result};
@@ -57,7 +57,7 @@ impl ByteArrayOutputStream {
         Self::ensure_capacity(jvm, &mut this, (pos + 1) as _).await?;
 
         let mut buf = jvm.get_field(&this, "buf", "[B").await?;
-        jvm.store_byte_array(&mut buf, pos as _, vec![b as i8]).await?;
+        jvm.store_array(&mut buf, pos as _, vec![b as i8]).await?;
 
         jvm.put_field(&mut this, "pos", "I", pos + 1).await?;
 
@@ -67,28 +67,41 @@ impl ByteArrayOutputStream {
     async fn to_byte_array(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Array<i8>>> {
         tracing::debug!("java.io.ByteArrayOutputStream::to_byte_array({:?})", &this);
 
-        let buf = jvm.get_field(&this, "buf", "[B").await?;
+        let buf: ClassInstanceRef<Array<i8>> = jvm.get_field(&this, "buf", "[B").await?;
         let pos: i32 = jvm.get_field(&this, "pos", "I").await?;
 
-        let bytes = jvm.load_byte_array(&buf, 0, pos as _).await?;
-        let mut array = jvm.instantiate_array("B", bytes.len()).await?;
-        jvm.store_byte_array(&mut array, 0, bytes).await?;
+        let dest = jvm.instantiate_array("B", pos as _).await?;
+        let _: () = jvm
+            .invoke_static(
+                "java/lang/System",
+                "arraycopy",
+                "(Ljava/lang/Object;ILjava/lang/Object;II)V",
+                (buf.clone(), 0, dest.clone(), 0, pos),
+            )
+            .await?;
 
-        Ok(array.into())
+        Ok(dest.into())
     }
 
     async fn ensure_capacity(jvm: &Jvm, this: &mut ClassInstanceRef<Self>, capacity: usize) -> Result<()> {
         let old_buf = jvm.get_field(this, "buf", "[B").await?;
         let current_capacity = jvm.array_length(&old_buf).await?;
 
         if current_capacity < capacity {
-            let old_values: Vec<i8> = jvm.load_byte_array(&old_buf, 0, current_capacity).await?;
             let new_capacity = capacity * 2;
+            let new_buf = jvm.instantiate_array("B", new_capacity).await?;
+
+            let _: () = jvm
+                .invoke_static(
+                    "java/lang/System",
+                    "arraycopy",
+                    "(Ljava/lang/Object;ILjava/lang/Object;II)V",
+                    (old_buf.clone(), 0, new_buf.clone(), 0, current_capacity as i32),
+                )
+                .await?;
 
-            let mut new_buf = jvm.instantiate_array("B", new_capacity).await?;
             jvm.put_field(this, "buf", "[B", new_buf.clone()).await?;
-            jvm.store_byte_array(&mut new_buf, 0, old_values).await?;
-            jvm.destroy(old_buf)?;
+            jvm.destroy(old_buf)?; // temporary before GC
         }
 
         Ok(())
@@ -97,6 +110,7 @@ impl ByteArrayOutputStream {
 
 #[cfg(test)]
 mod test {
+    use alloc::vec;
 
     use bytemuck::cast_vec;
 
@@ -117,7 +131,9 @@ mod test {
 
         let buf = jvm.invoke_virtual(&stream, "toByteArray", "()[B", ()).await?;
 
-        let bytes = jvm.load_byte_array(&buf, 0, 5).await?;
+        let mut bytes = vec![0; 5];
+        jvm.array_raw_buffer(&buf).await?.read(0, &mut bytes)?;
+
         assert_eq!(bytes, cast_vec(b"Hello".to_vec()));
 
         Ok(())

java_runtime/src/classes/java/io/data_input_stream.rs

@@ -1,7 +1,5 @@
 use alloc::{string::String as RustString, vec};
 
-use bytemuck::cast_vec;
-
 use java_class_proto::{JavaFieldProto, JavaMethodProto};
 use jvm::{runtime::JavaLangString, Array, ClassInstanceRef, JavaChar, Jvm, Result};
 
@@ -218,10 +216,11 @@ impl DataInputStream {
         let java_array = jvm.instantiate_array("B", length as _).await?;
         let _: i32 = jvm.invoke_virtual(&this, "read", "([BII)I", (java_array.clone(), 0, length)).await?;
 
-        let bytes = jvm.load_byte_array(&java_array, 0, length as _).await?;
+        let mut buf = vec![0; length as _];
+        jvm.array_raw_buffer(&java_array).await?.read(0, &mut buf)?;
 
         // TODO handle modified utf-8
-        let string = RustString::from_utf8(cast_vec(bytes)).unwrap();
+        let string = RustString::from_utf8(buf).unwrap();
 
         Ok(JavaLangString::from_rust_string(jvm, &string).await?.into())
     }
@@ -257,7 +256,7 @@ mod test {
         let data_len = data.len();
 
         let mut data_array = jvm.instantiate_array("B", data_len).await?;
-        jvm.store_byte_array(&mut data_array, 0, data).await?;
+        jvm.array_raw_buffer_mut(&mut data_array).await?.write(0, &data)?;
 
         let input_stream = jvm.new_class("java/io/ByteArrayInputStream", "([B)V", (data_array,)).await?;
         let data_input_stream = jvm
@@ -299,7 +298,7 @@ mod test {
         let data_len = data.len();
 
         let mut data_array = jvm.instantiate_array("B", data_len).await?;
-        jvm.store_byte_array(&mut data_array, 0, data).await?;
+        jvm.array_raw_buffer_mut(&mut data_array).await?.write(0, &data)?;
 
         let input_stream = jvm.new_class("java/io/ByteArrayInputStream", "([B)V", (data_array,)).await?;
         let data_input_stream = jvm

java_runtime/src/classes/java/io/data_output_stream.rs

@@ -53,7 +53,7 @@ impl DataOutputStream {
 
         let bytes = i.to_be_bytes();
         let mut byte_array = jvm.instantiate_array("B", bytes.len() as _).await?;
-        jvm.store_byte_array(&mut byte_array, 0, cast_vec(bytes.to_vec())).await?;
+        jvm.store_array(&mut byte_array, 0, cast_vec::<u8, i8>(bytes.to_vec())).await?;
 
         let out = jvm.get_field(&this, "out", "Ljava/io/OutputStream;").await?;
         let _: () = jvm.invoke_virtual(&out, "write", "([B)V", (byte_array,)).await?;
@@ -66,7 +66,7 @@ impl DataOutputStream {
 
         let bytes = l.to_be_bytes();
         let mut byte_array = jvm.instantiate_array("B", bytes.len() as _).await?;
-        jvm.store_byte_array(&mut byte_array, 0, cast_vec(bytes.to_vec())).await?;
+        jvm.store_array(&mut byte_array, 0, cast_vec::<u8, i8>(bytes.to_vec())).await?;
 
         let out = jvm.get_field(&this, "out", "Ljava/io/OutputStream;").await?;
         let _: () = jvm.invoke_virtual(&out, "write", "([B)V", (byte_array,)).await?;
@@ -99,7 +99,6 @@ impl DataOutputStream {
 mod test {
     use alloc::vec;
 
-    use bytemuck::cast_vec;
     use jvm::{runtime::JavaLangString, Result};
 
     use crate::test::test_jvm;
@@ -122,10 +121,13 @@ mod test {
         let _: () = jvm.invoke_virtual(&data_output_stream, "writeLong", "(J)V", (123412341324i64,)).await?;
 
         let bytes = jvm.invoke_virtual(&stream, "toByteArray", "()[B", ()).await?;
-        let bytes = jvm.load_byte_array(&bytes, 0, jvm.array_length(&bytes).await? as _).await?;
+
+        let length = jvm.array_length(&bytes).await?;
+        let mut buf = vec![0; length];
+        jvm.array_raw_buffer(&bytes).await?.read(0, &mut buf)?;
 
         assert_eq!(
-            cast_vec::<i8, u8>(bytes),
+            buf,
             vec![
                 1, b'h', b'e', b'l', b'l', b'o', b',', b' ', b'w', b'o', b'r', b'l', b'd', 0, 0xbc, 0x4f, 0xf2, 0, 0, 0, 0x1c, 0xbb, 0xf2, 0xe2, 0x4c
             ]

java_runtime/src/classes/java/io/file_input_stream.rs

@@ -1,6 +1,7 @@
 use alloc::vec;
 
 use bytemuck::cast_vec;
+
 use java_class_proto::{JavaFieldProto, JavaMethodProto};
 use jvm::{runtime::JavaLangString, Array, ClassInstanceRef, Jvm, Result};
 
@@ -58,7 +59,7 @@ impl FileInputStream {
             return Ok(-1);
         }
 
-        jvm.store_byte_array(&mut buf, 0, cast_vec(rust_buf)).await?;
+        jvm.store_array(&mut buf, 0, cast_vec::<u8, i8>(rust_buf)).await?;
 
         Ok(read as _)
     }

java_runtime/src/classes/java/io/file_output_stream.rs

@@ -84,7 +84,8 @@ impl FileOutputStream {
         let fd = jvm.get_field(&this, "fd", "Ljava/io/FileDescriptor;").await?;
         let mut file = FileDescriptor::file(jvm, fd).await?;
 
-        let buf = jvm.load_byte_array(&buffer, offset as _, length as _).await?;
+        let mut buf = vec![0; length as _];
+        jvm.array_raw_buffer(&buffer).await?.read(offset as _, &mut buf).unwrap();
 
         file.write(cast_slice(&buf)).await.unwrap();
 

java_runtime/src/classes/java/io/input_stream_reader.rs

@@ -110,7 +110,8 @@ impl InputStreamReader {
             }
 
             let read_buf_size: i32 = jvm.get_field(&this, "readBufSize", "I").await?;
-            let read_buf_data = jvm.load_byte_array(&read_buf, 0, read_buf_size as _).await?;
+            let mut read_buf_data = vec![0; read_buf_size as _];
+            jvm.array_raw_buffer(&read_buf).await?.read(0, &mut read_buf_data).unwrap();
 
             let decoder: Arc<Mutex<Decoder>> = jvm.get_rust_object_field(&this, "decoder").await?;
 
@@ -182,8 +183,6 @@ impl InputStreamReader {
 mod test {
     use alloc::{vec, vec::Vec};
 
-    use bytemuck::cast_vec;
-
     use jvm::{JavaChar, Result};
 
     use crate::test::test_jvm;
@@ -193,7 +192,7 @@ mod test {
         let jvm = test_jvm().await?;
 
         let mut buffer = jvm.instantiate_array("B", 11).await?;
-        jvm.store_byte_array(&mut buffer, 0, cast_vec(b"Hello\nWorld".to_vec())).await?;
+        jvm.array_raw_buffer_mut(&mut buffer).await?.write(0, b"Hello\nWorld")?;
 
         let is = jvm.new_class("java/io/ByteArrayInputStream", "([B)V", (buffer,)).await?;
         let isr = jvm.new_class("java/io/InputStreamReader", "(Ljava/io/InputStream;)V", (is,)).await?;

java_runtime/src/classes/java/io/output_stream.rs

@@ -52,7 +52,8 @@ impl OutputStream {
     ) -> Result<()> {
         tracing::debug!("java.io.OutputStream::write({:?}, {:?}, {:?}, {:?})", &this, &buffer, &offset, &length);
 
-        let bytes = jvm.load_byte_array(&buffer, offset as _, length as _).await?;
+        let mut bytes = vec![0; length as usize];
+        jvm.array_raw_buffer(&buffer).await?.read(offset as _, &mut bytes)?;
         for byte in bytes {
             let _: () = jvm.invoke_virtual(&this, "write", "(I)V", (byte as i32,)).await?;
         }

java_runtime/src/classes/java/io/print_stream.rs

@@ -1,7 +1,5 @@
 use alloc::{format, string::ToString, vec};
 
-use bytemuck::cast_vec;
-
 use java_class_proto::JavaMethodProto;
 use jvm::{runtime::JavaLangString, ClassInstanceRef, JavaChar, Jvm, Result};
 
@@ -62,7 +60,7 @@ impl PrintStream {
         let bytes = result.into_bytes();
 
         let mut string_bytes = jvm.instantiate_array("B", bytes.len()).await?;
-        jvm.store_byte_array(&mut string_bytes, 0, cast_vec(bytes)).await?;
+        jvm.array_raw_buffer_mut(&mut string_bytes).await?.write(0, &bytes)?;
 
         let _: () = jvm.invoke_virtual(&this, "write", "([B)V", (string_bytes,)).await?;
 
@@ -81,7 +79,7 @@ impl PrintStream {
         let bytes = result.into_bytes();
 
         let mut string_bytes = jvm.instantiate_array("B", bytes.len()).await?;
-        jvm.store_byte_array(&mut string_bytes, 0, cast_vec(bytes)).await?;
+        jvm.array_raw_buffer_mut(&mut string_bytes).await?.write(0, &bytes)?;
 
         let _: () = jvm.invoke_virtual(&this, "write", "([B)V", (string_bytes,)).await?;