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 = jvm.get_field(&this, "java/io/DataOutputStream", "out", "Ljava/io/OutputStream;").await?;
109        let _: () = jvm.invoke_virtual(&out, "java/io/OutputStream", "write", "(I)V", (b,)).await?;
110
111        Ok(())
112    }
113
114    async fn write_byte(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, v: i32) -> Result<()> {
115        tracing::debug!("java.io.DataOutputStream::writeByte({this:?}, {v:?})");
116
117        let out = jvm.get_field(&this, "java/io/DataOutputStream", "out", "Ljava/io/OutputStream;").await?;
118        let _: () = jvm.invoke_virtual(&out, "java/io/OutputStream", "write", "(I)V", (v,)).await?;
119
120        Ok(())
121    }
122
123    async fn write_boolean(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, v: bool) -> Result<()> {
124        tracing::debug!("java.io.DataOutputStream::writeBoolean({this:?}, {v:?})");
125
126        let _: () = jvm
127            .invoke_virtual(&this, "java/io/DataOutputStream", "writeByte", "(I)V", (v as i32,))
128            .await?;
129
130        Ok(())
131    }
132
133    async fn write_short(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, s: i32) -> Result<()> {
134        tracing::debug!("java.io.DataOutputStream::writeShort({this:?}, {s:?})");
135
136        let bytes = (s as i16).to_be_bytes();
137        let mut byte_array = jvm.instantiate_array("B", bytes.len() as _).await?;
138        jvm.store_array(&mut byte_array, 0, cast_vec::<u8, i8>(bytes.to_vec())).await?;
139
140        let out = jvm.get_field(&this, "java/io/DataOutputStream", "out", "Ljava/io/OutputStream;").await?;
141        let _: () = jvm.invoke_virtual(&out, "java/io/OutputStream", "write", "([B)V", (byte_array,)).await?;
142
143        Ok(())
144    }
145
146    async fn write_char(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, value: i32) -> Result<()> {
147        tracing::debug!("java.io.DataOutputStream::writeChar({this:?}, {value:?})");
148        jvm.invoke_virtual(&this, "java/io/DataOutputStream", "writeShort", "(I)V", (value & 0xffff,))
149            .await
150    }
151
152    async fn write_int(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, i: i32) -> Result<()> {
153        tracing::debug!("java.io.DataOutputStream::writeInt({this:?}, {i:?})");
154
155        let bytes = i.to_be_bytes();
156        let mut byte_array = jvm.instantiate_array("B", bytes.len() as _).await?;
157        jvm.store_array(&mut byte_array, 0, cast_vec::<u8, i8>(bytes.to_vec())).await?;
158
159        let out = jvm.get_field(&this, "java/io/DataOutputStream", "out", "Ljava/io/OutputStream;").await?;
160        let _: () = jvm.invoke_virtual(&out, "java/io/OutputStream", "write", "([B)V", (byte_array,)).await?;
161
162        Ok(())
163    }
164
165    async fn write_long(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, l: i64) -> Result<()> {
166        tracing::debug!("java.io.DataOutputStream::writeLong({this:?}, {l:?})");
167
168        let bytes = l.to_be_bytes();
169        let mut byte_array = jvm.instantiate_array("B", bytes.len() as _).await?;
170        jvm.store_array(&mut byte_array, 0, cast_vec::<u8, i8>(bytes.to_vec())).await?;
171
172        let out = jvm.get_field(&this, "java/io/DataOutputStream", "out", "Ljava/io/OutputStream;").await?;
173        let _: () = jvm.invoke_virtual(&out, "java/io/OutputStream", "write", "([B)V", (byte_array,)).await?;
174
175        Ok(())
176    }
177
178    async fn write_float(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, value: f32) -> Result<()> {
179        tracing::debug!("java.io.DataOutputStream::writeFloat({this:?}, {value:?})");
180        jvm.invoke_virtual(&this, "java/io/DataOutputStream", "writeInt", "(I)V", (value.to_bits() as i32,))
181            .await
182    }
183
184    async fn write_double(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, value: f64) -> Result<()> {
185        tracing::debug!("java.io.DataOutputStream::writeDouble({this:?}, {value:?})");
186        jvm.invoke_virtual(&this, "java/io/DataOutputStream", "writeLong", "(J)V", (value.to_bits() as i64,))
187            .await
188    }
189
190    async fn write_bytes(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, s: ClassInstanceRef<String>) -> Result<()> {
191        tracing::debug!("java.io.DataOutputStream::writeBytes({this:?}, {s:?})");
192
193        let chars: ClassInstanceRef<Array<JavaChar>> = jvm.invoke_virtual(&s, "java/lang/String", "toCharArray", "()[C", ()).await?;
194        let length = jvm.array_length(&chars).await?;
195        let chars: Vec<JavaChar> = jvm.load_array(&chars, 0, length).await?;
196        let mut bytes = jvm.instantiate_array("B", chars.len()).await?;
197        jvm.store_array(&mut bytes, 0, chars.into_iter().map(|value| value as i8)).await?;
198
199        let out = jvm.get_field(&this, "java/io/DataOutputStream", "out", "Ljava/io/OutputStream;").await?;
200        jvm.invoke_virtual(&out, "java/io/OutputStream", "write", "([B)V", (bytes,)).await
201    }
202
203    async fn write_chars(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, s: ClassInstanceRef<String>) -> Result<()> {
204        tracing::debug!("java.io.DataOutputStream::writeChars({this:?}, {s:?})");
205
206        let chars: ClassInstanceRef<Array<JavaChar>> = jvm.invoke_virtual(&s, "java/lang/String", "toCharArray", "()[C", ()).await?;
207        let length = jvm.array_length(&chars).await?;
208        let chars: Vec<JavaChar> = jvm.load_array(&chars, 0, length).await?;
209        let mut data = Vec::with_capacity(chars.len() * 2);
210        for value in chars {
211            data.push((value >> 8) as i8);
212            data.push(value as i8);
213        }
214
215        let mut bytes = jvm.instantiate_array("B", data.len()).await?;
216        jvm.store_array(&mut bytes, 0, data).await?;
217
218        let out = jvm.get_field(&this, "java/io/DataOutputStream", "out", "Ljava/io/OutputStream;").await?;
219        jvm.invoke_virtual(&out, "java/io/OutputStream", "write", "([B)V", (bytes,)).await
220    }
221
222    async fn write_utf(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, s: ClassInstanceRef<String>) -> Result<()> {
223        tracing::debug!("java.io.DataOutputStream::writeUTF({this:?}, {s:?})");
224
225        let chars: ClassInstanceRef<Array<JavaChar>> = jvm.invoke_virtual(&s, "java/lang/String", "toCharArray", "()[C", ()).await?;
226        let length = jvm.array_length(&chars).await?;
227        let chars: Vec<JavaChar> = jvm.load_array(&chars, 0, length).await?;
228        let data: Vec<i8> = cast_vec(modified_utf8::encode(&chars));
229
230        if data.len() > u16::MAX as usize {
231            return Err(jvm.exception("java/io/UTFDataFormatException", "encoded string is too long").await);
232        }
233
234        let _: () = jvm
235            .invoke_virtual(&this, "java/io/DataOutputStream", "writeShort", "(I)V", (data.len() as i32,))
236            .await?;
237
238        let mut bytes = jvm.instantiate_array("B", data.len()).await?;
239        jvm.store_array(&mut bytes, 0, data).await?;
240
241        let out = jvm.get_field(&this, "java/io/DataOutputStream", "out", "Ljava/io/OutputStream;").await?;
242        jvm.invoke_virtual(&out, "java/io/OutputStream", "write", "([B)V", (bytes,)).await
243    }
244
245    async fn close(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<()> {
246        tracing::debug!("java.io.DataOutputStream::close({this:?})");
247
248        let out = jvm.get_field(&this, "java/io/DataOutputStream", "out", "Ljava/io/OutputStream;").await?;
249        let _: () = jvm.invoke_virtual(&out, "java/io/OutputStream", "close", "()V", []).await?;
250
251        Ok(())
252    }
253
254    async fn flush(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<()> {
255        tracing::debug!("java.io.DataOutputStream::flush({this:?})");
256
257        let out = jvm.get_field(&this, "java/io/DataOutputStream", "out", "Ljava/io/OutputStream;").await?;
258        let _: () = jvm.invoke_virtual(&out, "java/io/OutputStream", "flush", "()V", []).await?;
259
260        Ok(())
261    }
262}