Skip to main content

rustjava_runtime/classes/java/io/
print_stream.rs

1use core::future::Future;
2
3use alloc::{vec, vec::Vec};
4
5use jvm::{Array, ClassInstanceRef, JavaChar, JavaError, Jvm, Result, runtime::JavaLangString};
6use jvm_class_proto::{JavaFieldProto, JavaMethodProto};
7use jvm_types::{ClassAccessFlags, FieldAccessFlags, MethodAccessFlags};
8
9use crate::{
10    RuntimeClassProto, RuntimeContext,
11    classes::java::{
12        io::{File, OutputStream, OutputStreamWriter},
13        lang::{Appendable, CharSequence, Object, String},
14        util::{Formatter, Locale, Properties},
15    },
16};
17
18// class java.io.PrintStream
19pub struct PrintStream;
20
21impl PrintStream {
22    pub fn as_proto() -> RuntimeClassProto {
23        RuntimeClassProto {
24            name: "java/io/PrintStream",
25            parent_class: Some("java/io/FilterOutputStream"),
26            interfaces: vec!["java/lang/Appendable", "java/io/Closeable"],
27            methods: vec![
28                JavaMethodProto::new("<init>", "(Ljava/io/OutputStream;)V", Self::init, MethodAccessFlags::PUBLIC),
29                JavaMethodProto::new("<init>", "(Ljava/io/OutputStream;Z)V", Self::init_auto_flush, MethodAccessFlags::PUBLIC),
30                JavaMethodProto::new(
31                    "<init>",
32                    "(Ljava/io/OutputStream;ZLjava/lang/String;)V",
33                    Self::init_auto_flush_encoding,
34                    MethodAccessFlags::PUBLIC,
35                ),
36                JavaMethodProto::new("<init>", "(Ljava/lang/String;)V", Self::init_path, MethodAccessFlags::PUBLIC),
37                JavaMethodProto::new(
38                    "<init>",
39                    "(Ljava/lang/String;Ljava/lang/String;)V",
40                    Self::init_path_encoding,
41                    MethodAccessFlags::PUBLIC,
42                ),
43                JavaMethodProto::new("<init>", "(Ljava/io/File;)V", Self::init_file, MethodAccessFlags::PUBLIC),
44                JavaMethodProto::new(
45                    "<init>",
46                    "(Ljava/io/File;Ljava/lang/String;)V",
47                    Self::init_file_encoding,
48                    MethodAccessFlags::PUBLIC,
49                ),
50                JavaMethodProto::new("checkError", "()Z", Self::check_error, MethodAccessFlags::PUBLIC),
51                JavaMethodProto::new("setError", "()V", Self::set_error, MethodAccessFlags::PROTECTED),
52                JavaMethodProto::new("close", "()V", Self::close, MethodAccessFlags::PUBLIC),
53                JavaMethodProto::new("flush", "()V", Self::flush, MethodAccessFlags::PUBLIC),
54                JavaMethodProto::new("write", "(I)V", Self::write_byte, MethodAccessFlags::PUBLIC),
55                JavaMethodProto::new("write", "([BII)V", Self::write_bytes, MethodAccessFlags::PUBLIC),
56                JavaMethodProto::new("print", "(Ljava/lang/Object;)V", Self::print_object, MethodAccessFlags::PUBLIC),
57                JavaMethodProto::new("print", "(Ljava/lang/String;)V", Self::print_string, MethodAccessFlags::PUBLIC),
58                JavaMethodProto::new("print", "(I)V", Self::print_int, MethodAccessFlags::PUBLIC),
59                JavaMethodProto::new("print", "(J)V", Self::print_long, MethodAccessFlags::PUBLIC),
60                JavaMethodProto::new("print", "(C)V", Self::print_char, MethodAccessFlags::PUBLIC),
61                JavaMethodProto::new("print", "([C)V", Self::print_chars, MethodAccessFlags::PUBLIC),
62                JavaMethodProto::new("print", "(Z)V", Self::print_bool, MethodAccessFlags::PUBLIC),
63                JavaMethodProto::new("print", "(F)V", Self::print_float, MethodAccessFlags::PUBLIC),
64                JavaMethodProto::new("print", "(D)V", Self::print_double, MethodAccessFlags::PUBLIC),
65                JavaMethodProto::new("println", "()V", Self::println, MethodAccessFlags::PUBLIC),
66                JavaMethodProto::new("println", "(Ljava/lang/Object;)V", Self::println_object, MethodAccessFlags::PUBLIC),
67                JavaMethodProto::new("println", "(Ljava/lang/String;)V", Self::println_string, MethodAccessFlags::PUBLIC),
68                JavaMethodProto::new("println", "(I)V", Self::println_int, MethodAccessFlags::PUBLIC),
69                JavaMethodProto::new("println", "(J)V", Self::println_long, MethodAccessFlags::PUBLIC),
70                JavaMethodProto::new("println", "(C)V", Self::println_char, MethodAccessFlags::PUBLIC),
71                JavaMethodProto::new("println", "([C)V", Self::println_chars, MethodAccessFlags::PUBLIC),
72                JavaMethodProto::new("println", "(Z)V", Self::println_bool, MethodAccessFlags::PUBLIC),
73                JavaMethodProto::new("println", "(F)V", Self::println_float, MethodAccessFlags::PUBLIC),
74                JavaMethodProto::new("println", "(D)V", Self::println_double, MethodAccessFlags::PUBLIC),
75                JavaMethodProto::new(
76                    "printf",
77                    "(Ljava/lang/String;[Ljava/lang/Object;)Ljava/io/PrintStream;",
78                    Self::printf,
79                    MethodAccessFlags::PUBLIC | MethodAccessFlags::VARARGS,
80                ),
81                JavaMethodProto::new(
82                    "printf",
83                    "(Ljava/util/Locale;Ljava/lang/String;[Ljava/lang/Object;)Ljava/io/PrintStream;",
84                    Self::printf_with_locale,
85                    MethodAccessFlags::PUBLIC | MethodAccessFlags::VARARGS,
86                ),
87                JavaMethodProto::new(
88                    "format",
89                    "(Ljava/lang/String;[Ljava/lang/Object;)Ljava/io/PrintStream;",
90                    Self::format,
91                    MethodAccessFlags::PUBLIC | MethodAccessFlags::VARARGS,
92                ),
93                JavaMethodProto::new(
94                    "format",
95                    "(Ljava/util/Locale;Ljava/lang/String;[Ljava/lang/Object;)Ljava/io/PrintStream;",
96                    Self::format_with_locale,
97                    MethodAccessFlags::PUBLIC | MethodAccessFlags::VARARGS,
98                ),
99                JavaMethodProto::new(
100                    "append",
101                    "(Ljava/lang/CharSequence;)Ljava/io/PrintStream;",
102                    Self::append_char_sequence,
103                    MethodAccessFlags::PUBLIC,
104                ),
105                JavaMethodProto::new(
106                    "append",
107                    "(Ljava/lang/CharSequence;II)Ljava/io/PrintStream;",
108                    Self::append_char_sequence_range,
109                    MethodAccessFlags::PUBLIC,
110                ),
111                JavaMethodProto::new("append", "(C)Ljava/io/PrintStream;", Self::append_char, MethodAccessFlags::PUBLIC),
112                JavaMethodProto::new(
113                    "append",
114                    "(Ljava/lang/CharSequence;)Ljava/lang/Appendable;",
115                    Self::append_char_sequence,
116                    MethodAccessFlags::PUBLIC | MethodAccessFlags::BRIDGE | MethodAccessFlags::SYNTHETIC,
117                ),
118                JavaMethodProto::new(
119                    "append",
120                    "(Ljava/lang/CharSequence;II)Ljava/lang/Appendable;",
121                    Self::append_char_sequence_range,
122                    MethodAccessFlags::PUBLIC | MethodAccessFlags::BRIDGE | MethodAccessFlags::SYNTHETIC,
123                ),
124                JavaMethodProto::new(
125                    "append",
126                    "(C)Ljava/lang/Appendable;",
127                    Self::append_char,
128                    MethodAccessFlags::PUBLIC | MethodAccessFlags::BRIDGE | MethodAccessFlags::SYNTHETIC,
129                ),
130            ],
131            fields: vec![
132                JavaFieldProto::new("autoFlush", "Z", FieldAccessFlags::PRIVATE),
133                JavaFieldProto::new("trouble", "Z", FieldAccessFlags::PRIVATE),
134                JavaFieldProto::new("charOut", "Ljava/io/OutputStreamWriter;", FieldAccessFlags::PRIVATE),
135                JavaFieldProto::new("closing", "Z", FieldAccessFlags::PRIVATE),
136            ],
137            access_flags: ClassAccessFlags::PUBLIC,
138        }
139    }
140
141    async fn init(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, out: ClassInstanceRef<OutputStream>) -> Result<()> {
142        tracing::debug!("java.io.PrintStream::<init>({this:?}, {out:?})");
143        jvm.invoke_special(&this, "java/io/PrintStream", "<init>", "(Ljava/io/OutputStream;Z)V", (out, false))
144            .await
145    }
146
147    async fn init_auto_flush(
148        jvm: &Jvm,
149        _: &mut RuntimeContext,
150        this: ClassInstanceRef<Self>,
151        out: ClassInstanceRef<OutputStream>,
152        auto_flush: bool,
153    ) -> Result<()> {
154        tracing::debug!("java.io.PrintStream::<init>({this:?}, {out:?}, {auto_flush})");
155
156        let props: ClassInstanceRef<Properties> = jvm.get_static_field("java/lang/System", "props", "Ljava/util/Properties;").await?;
157        let encoding: ClassInstanceRef<String> = if props.is_null() {
158            JavaLangString::from_rust_string(jvm, "UTF-8").await?.into()
159        } else {
160            let key = JavaLangString::from_rust_string(jvm, "file.encoding").await?;
161            let encoding: ClassInstanceRef<String> = jvm
162                .invoke_virtual(
163                    &props,
164                    "java/util/Properties",
165                    "getProperty",
166                    "(Ljava/lang/String;)Ljava/lang/String;",
167                    (key,),
168                )
169                .await?;
170            if encoding.is_null() {
171                JavaLangString::from_rust_string(jvm, "UTF-8").await?.into()
172            } else {
173                encoding
174            }
175        };
176        jvm.invoke_special(
177            &this,
178            "java/io/PrintStream",
179            "<init>",
180            "(Ljava/io/OutputStream;ZLjava/lang/String;)V",
181            (out, auto_flush, encoding),
182        )
183        .await
184    }
185
186    async fn init_auto_flush_encoding(
187        jvm: &Jvm,
188        _: &mut RuntimeContext,
189        mut this: ClassInstanceRef<Self>,
190        out: ClassInstanceRef<OutputStream>,
191        auto_flush: bool,
192        encoding: ClassInstanceRef<String>,
193    ) -> Result<()> {
194        if out.is_null() {
195            return Err(jvm.exception("java/lang/NullPointerException", "output is null").await);
196        }
197        OutputStreamWriter::validate_encoding(jvm, &encoding).await?;
198
199        let _: () = jvm
200            .invoke_special(&this, "java/io/FilterOutputStream", "<init>", "(Ljava/io/OutputStream;)V", (out.clone(),))
201            .await?;
202        let this_output: ClassInstanceRef<OutputStream> = this.instance.clone().into();
203        let char_out = jvm
204            .new_class(
205                "java/io/OutputStreamWriter",
206                "(Ljava/io/OutputStream;Ljava/lang/String;)V",
207                (this_output, encoding),
208            )
209            .await?;
210        jvm.put_field(&mut this, "java/io/PrintStream", "autoFlush", "Z", auto_flush).await?;
211        jvm.put_field(&mut this, "java/io/PrintStream", "trouble", "Z", false).await?;
212        jvm.put_field(&mut this, "java/io/PrintStream", "charOut", "Ljava/io/OutputStreamWriter;", char_out)
213            .await?;
214        jvm.put_field(&mut this, "java/io/PrintStream", "closing", "Z", false).await
215    }
216
217    async fn init_path(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, path: ClassInstanceRef<String>) -> Result<()> {
218        if path.is_null() {
219            return Err(jvm.exception("java/lang/NullPointerException", "file name is null").await);
220        }
221        let file: ClassInstanceRef<File> = jvm.new_class("java/io/File", "(Ljava/lang/String;)V", (path,)).await?.into();
222        jvm.invoke_special(&this, "java/io/PrintStream", "<init>", "(Ljava/io/File;)V", (file,))
223            .await
224    }
225
226    async fn init_path_encoding(
227        jvm: &Jvm,
228        _: &mut RuntimeContext,
229        this: ClassInstanceRef<Self>,
230        path: ClassInstanceRef<String>,
231        encoding: ClassInstanceRef<String>,
232    ) -> Result<()> {
233        if path.is_null() {
234            return Err(jvm.exception("java/lang/NullPointerException", "file name is null").await);
235        }
236        OutputStreamWriter::validate_encoding(jvm, &encoding).await?;
237        let file: ClassInstanceRef<File> = jvm.new_class("java/io/File", "(Ljava/lang/String;)V", (path,)).await?.into();
238        jvm.invoke_special(
239            &this,
240            "java/io/PrintStream",
241            "<init>",
242            "(Ljava/io/File;Ljava/lang/String;)V",
243            (file, encoding),
244        )
245        .await
246    }
247
248    async fn init_file(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, file: ClassInstanceRef<File>) -> Result<()> {
249        if file.is_null() {
250            return Err(jvm.exception("java/lang/NullPointerException", "file is null").await);
251        }
252        let output: ClassInstanceRef<OutputStream> = jvm.new_class("java/io/FileOutputStream", "(Ljava/io/File;)V", (file,)).await?.into();
253        jvm.invoke_special(&this, "java/io/PrintStream", "<init>", "(Ljava/io/OutputStream;)V", (output,))
254            .await
255    }
256
257    async fn init_file_encoding(
258        jvm: &Jvm,
259        _: &mut RuntimeContext,
260        this: ClassInstanceRef<Self>,
261        file: ClassInstanceRef<File>,
262        encoding: ClassInstanceRef<String>,
263    ) -> Result<()> {
264        if file.is_null() {
265            return Err(jvm.exception("java/lang/NullPointerException", "file is null").await);
266        }
267        OutputStreamWriter::validate_encoding(jvm, &encoding).await?;
268        let output: ClassInstanceRef<OutputStream> = jvm.new_class("java/io/FileOutputStream", "(Ljava/io/File;)V", (file,)).await?.into();
269        jvm.invoke_special(
270            &this,
271            "java/io/PrintStream",
272            "<init>",
273            "(Ljava/io/OutputStream;ZLjava/lang/String;)V",
274            (output, false, encoding),
275        )
276        .await
277    }
278
279    async fn with_monitor<T, F>(jvm: &Jvm, this: &ClassInstanceRef<Self>, operation: F) -> Result<T>
280    where
281        F: Future<Output = Result<T>>,
282    {
283        jvm.monitor_enter(this).await?;
284        match operation.await {
285            Ok(value) => {
286                jvm.monitor_exit(this).await?;
287                Ok(value)
288            }
289            Err(error) => {
290                if let Err(exit_error) = jvm.monitor_exit(this).await {
291                    tracing::error!(?exit_error, "failed to release PrintStream monitor");
292                }
293                Err(error)
294            }
295        }
296    }
297
298    async fn check_error(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<bool> {
299        tracing::debug!("java.io.PrintStream::checkError({this:?})");
300
301        Self::with_monitor(jvm, &this, async {
302            let out: ClassInstanceRef<OutputStream> = jvm.get_field(&this, "java/io/PrintStream", "out", "Ljava/io/OutputStream;").await?;
303            if !out.is_null() {
304                let _: () = jvm.invoke_virtual(&this, "java/io/PrintStream", "flush", "()V", ()).await?;
305                if jvm.is_instance(&**out, "java/io/PrintStream") {
306                    return jvm.invoke_virtual(&out, "java/io/PrintStream", "checkError", "()Z", ()).await;
307                }
308            }
309            jvm.get_field(&this, "java/io/PrintStream", "trouble", "Z").await
310        })
311        .await
312    }
313
314    async fn set_error(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>) -> Result<()> {
315        jvm.put_field(&mut this, "java/io/PrintStream", "trouble", "Z", true).await
316    }
317
318    async fn close(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<()> {
319        tracing::debug!("java.io.PrintStream::close({this:?})");
320
321        Self::with_monitor(jvm, &this, async {
322            let out: ClassInstanceRef<OutputStream> = jvm.get_field(&this, "java/io/PrintStream", "out", "Ljava/io/OutputStream;").await?;
323            if out.is_null() || jvm.get_field::<bool>(&this, "java/io/PrintStream", "closing", "Z").await? {
324                return Ok(());
325            }
326
327            let mut this = this.clone();
328            jvm.put_field(&mut this, "java/io/PrintStream", "closing", "Z", true).await?;
329            let char_out: ClassInstanceRef<OutputStreamWriter> = jvm
330                .get_field(&this, "java/io/PrintStream", "charOut", "Ljava/io/OutputStreamWriter;")
331                .await?;
332            let char_out_result = jvm.invoke_virtual(&char_out, "java/io/OutputStreamWriter", "close", "()V", ()).await;
333            let close_out = match char_out_result {
334                Ok(()) => true,
335                Err(JavaError::JavaException(exception)) if jvm.is_instance(&*exception, "java/io/IOException") => {
336                    jvm.put_field(&mut this, "java/io/PrintStream", "trouble", "Z", true).await?;
337                    false
338                }
339                Err(error) => return Err(error),
340            };
341
342            if close_out {
343                match jvm.invoke_virtual(&out, "java/io/OutputStream", "close", "()V", ()).await {
344                    Ok(()) => {}
345                    Err(JavaError::JavaException(exception)) if jvm.is_instance(&*exception, "java/io/IOException") => {
346                        jvm.put_field(&mut this, "java/io/PrintStream", "trouble", "Z", true).await?;
347                    }
348                    Err(error) => return Err(error),
349                }
350            }
351
352            let closed_output: ClassInstanceRef<OutputStream> = None.into();
353            let closed_writer: ClassInstanceRef<OutputStreamWriter> = None.into();
354            jvm.put_field(&mut this, "java/io/PrintStream", "charOut", "Ljava/io/OutputStreamWriter;", closed_writer)
355                .await?;
356            jvm.put_field(&mut this, "java/io/PrintStream", "out", "Ljava/io/OutputStream;", closed_output)
357                .await
358        })
359        .await
360    }
361
362    async fn flush(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<()> {
363        tracing::debug!("java.io.PrintStream::flush({this:?})");
364
365        Self::with_monitor(jvm, &this, async {
366            let out: ClassInstanceRef<OutputStream> = jvm.get_field(&this, "java/io/PrintStream", "out", "Ljava/io/OutputStream;").await?;
367            if out.is_null() {
368                let mut this = this.clone();
369                jvm.put_field(&mut this, "java/io/PrintStream", "trouble", "Z", true).await?;
370                return Ok(());
371            }
372
373            let result = jvm.invoke_virtual(&out, "java/io/OutputStream", "flush", "()V", ()).await;
374            Self::suppress_io_exception(jvm, &this, result).await.map(|_| ())
375        })
376        .await
377    }
378
379    async fn write_byte(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, value: i32) -> Result<()> {
380        tracing::debug!("java.io.PrintStream::write({this:?}, {value})");
381
382        Self::with_monitor(jvm, &this, async {
383            let out: ClassInstanceRef<OutputStream> = jvm.get_field(&this, "java/io/PrintStream", "out", "Ljava/io/OutputStream;").await?;
384            if out.is_null() {
385                let mut this = this.clone();
386                jvm.put_field(&mut this, "java/io/PrintStream", "trouble", "Z", true).await?;
387                return Ok(());
388            }
389
390            let result = jvm.invoke_virtual(&out, "java/io/OutputStream", "write", "(I)V", (value,)).await;
391            if Self::suppress_io_exception(jvm, &this, result).await?
392                && value == b'\n' as i32
393                && jvm.get_field::<bool>(&this, "java/io/PrintStream", "autoFlush", "Z").await?
394            {
395                let result = jvm.invoke_virtual(&out, "java/io/OutputStream", "flush", "()V", ()).await;
396                Self::suppress_io_exception(jvm, &this, result).await?;
397            }
398            Ok(())
399        })
400        .await
401    }
402
403    async fn write_bytes(
404        jvm: &Jvm,
405        _: &mut RuntimeContext,
406        this: ClassInstanceRef<Self>,
407        bytes: ClassInstanceRef<Array<i8>>,
408        off: i32,
409        len: i32,
410    ) -> Result<()> {
411        tracing::debug!("java.io.PrintStream::write({this:?}, {bytes:?}, {off}, {len})");
412
413        Self::with_monitor(jvm, &this, async {
414            if bytes.is_null() {
415                return Err(jvm.exception("java/lang/NullPointerException", "bytes is null").await);
416            }
417            let array_length = jvm.array_length(&bytes).await? as i32;
418            if off < 0 || len < 0 || off > array_length - len {
419                return Err(jvm.exception("java/lang/IndexOutOfBoundsException", "invalid offset or length").await);
420            }
421
422            let out: ClassInstanceRef<OutputStream> = jvm.get_field(&this, "java/io/PrintStream", "out", "Ljava/io/OutputStream;").await?;
423            if out.is_null() {
424                let mut this = this.clone();
425                jvm.put_field(&mut this, "java/io/PrintStream", "trouble", "Z", true).await?;
426                return Ok(());
427            }
428
429            let result = jvm
430                .invoke_virtual(&out, "java/io/OutputStream", "write", "([BII)V", (bytes, off, len))
431                .await;
432            if Self::suppress_io_exception(jvm, &this, result).await? && jvm.get_field::<bool>(&this, "java/io/PrintStream", "autoFlush", "Z").await?
433            {
434                let result = jvm.invoke_virtual(&out, "java/io/OutputStream", "flush", "()V", ()).await;
435                Self::suppress_io_exception(jvm, &this, result).await?;
436            }
437            Ok(())
438        })
439        .await
440    }
441
442    async fn print_object(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, value: ClassInstanceRef<Object>) -> Result<()> {
443        tracing::debug!("java.io.PrintStream::print({this:?}, {value:?})");
444        let value: ClassInstanceRef<String> = jvm
445            .invoke_static("java/lang/String", "valueOf", "(Ljava/lang/Object;)Ljava/lang/String;", (value,))
446            .await?;
447        Self::write_string(jvm, &this, value).await
448    }
449
450    async fn print_string(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, value: ClassInstanceRef<String>) -> Result<()> {
451        tracing::debug!("java.io.PrintStream::print({this:?}, {value:?})");
452        let value = if value.is_null() {
453            JavaLangString::from_rust_string(jvm, "null").await?.into()
454        } else {
455            value
456        };
457        Self::write_string(jvm, &this, value).await
458    }
459
460    async fn print_int(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, value: i32) -> Result<()> {
461        let value: ClassInstanceRef<String> = jvm
462            .invoke_static("java/lang/String", "valueOf", "(I)Ljava/lang/String;", (value,))
463            .await?;
464        Self::write_string(jvm, &this, value).await
465    }
466
467    async fn print_long(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, value: i64) -> Result<()> {
468        let value: ClassInstanceRef<String> = jvm
469            .invoke_static("java/lang/String", "valueOf", "(J)Ljava/lang/String;", (value,))
470            .await?;
471        Self::write_string(jvm, &this, value).await
472    }
473
474    async fn print_char(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, value: JavaChar) -> Result<()> {
475        let mut chars = jvm.instantiate_array("C", 1).await?;
476        jvm.store_array(&mut chars, 0, [value]).await?;
477        Self::write_characters(jvm, &this, chars.into()).await
478    }
479
480    async fn print_chars(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, value: ClassInstanceRef<Array<JavaChar>>) -> Result<()> {
481        Self::write_characters(jvm, &this, value).await
482    }
483
484    async fn print_bool(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, value: bool) -> Result<()> {
485        let value: ClassInstanceRef<String> = jvm
486            .invoke_static("java/lang/String", "valueOf", "(Z)Ljava/lang/String;", (value,))
487            .await?;
488        Self::write_string(jvm, &this, value).await
489    }
490
491    async fn print_float(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, value: f32) -> Result<()> {
492        let value: ClassInstanceRef<String> = jvm
493            .invoke_static("java/lang/String", "valueOf", "(F)Ljava/lang/String;", (value,))
494            .await?;
495        Self::write_string(jvm, &this, value).await
496    }
497
498    async fn print_double(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, value: f64) -> Result<()> {
499        let value: ClassInstanceRef<String> = jvm
500            .invoke_static("java/lang/String", "valueOf", "(D)Ljava/lang/String;", (value,))
501            .await?;
502        Self::write_string(jvm, &this, value).await
503    }
504
505    async fn println(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<()> {
506        Self::new_line(jvm, &this).await
507    }
508
509    async fn println_object(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, value: ClassInstanceRef<Object>) -> Result<()> {
510        let value: ClassInstanceRef<String> = jvm
511            .invoke_static("java/lang/String", "valueOf", "(Ljava/lang/Object;)Ljava/lang/String;", (value,))
512            .await?;
513        Self::with_monitor(jvm, &this, async {
514            let _: () = jvm
515                .invoke_virtual(&this, "java/io/PrintStream", "print", "(Ljava/lang/String;)V", (value,))
516                .await?;
517            Self::new_line(jvm, &this).await
518        })
519        .await
520    }
521
522    async fn println_string(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, value: ClassInstanceRef<String>) -> Result<()> {
523        Self::with_monitor(jvm, &this, async {
524            let _: () = jvm
525                .invoke_virtual(&this, "java/io/PrintStream", "print", "(Ljava/lang/String;)V", (value,))
526                .await?;
527            Self::new_line(jvm, &this).await
528        })
529        .await
530    }
531
532    async fn println_int(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, value: i32) -> Result<()> {
533        Self::with_monitor(jvm, &this, async {
534            let _: () = jvm.invoke_virtual(&this, "java/io/PrintStream", "print", "(I)V", (value,)).await?;
535            Self::new_line(jvm, &this).await
536        })
537        .await
538    }
539
540    async fn println_long(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, value: i64) -> Result<()> {
541        Self::with_monitor(jvm, &this, async {
542            let _: () = jvm.invoke_virtual(&this, "java/io/PrintStream", "print", "(J)V", (value,)).await?;
543            Self::new_line(jvm, &this).await
544        })
545        .await
546    }
547
548    async fn println_char(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, value: JavaChar) -> Result<()> {
549        Self::with_monitor(jvm, &this, async {
550            let _: () = jvm.invoke_virtual(&this, "java/io/PrintStream", "print", "(C)V", (value,)).await?;
551            Self::new_line(jvm, &this).await
552        })
553        .await
554    }
555
556    async fn println_chars(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, value: ClassInstanceRef<Array<JavaChar>>) -> Result<()> {
557        Self::with_monitor(jvm, &this, async {
558            let _: () = jvm.invoke_virtual(&this, "java/io/PrintStream", "print", "([C)V", (value,)).await?;
559            Self::new_line(jvm, &this).await
560        })
561        .await
562    }
563
564    async fn println_bool(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, value: bool) -> Result<()> {
565        Self::with_monitor(jvm, &this, async {
566            let _: () = jvm.invoke_virtual(&this, "java/io/PrintStream", "print", "(Z)V", (value,)).await?;
567            Self::new_line(jvm, &this).await
568        })
569        .await
570    }
571
572    async fn println_float(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, value: f32) -> Result<()> {
573        Self::with_monitor(jvm, &this, async {
574            let _: () = jvm.invoke_virtual(&this, "java/io/PrintStream", "print", "(F)V", (value,)).await?;
575            Self::new_line(jvm, &this).await
576        })
577        .await
578    }
579
580    async fn println_double(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, value: f64) -> Result<()> {
581        Self::with_monitor(jvm, &this, async {
582            let _: () = jvm.invoke_virtual(&this, "java/io/PrintStream", "print", "(D)V", (value,)).await?;
583            Self::new_line(jvm, &this).await
584        })
585        .await
586    }
587
588    async fn printf(
589        jvm: &Jvm,
590        _: &mut RuntimeContext,
591        this: ClassInstanceRef<Self>,
592        format: ClassInstanceRef<String>,
593        arguments: ClassInstanceRef<Array<Object>>,
594    ) -> Result<ClassInstanceRef<Self>> {
595        jvm.invoke_virtual(
596            &this,
597            "java/io/PrintStream",
598            "format",
599            "(Ljava/lang/String;[Ljava/lang/Object;)Ljava/io/PrintStream;",
600            (format, arguments),
601        )
602        .await
603    }
604
605    async fn printf_with_locale(
606        jvm: &Jvm,
607        _: &mut RuntimeContext,
608        this: ClassInstanceRef<Self>,
609        locale: ClassInstanceRef<Locale>,
610        format: ClassInstanceRef<String>,
611        arguments: ClassInstanceRef<Array<Object>>,
612    ) -> Result<ClassInstanceRef<Self>> {
613        jvm.invoke_virtual(
614            &this,
615            "java/io/PrintStream",
616            "format",
617            "(Ljava/util/Locale;Ljava/lang/String;[Ljava/lang/Object;)Ljava/io/PrintStream;",
618            (locale, format, arguments),
619        )
620        .await
621    }
622
623    async fn format(
624        jvm: &Jvm,
625        _: &mut RuntimeContext,
626        this: ClassInstanceRef<Self>,
627        format: ClassInstanceRef<String>,
628        arguments: ClassInstanceRef<Array<Object>>,
629    ) -> Result<ClassInstanceRef<Self>> {
630        let locale: ClassInstanceRef<Locale> = jvm.invoke_static("java/util/Locale", "getDefault", "()Ljava/util/Locale;", ()).await?;
631        jvm.invoke_virtual(
632            &this,
633            "java/io/PrintStream",
634            "format",
635            "(Ljava/util/Locale;Ljava/lang/String;[Ljava/lang/Object;)Ljava/io/PrintStream;",
636            (locale, format, arguments),
637        )
638        .await
639    }
640
641    async fn format_with_locale(
642        jvm: &Jvm,
643        _: &mut RuntimeContext,
644        this: ClassInstanceRef<Self>,
645        locale: ClassInstanceRef<Locale>,
646        format: ClassInstanceRef<String>,
647        arguments: ClassInstanceRef<Array<Object>>,
648    ) -> Result<ClassInstanceRef<Self>> {
649        Self::with_monitor(jvm, &this, async {
650            let appendable: ClassInstanceRef<Appendable> = this.instance.clone().into();
651            let formatter: ClassInstanceRef<Formatter> = jvm
652                .new_class("java/util/Formatter", "(Ljava/lang/Appendable;Ljava/util/Locale;)V", (appendable, locale))
653                .await?
654                .into();
655            let _: ClassInstanceRef<Formatter> = jvm
656                .invoke_virtual(
657                    &formatter,
658                    "java/util/Formatter",
659                    "format",
660                    "(Ljava/lang/String;[Ljava/lang/Object;)Ljava/util/Formatter;",
661                    (format, arguments),
662                )
663                .await?;
664            Ok(this.clone())
665        })
666        .await
667    }
668
669    async fn append_char_sequence(
670        jvm: &Jvm,
671        _: &mut RuntimeContext,
672        this: ClassInstanceRef<Self>,
673        sequence: ClassInstanceRef<CharSequence>,
674    ) -> Result<ClassInstanceRef<Self>> {
675        let string: ClassInstanceRef<String> = if sequence.is_null() {
676            JavaLangString::from_rust_string(jvm, "null").await?.into()
677        } else {
678            jvm.invoke_virtual(&sequence, &sequence.class_definition().name(), "toString", "()Ljava/lang/String;", ())
679                .await?
680        };
681        let _: () = jvm
682            .invoke_virtual(&this, "java/io/PrintStream", "print", "(Ljava/lang/String;)V", (string,))
683            .await?;
684        Ok(this)
685    }
686
687    async fn append_char_sequence_range(
688        jvm: &Jvm,
689        _: &mut RuntimeContext,
690        this: ClassInstanceRef<Self>,
691        sequence: ClassInstanceRef<CharSequence>,
692        start: i32,
693        end: i32,
694    ) -> Result<ClassInstanceRef<Self>> {
695        let sequence: ClassInstanceRef<CharSequence> = if sequence.is_null() {
696            JavaLangString::from_rust_string(jvm, "null").await?.into()
697        } else {
698            sequence
699        };
700        let subsequence: ClassInstanceRef<CharSequence> = jvm
701            .invoke_virtual(
702                &sequence,
703                &sequence.class_definition().name(),
704                "subSequence",
705                "(II)Ljava/lang/CharSequence;",
706                (start, end),
707            )
708            .await?;
709        let string: ClassInstanceRef<String> = jvm
710            .invoke_virtual(
711                &subsequence,
712                &subsequence.class_definition().name(),
713                "toString",
714                "()Ljava/lang/String;",
715                (),
716            )
717            .await?;
718        let _: () = jvm
719            .invoke_virtual(&this, "java/io/PrintStream", "print", "(Ljava/lang/String;)V", (string,))
720            .await?;
721        Ok(this)
722    }
723
724    async fn append_char(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, character: JavaChar) -> Result<ClassInstanceRef<Self>> {
725        let _: () = jvm.invoke_virtual(&this, "java/io/PrintStream", "print", "(C)V", (character,)).await?;
726        Ok(this)
727    }
728
729    async fn write_string(jvm: &Jvm, this: &ClassInstanceRef<Self>, value: ClassInstanceRef<String>) -> Result<()> {
730        let chars: ClassInstanceRef<Array<JavaChar>> = jvm.invoke_virtual(&value, "java/lang/String", "toCharArray", "()[C", ()).await?;
731        Self::write_characters(jvm, this, chars).await
732    }
733
734    async fn write_characters(jvm: &Jvm, this: &ClassInstanceRef<Self>, chars: ClassInstanceRef<Array<JavaChar>>) -> Result<()> {
735        Self::with_monitor(jvm, this, async {
736            if chars.is_null() {
737                return Err(jvm.exception("java/lang/NullPointerException", "chars is null").await);
738            }
739
740            let out: ClassInstanceRef<OutputStream> = jvm.get_field(this, "java/io/PrintStream", "out", "Ljava/io/OutputStream;").await?;
741            if out.is_null() {
742                let mut this = this.clone();
743                jvm.put_field(&mut this, "java/io/PrintStream", "trouble", "Z", true).await?;
744                return Ok(());
745            }
746
747            let length = jvm.array_length(&chars).await?;
748            let values: Vec<JavaChar> = jvm.load_array(&chars, 0, length).await?;
749            let char_out: ClassInstanceRef<OutputStreamWriter> = jvm
750                .get_field(this, "java/io/PrintStream", "charOut", "Ljava/io/OutputStreamWriter;")
751                .await?;
752            let result = jvm
753                .invoke_virtual(&char_out, "java/io/OutputStreamWriter", "write", "([CII)V", (chars, 0, length as i32))
754                .await;
755            if !Self::suppress_io_exception(jvm, this, result).await? {
756                return Ok(());
757            }
758
759            if jvm.get_field::<bool>(this, "java/io/PrintStream", "autoFlush", "Z").await? && values.contains(&('\n' as JavaChar)) {
760                let result = jvm.invoke_virtual(&out, "java/io/OutputStream", "flush", "()V", ()).await;
761                Self::suppress_io_exception(jvm, this, result).await?;
762            }
763            Ok(())
764        })
765        .await
766    }
767
768    async fn new_line(jvm: &Jvm, this: &ClassInstanceRef<Self>) -> Result<()> {
769        Self::with_monitor(jvm, this, async {
770            let out: ClassInstanceRef<OutputStream> = jvm.get_field(this, "java/io/PrintStream", "out", "Ljava/io/OutputStream;").await?;
771            if out.is_null() {
772                let mut this = this.clone();
773                jvm.put_field(&mut this, "java/io/PrintStream", "trouble", "Z", true).await?;
774                return Ok(());
775            }
776
777            let key = JavaLangString::from_rust_string(jvm, "line.separator").await?;
778            let separator: ClassInstanceRef<String> = jvm
779                .invoke_static("java/lang/System", "getProperty", "(Ljava/lang/String;)Ljava/lang/String;", (key,))
780                .await?;
781            let separator = if separator.is_null() {
782                JavaLangString::from_rust_string(jvm, "\n").await?.into()
783            } else {
784                separator
785            };
786            let chars: ClassInstanceRef<Array<JavaChar>> = jvm.invoke_virtual(&separator, "java/lang/String", "toCharArray", "()[C", ()).await?;
787            let length = jvm.array_length(&chars).await?;
788            let char_out: ClassInstanceRef<OutputStreamWriter> = jvm
789                .get_field(this, "java/io/PrintStream", "charOut", "Ljava/io/OutputStreamWriter;")
790                .await?;
791            let result = jvm
792                .invoke_virtual(&char_out, "java/io/OutputStreamWriter", "write", "([CII)V", (chars, 0, length as i32))
793                .await;
794            if !Self::suppress_io_exception(jvm, this, result).await? {
795                return Ok(());
796            }
797
798            if jvm.get_field::<bool>(this, "java/io/PrintStream", "autoFlush", "Z").await? {
799                let result = jvm.invoke_virtual(&out, "java/io/OutputStream", "flush", "()V", ()).await;
800                Self::suppress_io_exception(jvm, this, result).await?;
801            }
802            Ok(())
803        })
804        .await
805    }
806
807    async fn suppress_io_exception(jvm: &Jvm, this: &ClassInstanceRef<Self>, result: Result<()>) -> Result<bool> {
808        match result {
809            Ok(()) => Ok(true),
810            Err(JavaError::JavaException(exception)) if jvm.is_instance(&*exception, "java/io/IOException") => {
811                let mut this = this.clone();
812                jvm.put_field(&mut this, "java/io/PrintStream", "trouble", "Z", true).await?;
813                Ok(false)
814            }
815            Err(error) => Err(error),
816        }
817    }
818}