Skip to main content

rustjava_runtime/classes/java/io/
data_output_stream.rs

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
14// class java.io.DataOutputStream
15pub 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}