1use alloc::{vec, vec::Vec};
2
3use bytemuck::cast_vec;
4
5use jvm::{Array, ClassInstanceRef, JavaChar, Jvm, Result};
6use jvm_class_proto::JavaMethodProto;
7use jvm_types::{ClassAccessFlags, MethodAccessFlags, modified_utf8};
8
9use crate::{
10 RuntimeClassProto, RuntimeContext,
11 classes::java::{io::OutputStream, lang::String},
12};
13
14pub struct DataOutputStream;
16
17impl DataOutputStream {
18 pub fn as_proto() -> RuntimeClassProto {
19 RuntimeClassProto {
20 name: "java/io/DataOutputStream",
21 parent_class: Some("java/io/FilterOutputStream"),
22 interfaces: vec!["java/io/DataOutput"],
23 methods: vec![
24 JavaMethodProto::new("<init>", "(Ljava/io/OutputStream;)V", Self::init, MethodAccessFlags::PUBLIC),
25 JavaMethodProto::new("write", "(I)V", Self::write, MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED),
26 JavaMethodProto::new(
27 "writeByte",
28 "(I)V",
29 Self::write_byte,
30 MethodAccessFlags::PUBLIC | MethodAccessFlags::FINAL,
31 ),
32 JavaMethodProto::new(
33 "writeBoolean",
34 "(Z)V",
35 Self::write_boolean,
36 MethodAccessFlags::PUBLIC | MethodAccessFlags::FINAL,
37 ),
38 JavaMethodProto::new("writeInt", "(I)V", Self::write_int, MethodAccessFlags::PUBLIC | MethodAccessFlags::FINAL),
39 JavaMethodProto::new(
40 "writeShort",
41 "(I)V",
42 Self::write_short,
43 MethodAccessFlags::PUBLIC | MethodAccessFlags::FINAL,
44 ),
45 JavaMethodProto::new(
46 "writeChar",
47 "(I)V",
48 Self::write_char,
49 MethodAccessFlags::PUBLIC | MethodAccessFlags::FINAL,
50 ),
51 JavaMethodProto::new(
52 "writeLong",
53 "(J)V",
54 Self::write_long,
55 MethodAccessFlags::PUBLIC | MethodAccessFlags::FINAL,
56 ),
57 JavaMethodProto::new(
58 "writeFloat",
59 "(F)V",
60 Self::write_float,
61 MethodAccessFlags::PUBLIC | MethodAccessFlags::FINAL,
62 ),
63 JavaMethodProto::new(
64 "writeDouble",
65 "(D)V",
66 Self::write_double,
67 MethodAccessFlags::PUBLIC | MethodAccessFlags::FINAL,
68 ),
69 JavaMethodProto::new(
70 "writeBytes",
71 "(Ljava/lang/String;)V",
72 Self::write_bytes,
73 MethodAccessFlags::PUBLIC | MethodAccessFlags::FINAL,
74 ),
75 JavaMethodProto::new(
76 "writeChars",
77 "(Ljava/lang/String;)V",
78 Self::write_chars,
79 MethodAccessFlags::PUBLIC | MethodAccessFlags::FINAL,
80 ),
81 JavaMethodProto::new(
82 "writeUTF",
83 "(Ljava/lang/String;)V",
84 Self::write_utf,
85 MethodAccessFlags::PUBLIC | MethodAccessFlags::FINAL,
86 ),
87 JavaMethodProto::new("close", "()V", Self::close, MethodAccessFlags::PUBLIC),
88 JavaMethodProto::new("flush", "()V", Self::flush, MethodAccessFlags::PUBLIC),
89 ],
90 fields: vec![],
91 access_flags: ClassAccessFlags::PUBLIC,
92 }
93 }
94
95 async fn init(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, out: ClassInstanceRef<OutputStream>) -> Result<()> {
96 tracing::debug!("java.io.DataOutputStream::<init>({this:?}, {out:?})");
97
98 let _: () = jvm
99 .invoke_special(&this, "java/io/FilterOutputStream", "<init>", "(Ljava/io/OutputStream;)V", (out,))
100 .await?;
101
102 Ok(())
103 }
104
105 async fn write(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, b: i32) -> Result<()> {
106 tracing::debug!("java.io.DataOutputStream::write({this:?}, {b:?})");
107
108 let out: ClassInstanceRef<OutputStream> = jvm.get_field(&this, "java/io/DataOutputStream", "out", "Ljava/io/OutputStream;").await?;
109 if out.is_null() {
110 return Err(jvm.exception("java/lang/NullPointerException", "underlying stream is null").await);
111 }
112 let _: () = jvm.invoke_virtual(&out, "java/io/OutputStream", "write", "(I)V", (b,)).await?;
113
114 Ok(())
115 }
116
117 async fn write_byte(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, v: i32) -> Result<()> {
118 tracing::debug!("java.io.DataOutputStream::writeByte({this:?}, {v:?})");
119
120 let out: ClassInstanceRef<OutputStream> = jvm.get_field(&this, "java/io/DataOutputStream", "out", "Ljava/io/OutputStream;").await?;
121 if out.is_null() {
122 return Err(jvm.exception("java/lang/NullPointerException", "underlying stream is null").await);
123 }
124 let _: () = jvm.invoke_virtual(&out, "java/io/OutputStream", "write", "(I)V", (v,)).await?;
125
126 Ok(())
127 }
128
129 async fn write_boolean(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, v: bool) -> Result<()> {
130 tracing::debug!("java.io.DataOutputStream::writeBoolean({this:?}, {v:?})");
131
132 let _: () = jvm
133 .invoke_virtual(&this, "java/io/DataOutputStream", "writeByte", "(I)V", (v as i32,))
134 .await?;
135
136 Ok(())
137 }
138
139 async fn write_short(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, s: i32) -> Result<()> {
140 tracing::debug!("java.io.DataOutputStream::writeShort({this:?}, {s:?})");
141
142 let bytes = (s as i16).to_be_bytes();
143 let mut byte_array = jvm.instantiate_array("B", bytes.len() as _).await?;
144 jvm.store_array(&mut byte_array, 0, cast_vec::<u8, i8>(bytes.to_vec())).await?;
145
146 let out: ClassInstanceRef<OutputStream> = jvm.get_field(&this, "java/io/DataOutputStream", "out", "Ljava/io/OutputStream;").await?;
147 if out.is_null() {
148 return Err(jvm.exception("java/lang/NullPointerException", "underlying stream is null").await);
149 }
150 let _: () = jvm.invoke_virtual(&out, "java/io/OutputStream", "write", "([B)V", (byte_array,)).await?;
151
152 Ok(())
153 }
154
155 async fn write_char(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, value: i32) -> Result<()> {
156 tracing::debug!("java.io.DataOutputStream::writeChar({this:?}, {value:?})");
157 jvm.invoke_virtual(&this, "java/io/DataOutputStream", "writeShort", "(I)V", (value & 0xffff,))
158 .await
159 }
160
161 async fn write_int(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, i: i32) -> Result<()> {
162 tracing::debug!("java.io.DataOutputStream::writeInt({this:?}, {i:?})");
163
164 let bytes = i.to_be_bytes();
165 let mut byte_array = jvm.instantiate_array("B", bytes.len() as _).await?;
166 jvm.store_array(&mut byte_array, 0, cast_vec::<u8, i8>(bytes.to_vec())).await?;
167
168 let out: ClassInstanceRef<OutputStream> = jvm.get_field(&this, "java/io/DataOutputStream", "out", "Ljava/io/OutputStream;").await?;
169 if out.is_null() {
170 return Err(jvm.exception("java/lang/NullPointerException", "underlying stream is null").await);
171 }
172 let _: () = jvm.invoke_virtual(&out, "java/io/OutputStream", "write", "([B)V", (byte_array,)).await?;
173
174 Ok(())
175 }
176
177 async fn write_long(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, l: i64) -> Result<()> {
178 tracing::debug!("java.io.DataOutputStream::writeLong({this:?}, {l:?})");
179
180 let bytes = l.to_be_bytes();
181 let mut byte_array = jvm.instantiate_array("B", bytes.len() as _).await?;
182 jvm.store_array(&mut byte_array, 0, cast_vec::<u8, i8>(bytes.to_vec())).await?;
183
184 let out: ClassInstanceRef<OutputStream> = jvm.get_field(&this, "java/io/DataOutputStream", "out", "Ljava/io/OutputStream;").await?;
185 if out.is_null() {
186 return Err(jvm.exception("java/lang/NullPointerException", "underlying stream is null").await);
187 }
188 let _: () = jvm.invoke_virtual(&out, "java/io/OutputStream", "write", "([B)V", (byte_array,)).await?;
189
190 Ok(())
191 }
192
193 async fn write_float(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, value: f32) -> Result<()> {
194 tracing::debug!("java.io.DataOutputStream::writeFloat({this:?}, {value:?})");
195 jvm.invoke_virtual(&this, "java/io/DataOutputStream", "writeInt", "(I)V", (value.to_bits() as i32,))
196 .await
197 }
198
199 async fn write_double(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, value: f64) -> Result<()> {
200 tracing::debug!("java.io.DataOutputStream::writeDouble({this:?}, {value:?})");
201 jvm.invoke_virtual(&this, "java/io/DataOutputStream", "writeLong", "(J)V", (value.to_bits() as i64,))
202 .await
203 }
204
205 async fn write_bytes(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, s: ClassInstanceRef<String>) -> Result<()> {
206 tracing::debug!("java.io.DataOutputStream::writeBytes({this:?}, {s:?})");
207 if s.is_null() {
208 return Err(jvm.exception("java/lang/NullPointerException", "argument is null").await);
209 }
210
211 let chars: ClassInstanceRef<Array<JavaChar>> = jvm.invoke_virtual(&s, "java/lang/String", "toCharArray", "()[C", ()).await?;
212 let length = jvm.array_length(&chars).await?;
213 let chars: Vec<JavaChar> = jvm.load_array(&chars, 0, length).await?;
214 if chars.is_empty() {
215 return Ok(());
216 }
217 let mut bytes = jvm.instantiate_array("B", chars.len()).await?;
218 jvm.store_array(&mut bytes, 0, chars.into_iter().map(|value| value as i8)).await?;
219
220 let out: ClassInstanceRef<OutputStream> = jvm.get_field(&this, "java/io/DataOutputStream", "out", "Ljava/io/OutputStream;").await?;
221 if out.is_null() {
222 return Err(jvm.exception("java/lang/NullPointerException", "underlying stream is null").await);
223 }
224 jvm.invoke_virtual(&out, "java/io/OutputStream", "write", "([B)V", (bytes,)).await
225 }
226
227 async fn write_chars(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, s: ClassInstanceRef<String>) -> Result<()> {
228 tracing::debug!("java.io.DataOutputStream::writeChars({this:?}, {s:?})");
229 if s.is_null() {
230 return Err(jvm.exception("java/lang/NullPointerException", "argument is null").await);
231 }
232
233 let chars: ClassInstanceRef<Array<JavaChar>> = jvm.invoke_virtual(&s, "java/lang/String", "toCharArray", "()[C", ()).await?;
234 let length = jvm.array_length(&chars).await?;
235 let chars: Vec<JavaChar> = jvm.load_array(&chars, 0, length).await?;
236 if chars.is_empty() {
237 return Ok(());
238 }
239 let mut data = Vec::with_capacity(chars.len() * 2);
240 for value in chars {
241 data.push((value >> 8) as i8);
242 data.push(value as i8);
243 }
244
245 let mut bytes = jvm.instantiate_array("B", data.len()).await?;
246 jvm.store_array(&mut bytes, 0, data).await?;
247
248 let out: ClassInstanceRef<OutputStream> = jvm.get_field(&this, "java/io/DataOutputStream", "out", "Ljava/io/OutputStream;").await?;
249 if out.is_null() {
250 return Err(jvm.exception("java/lang/NullPointerException", "underlying stream is null").await);
251 }
252 jvm.invoke_virtual(&out, "java/io/OutputStream", "write", "([B)V", (bytes,)).await
253 }
254
255 async fn write_utf(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, s: ClassInstanceRef<String>) -> Result<()> {
256 tracing::debug!("java.io.DataOutputStream::writeUTF({this:?}, {s:?})");
257 if s.is_null() {
258 return Err(jvm.exception("java/lang/NullPointerException", "argument is null").await);
259 }
260
261 let chars: ClassInstanceRef<Array<JavaChar>> = jvm.invoke_virtual(&s, "java/lang/String", "toCharArray", "()[C", ()).await?;
262 let length = jvm.array_length(&chars).await?;
263 let chars: Vec<JavaChar> = jvm.load_array(&chars, 0, length).await?;
264 let data: Vec<i8> = cast_vec(modified_utf8::encode(&chars));
265
266 if data.len() > u16::MAX as usize {
267 return Err(jvm.exception("java/io/UTFDataFormatException", "encoded string is too long").await);
268 }
269
270 let _: () = jvm
271 .invoke_virtual(&this, "java/io/DataOutputStream", "writeShort", "(I)V", (data.len() as i32,))
272 .await?;
273
274 let mut bytes = jvm.instantiate_array("B", data.len()).await?;
275 jvm.store_array(&mut bytes, 0, data).await?;
276
277 let out: ClassInstanceRef<OutputStream> = jvm.get_field(&this, "java/io/DataOutputStream", "out", "Ljava/io/OutputStream;").await?;
278 if out.is_null() {
279 return Err(jvm.exception("java/lang/NullPointerException", "underlying stream is null").await);
280 }
281 jvm.invoke_virtual(&out, "java/io/OutputStream", "write", "([B)V", (bytes,)).await
282 }
283
284 async fn close(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<()> {
285 tracing::debug!("java.io.DataOutputStream::close({this:?})");
286
287 let out: ClassInstanceRef<OutputStream> = jvm.get_field(&this, "java/io/DataOutputStream", "out", "Ljava/io/OutputStream;").await?;
288 if out.is_null() {
289 return Err(jvm.exception("java/lang/NullPointerException", "underlying stream is null").await);
290 }
291 let _: () = jvm.invoke_virtual(&out, "java/io/OutputStream", "close", "()V", []).await?;
292
293 Ok(())
294 }
295
296 async fn flush(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<()> {
297 tracing::debug!("java.io.DataOutputStream::flush({this:?})");
298
299 let out: ClassInstanceRef<OutputStream> = jvm.get_field(&this, "java/io/DataOutputStream", "out", "Ljava/io/OutputStream;").await?;
300 if out.is_null() {
301 return Err(jvm.exception("java/lang/NullPointerException", "underlying stream is null").await);
302 }
303 let _: () = jvm.invoke_virtual(&out, "java/io/OutputStream", "flush", "()V", []).await?;
304
305 Ok(())
306 }
307}