Skip to main content

rustjava_runtime/classes/java/io/
byte_array_output_stream.rs

1use alloc::vec;
2
3use jvm::{Array, ClassInstanceRef, Jvm, Result};
4use jvm_class_proto::{JavaFieldProto, JavaMethodProto};
5use jvm_types::{ClassAccessFlags, FieldAccessFlags, MethodAccessFlags};
6
7use crate::{
8    RuntimeClassProto, RuntimeContext,
9    classes::java::{io::OutputStream, lang::String},
10};
11
12// class java.io.ByteArrayOutputStream
13pub struct ByteArrayOutputStream;
14
15impl ByteArrayOutputStream {
16    pub fn as_proto() -> RuntimeClassProto {
17        RuntimeClassProto {
18            name: "java/io/ByteArrayOutputStream",
19            parent_class: Some("java/io/OutputStream"),
20            interfaces: vec![],
21            methods: vec![
22                JavaMethodProto::new("<init>", "()V", Self::init, MethodAccessFlags::PUBLIC),
23                JavaMethodProto::new("<init>", "(I)V", Self::init_with_size, MethodAccessFlags::PUBLIC),
24                JavaMethodProto::new("write", "(I)V", Self::write, MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED),
25                JavaMethodProto::new(
26                    "write",
27                    "([BII)V",
28                    Self::write_bytes,
29                    MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED,
30                ),
31                JavaMethodProto::new(
32                    "writeTo",
33                    "(Ljava/io/OutputStream;)V",
34                    Self::write_to,
35                    MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED,
36                ),
37                JavaMethodProto::new(
38                    "toByteArray",
39                    "()[B",
40                    Self::to_byte_array,
41                    MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED,
42                ),
43                JavaMethodProto::new(
44                    "toString",
45                    "()Ljava/lang/String;",
46                    Self::to_string,
47                    MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED,
48                ),
49                JavaMethodProto::new(
50                    "toString",
51                    "(Ljava/lang/String;)Ljava/lang/String;",
52                    Self::to_string_with_encoding,
53                    MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED,
54                ),
55                JavaMethodProto::new("size", "()I", Self::size, MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED),
56                JavaMethodProto::new("reset", "()V", Self::reset, MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED),
57                JavaMethodProto::new("close", "()V", Self::close, MethodAccessFlags::PUBLIC),
58            ],
59            fields: vec![
60                JavaFieldProto::new("buf", "[B", FieldAccessFlags::PROTECTED),
61                JavaFieldProto::new("count", "I", FieldAccessFlags::PROTECTED),
62            ],
63            access_flags: ClassAccessFlags::PUBLIC,
64        }
65    }
66
67    async fn init(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<()> {
68        tracing::debug!("java.io.ByteArrayOutputStream::<init>({this:?})");
69
70        let _: () = jvm
71            .invoke_special(&this, "java/io/ByteArrayOutputStream", "<init>", "(I)V", (32,))
72            .await?;
73
74        Ok(())
75    }
76
77    async fn init_with_size(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>, size: i32) -> Result<()> {
78        tracing::debug!("java.io.ByteArrayOutputStream::<init>({this:?}, {size:?})");
79
80        if size < 0 {
81            return Err(jvm.exception("java/lang/IllegalArgumentException", "Negative initial size").await);
82        }
83
84        let _: () = jvm.invoke_special(&this, "java/io/OutputStream", "<init>", "()V", ()).await?;
85
86        let array = jvm.instantiate_array("B", size as usize).await?;
87
88        jvm.put_field(&mut this, "java/io/ByteArrayOutputStream", "buf", "[B", array).await?;
89        jvm.put_field(&mut this, "java/io/ByteArrayOutputStream", "count", "I", 0).await?;
90
91        Ok(())
92    }
93
94    async fn write_bytes(
95        jvm: &Jvm,
96        _: &mut RuntimeContext,
97        mut this: ClassInstanceRef<Self>,
98        bytes: ClassInstanceRef<Array<i8>>,
99        off: i32,
100        len: i32,
101    ) -> Result<()> {
102        tracing::debug!("java.io.ByteArrayOutputStream::write({this:?}, {bytes:?}, {off}, {len})");
103
104        if bytes.is_null() {
105            return Err(jvm.exception("java/lang/NullPointerException", "buffer is null").await);
106        }
107        let length = jvm.array_length(&bytes).await? as i32;
108        if off < 0 || len < 0 || off > length - len {
109            return Err(jvm.exception("java/lang/IndexOutOfBoundsException", "Invalid offset or length").await);
110        }
111
112        let count: i32 = jvm.get_field(&this, "java/io/ByteArrayOutputStream", "count", "I").await?;
113        Self::ensure_capacity(jvm, &mut this, (count + len) as usize).await?;
114        let mut buf = jvm.get_field(&this, "java/io/ByteArrayOutputStream", "buf", "[B").await?;
115        let mut values = vec![0; len as usize];
116        jvm.array_raw_buffer(&bytes).await?.read(off as usize, &mut values)?;
117        jvm.array_raw_buffer_mut(&mut buf).await?.write(count as usize, &values)?;
118        jvm.put_field(&mut this, "java/io/ByteArrayOutputStream", "count", "I", count + len).await
119    }
120
121    async fn write(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>, b: i32) -> Result<()> {
122        tracing::debug!("java.io.ByteArrayOutputStream::write({this:?}, {b:?})");
123
124        let count: i32 = jvm.get_field(&this, "java/io/ByteArrayOutputStream", "count", "I").await?;
125        Self::ensure_capacity(jvm, &mut this, (count + 1) as _).await?;
126
127        let mut buf = jvm.get_field(&this, "java/io/ByteArrayOutputStream", "buf", "[B").await?;
128        jvm.store_array(&mut buf, count as _, vec![b as i8]).await?;
129
130        jvm.put_field(&mut this, "java/io/ByteArrayOutputStream", "count", "I", count + 1).await?;
131
132        Ok(())
133    }
134
135    async fn write_to(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, out: ClassInstanceRef<OutputStream>) -> Result<()> {
136        tracing::debug!("java.io.ByteArrayOutputStream::writeTo({this:?}, {out:?})");
137
138        if out.is_null() {
139            return Err(jvm.exception("java/lang/NullPointerException", "output is null").await);
140        }
141
142        let buf: ClassInstanceRef<Array<i8>> = jvm.get_field(&this, "java/io/ByteArrayOutputStream", "buf", "[B").await?;
143        let count: i32 = jvm.get_field(&this, "java/io/ByteArrayOutputStream", "count", "I").await?;
144        jvm.invoke_virtual(&out, "java/io/OutputStream", "write", "([BII)V", (buf, 0, count))
145            .await
146    }
147
148    async fn to_byte_array(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Array<i8>>> {
149        tracing::debug!("java.io.ByteArrayOutputStream::to_byte_array({this:?})");
150
151        let buf: ClassInstanceRef<Array<i8>> = jvm.get_field(&this, "java/io/ByteArrayOutputStream", "buf", "[B").await?;
152        let count: i32 = jvm.get_field(&this, "java/io/ByteArrayOutputStream", "count", "I").await?;
153
154        let dest = jvm.instantiate_array("B", count as _).await?;
155        let _: () = jvm
156            .invoke_static(
157                "java/lang/System",
158                "arraycopy",
159                "(Ljava/lang/Object;ILjava/lang/Object;II)V",
160                (buf.clone(), 0, dest.clone(), 0, count),
161            )
162            .await?;
163
164        Ok(dest.into())
165    }
166
167    async fn size(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<i32> {
168        tracing::debug!("java.io.ByteArrayOutputStream::size({this:?})");
169
170        let count: i32 = jvm.get_field(&this, "java/io/ByteArrayOutputStream", "count", "I").await?;
171
172        Ok(count)
173    }
174
175    async fn to_string(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<String>> {
176        tracing::debug!("java.io.ByteArrayOutputStream::toString({this:?})");
177        let buf: ClassInstanceRef<Array<i8>> = jvm.get_field(&this, "java/io/ByteArrayOutputStream", "buf", "[B").await?;
178        let count: i32 = jvm.get_field(&this, "java/io/ByteArrayOutputStream", "count", "I").await?;
179        let bytes = jvm.instantiate_array("B", count as usize).await?;
180        let _: () = jvm
181            .invoke_static(
182                "java/lang/System",
183                "arraycopy",
184                "(Ljava/lang/Object;ILjava/lang/Object;II)V",
185                (buf, 0, bytes.clone(), 0, count),
186            )
187            .await?;
188        Ok(jvm.new_class("java/lang/String", "([B)V", (bytes,)).await?.into())
189    }
190
191    async fn to_string_with_encoding(
192        jvm: &Jvm,
193        _: &mut RuntimeContext,
194        this: ClassInstanceRef<Self>,
195        encoding: ClassInstanceRef<String>,
196    ) -> Result<ClassInstanceRef<String>> {
197        tracing::debug!("java.io.ByteArrayOutputStream::toString({this:?}, {encoding:?})");
198
199        if encoding.is_null() {
200            return Err(jvm.exception("java/lang/NullPointerException", "encoding is null").await);
201        }
202
203        let buf: ClassInstanceRef<Array<i8>> = jvm.get_field(&this, "java/io/ByteArrayOutputStream", "buf", "[B").await?;
204        let count: i32 = jvm.get_field(&this, "java/io/ByteArrayOutputStream", "count", "I").await?;
205        Ok(jvm
206            .new_class("java/lang/String", "([BIILjava/lang/String;)V", (buf, 0, count, encoding))
207            .await?
208            .into())
209    }
210
211    async fn reset(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>) -> Result<()> {
212        tracing::debug!("java.io.ByteArrayOutputStream::reset({this:?})");
213
214        jvm.put_field(&mut this, "java/io/ByteArrayOutputStream", "count", "I", 0).await?;
215
216        Ok(())
217    }
218
219    async fn close(_jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<()> {
220        tracing::debug!("java.io.ByteArrayOutputStream::close({this:?})");
221
222        Ok(())
223    }
224
225    async fn ensure_capacity(jvm: &Jvm, this: &mut ClassInstanceRef<Self>, capacity: usize) -> Result<()> {
226        let old_buf = jvm.get_field(this, "java/io/ByteArrayOutputStream", "buf", "[B").await?;
227        let current_capacity = jvm.array_length(&old_buf).await?;
228
229        if current_capacity < capacity {
230            let new_capacity = current_capacity.saturating_mul(2).max(capacity);
231            let new_buf = jvm.instantiate_array("B", new_capacity).await?;
232            let count: i32 = jvm.get_field(this, "java/io/ByteArrayOutputStream", "count", "I").await?;
233
234            let _: () = jvm
235                .invoke_static(
236                    "java/lang/System",
237                    "arraycopy",
238                    "(Ljava/lang/Object;ILjava/lang/Object;II)V",
239                    (old_buf.clone(), 0, new_buf.clone(), 0, count),
240                )
241                .await?;
242
243            jvm.put_field(this, "java/io/ByteArrayOutputStream", "buf", "[B", new_buf.clone()).await?;
244        }
245
246        Ok(())
247    }
248}