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
12pub 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}