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, "autoFlush", "Z", auto_flush).await?;
211        jvm.put_field(&mut this, "trouble", "Z", false).await?;
212        jvm.put_field(&mut this, "charOut", "Ljava/io/OutputStreamWriter;", char_out).await?;
213        jvm.put_field(&mut this, "closing", "Z", false).await
214    }
215
216    async fn init_path(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, path: ClassInstanceRef<String>) -> Result<()> {
217        if path.is_null() {
218            return Err(jvm.exception("java/lang/NullPointerException", "file name is null").await);
219        }
220        let file: ClassInstanceRef<File> = jvm.new_class("java/io/File", "(Ljava/lang/String;)V", (path,)).await?.into();
221        jvm.invoke_special(&this, "java/io/PrintStream", "<init>", "(Ljava/io/File;)V", (file,))
222            .await
223    }
224
225    async fn init_path_encoding(
226        jvm: &Jvm,
227        _: &mut RuntimeContext,
228        this: ClassInstanceRef<Self>,
229        path: ClassInstanceRef<String>,
230        encoding: ClassInstanceRef<String>,
231    ) -> Result<()> {
232        if path.is_null() {
233            return Err(jvm.exception("java/lang/NullPointerException", "file name is null").await);
234        }
235        OutputStreamWriter::validate_encoding(jvm, &encoding).await?;
236        let file: ClassInstanceRef<File> = jvm.new_class("java/io/File", "(Ljava/lang/String;)V", (path,)).await?.into();
237        jvm.invoke_special(
238            &this,
239            "java/io/PrintStream",
240            "<init>",
241            "(Ljava/io/File;Ljava/lang/String;)V",
242            (file, encoding),
243        )
244        .await
245    }
246
247    async fn init_file(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, file: ClassInstanceRef<File>) -> Result<()> {
248        if file.is_null() {
249            return Err(jvm.exception("java/lang/NullPointerException", "file is null").await);
250        }
251        let output: ClassInstanceRef<OutputStream> = jvm.new_class("java/io/FileOutputStream", "(Ljava/io/File;)V", (file,)).await?.into();
252        jvm.invoke_special(&this, "java/io/PrintStream", "<init>", "(Ljava/io/OutputStream;)V", (output,))
253            .await
254    }
255
256    async fn init_file_encoding(
257        jvm: &Jvm,
258        _: &mut RuntimeContext,
259        this: ClassInstanceRef<Self>,
260        file: ClassInstanceRef<File>,
261        encoding: ClassInstanceRef<String>,
262    ) -> Result<()> {
263        if file.is_null() {
264            return Err(jvm.exception("java/lang/NullPointerException", "file is null").await);
265        }
266        OutputStreamWriter::validate_encoding(jvm, &encoding).await?;
267        let output: ClassInstanceRef<OutputStream> = jvm.new_class("java/io/FileOutputStream", "(Ljava/io/File;)V", (file,)).await?.into();
268        jvm.invoke_special(
269            &this,
270            "java/io/PrintStream",
271            "<init>",
272            "(Ljava/io/OutputStream;ZLjava/lang/String;)V",
273            (output, false, encoding),
274        )
275        .await
276    }
277
278    async fn with_monitor<T, F>(jvm: &Jvm, this: &ClassInstanceRef<Self>, operation: F) -> Result<T>
279    where
280        F: Future<Output = Result<T>>,
281    {
282        jvm.monitor_enter(this).await?;
283        match operation.await {
284            Ok(value) => {
285                jvm.monitor_exit(this).await?;
286                Ok(value)
287            }
288            Err(error) => {
289                if let Err(exit_error) = jvm.monitor_exit(this).await {
290                    tracing::error!(?exit_error, "failed to release PrintStream monitor");
291                }
292                Err(error)
293            }
294        }
295    }
296
297    async fn check_error(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<bool> {
298        tracing::debug!("java.io.PrintStream::checkError({this:?})");
299
300        Self::with_monitor(jvm, &this, async {
301            let out: ClassInstanceRef<OutputStream> = jvm.get_field(&this, "out", "Ljava/io/OutputStream;").await?;
302            if !out.is_null() {
303                let _: () = jvm.invoke_virtual(&this, "java/io/PrintStream", "flush", "()V", ()).await?;
304                if jvm.is_instance(&**out, "java/io/PrintStream") {
305                    return jvm.invoke_virtual(&out, "java/io/PrintStream", "checkError", "()Z", ()).await;
306                }
307            }
308            jvm.get_field(&this, "trouble", "Z").await
309        })
310        .await
311    }
312
313    async fn set_error(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>) -> Result<()> {
314        jvm.put_field(&mut this, "trouble", "Z", true).await
315    }
316
317    async fn close(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<()> {
318        tracing::debug!("java.io.PrintStream::close({this:?})");
319
320        Self::with_monitor(jvm, &this, async {
321            let out: ClassInstanceRef<OutputStream> = jvm.get_field(&this, "out", "Ljava/io/OutputStream;").await?;
322            if out.is_null() || jvm.get_field::<bool>(&this, "closing", "Z").await? {
323                return Ok(());
324            }
325
326            let mut this = this.clone();
327            jvm.put_field(&mut this, "closing", "Z", true).await?;
328            let char_out: ClassInstanceRef<OutputStreamWriter> = jvm.get_field(&this, "charOut", "Ljava/io/OutputStreamWriter;").await?;
329            let char_out_result = jvm.invoke_virtual(&char_out, "java/io/OutputStreamWriter", "close", "()V", ()).await;
330            let close_out = match char_out_result {
331                Ok(()) => true,
332                Err(JavaError::JavaException(exception)) if jvm.is_instance(&*exception, "java/io/IOException") => {
333                    jvm.put_field(&mut this, "trouble", "Z", true).await?;
334                    false
335                }
336                Err(error) => return Err(error),
337            };
338
339            if close_out {
340                match jvm.invoke_virtual(&out, "java/io/OutputStream", "close", "()V", ()).await {
341                    Ok(()) => {}
342                    Err(JavaError::JavaException(exception)) if jvm.is_instance(&*exception, "java/io/IOException") => {
343                        jvm.put_field(&mut this, "trouble", "Z", true).await?;
344                    }
345                    Err(error) => return Err(error),
346                }
347            }
348
349            let closed_output: ClassInstanceRef<OutputStream> = None.into();
350            let closed_writer: ClassInstanceRef<OutputStreamWriter> = None.into();
351            jvm.put_field(&mut this, "charOut", "Ljava/io/OutputStreamWriter;", closed_writer).await?;
352            jvm.put_field(&mut this, "out", "Ljava/io/OutputStream;", closed_output).await
353        })
354        .await
355    }
356
357    async fn flush(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<()> {
358        tracing::debug!("java.io.PrintStream::flush({this:?})");
359
360        Self::with_monitor(jvm, &this, async {
361            let out: ClassInstanceRef<OutputStream> = jvm.get_field(&this, "out", "Ljava/io/OutputStream;").await?;
362            if out.is_null() {
363                let mut this = this.clone();
364                jvm.put_field(&mut this, "trouble", "Z", true).await?;
365                return Ok(());
366            }
367
368            let result = jvm.invoke_virtual(&out, "java/io/OutputStream", "flush", "()V", ()).await;
369            Self::suppress_io_exception(jvm, &this, result).await.map(|_| ())
370        })
371        .await
372    }
373
374    async fn write_byte(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, value: i32) -> Result<()> {
375        tracing::debug!("java.io.PrintStream::write({this:?}, {value})");
376
377        Self::with_monitor(jvm, &this, async {
378            let out: ClassInstanceRef<OutputStream> = jvm.get_field(&this, "out", "Ljava/io/OutputStream;").await?;
379            if out.is_null() {
380                let mut this = this.clone();
381                jvm.put_field(&mut this, "trouble", "Z", true).await?;
382                return Ok(());
383            }
384
385            let result = jvm.invoke_virtual(&out, "java/io/OutputStream", "write", "(I)V", (value,)).await;
386            if Self::suppress_io_exception(jvm, &this, result).await?
387                && value == b'\n' as i32
388                && jvm.get_field::<bool>(&this, "autoFlush", "Z").await?
389            {
390                let result = jvm.invoke_virtual(&out, "java/io/OutputStream", "flush", "()V", ()).await;
391                Self::suppress_io_exception(jvm, &this, result).await?;
392            }
393            Ok(())
394        })
395        .await
396    }
397
398    async fn write_bytes(
399        jvm: &Jvm,
400        _: &mut RuntimeContext,
401        this: ClassInstanceRef<Self>,
402        bytes: ClassInstanceRef<Array<i8>>,
403        off: i32,
404        len: i32,
405    ) -> Result<()> {
406        tracing::debug!("java.io.PrintStream::write({this:?}, {bytes:?}, {off}, {len})");
407
408        Self::with_monitor(jvm, &this, async {
409            if bytes.is_null() {
410                return Err(jvm.exception("java/lang/NullPointerException", "bytes is null").await);
411            }
412            let array_length = jvm.array_length(&bytes).await? as i32;
413            if off < 0 || len < 0 || off > array_length - len {
414                return Err(jvm.exception("java/lang/IndexOutOfBoundsException", "invalid offset or length").await);
415            }
416
417            let out: ClassInstanceRef<OutputStream> = jvm.get_field(&this, "out", "Ljava/io/OutputStream;").await?;
418            if out.is_null() {
419                let mut this = this.clone();
420                jvm.put_field(&mut this, "trouble", "Z", true).await?;
421                return Ok(());
422            }
423
424            let result = jvm
425                .invoke_virtual(&out, "java/io/OutputStream", "write", "([BII)V", (bytes, off, len))
426                .await;
427            if Self::suppress_io_exception(jvm, &this, result).await? && jvm.get_field::<bool>(&this, "autoFlush", "Z").await? {
428                let result = jvm.invoke_virtual(&out, "java/io/OutputStream", "flush", "()V", ()).await;
429                Self::suppress_io_exception(jvm, &this, result).await?;
430            }
431            Ok(())
432        })
433        .await
434    }
435
436    async fn print_object(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, value: ClassInstanceRef<Object>) -> Result<()> {
437        tracing::debug!("java.io.PrintStream::print({this:?}, {value:?})");
438        let value: ClassInstanceRef<String> = jvm
439            .invoke_static("java/lang/String", "valueOf", "(Ljava/lang/Object;)Ljava/lang/String;", (value,))
440            .await?;
441        Self::write_string(jvm, &this, value).await
442    }
443
444    async fn print_string(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, value: ClassInstanceRef<String>) -> Result<()> {
445        tracing::debug!("java.io.PrintStream::print({this:?}, {value:?})");
446        let value = if value.is_null() {
447            JavaLangString::from_rust_string(jvm, "null").await?.into()
448        } else {
449            value
450        };
451        Self::write_string(jvm, &this, value).await
452    }
453
454    async fn print_int(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, value: i32) -> Result<()> {
455        let value: ClassInstanceRef<String> = jvm
456            .invoke_static("java/lang/String", "valueOf", "(I)Ljava/lang/String;", (value,))
457            .await?;
458        Self::write_string(jvm, &this, value).await
459    }
460
461    async fn print_long(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, value: i64) -> Result<()> {
462        let value: ClassInstanceRef<String> = jvm
463            .invoke_static("java/lang/String", "valueOf", "(J)Ljava/lang/String;", (value,))
464            .await?;
465        Self::write_string(jvm, &this, value).await
466    }
467
468    async fn print_char(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, value: JavaChar) -> Result<()> {
469        let mut chars = jvm.instantiate_array("C", 1).await?;
470        jvm.store_array(&mut chars, 0, [value]).await?;
471        Self::write_characters(jvm, &this, chars.into()).await
472    }
473
474    async fn print_chars(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, value: ClassInstanceRef<Array<JavaChar>>) -> Result<()> {
475        Self::write_characters(jvm, &this, value).await
476    }
477
478    async fn print_bool(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, value: bool) -> Result<()> {
479        let value: ClassInstanceRef<String> = jvm
480            .invoke_static("java/lang/String", "valueOf", "(Z)Ljava/lang/String;", (value,))
481            .await?;
482        Self::write_string(jvm, &this, value).await
483    }
484
485    async fn print_float(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, value: f32) -> Result<()> {
486        let value: ClassInstanceRef<String> = jvm
487            .invoke_static("java/lang/String", "valueOf", "(F)Ljava/lang/String;", (value,))
488            .await?;
489        Self::write_string(jvm, &this, value).await
490    }
491
492    async fn print_double(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, value: f64) -> Result<()> {
493        let value: ClassInstanceRef<String> = jvm
494            .invoke_static("java/lang/String", "valueOf", "(D)Ljava/lang/String;", (value,))
495            .await?;
496        Self::write_string(jvm, &this, value).await
497    }
498
499    async fn println(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<()> {
500        Self::new_line(jvm, &this).await
501    }
502
503    async fn println_object(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, value: ClassInstanceRef<Object>) -> Result<()> {
504        let value: ClassInstanceRef<String> = jvm
505            .invoke_static("java/lang/String", "valueOf", "(Ljava/lang/Object;)Ljava/lang/String;", (value,))
506            .await?;
507        Self::with_monitor(jvm, &this, async {
508            let _: () = jvm
509                .invoke_virtual(&this, "java/io/PrintStream", "print", "(Ljava/lang/String;)V", (value,))
510                .await?;
511            Self::new_line(jvm, &this).await
512        })
513        .await
514    }
515
516    async fn println_string(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, value: ClassInstanceRef<String>) -> Result<()> {
517        Self::with_monitor(jvm, &this, async {
518            let _: () = jvm
519                .invoke_virtual(&this, "java/io/PrintStream", "print", "(Ljava/lang/String;)V", (value,))
520                .await?;
521            Self::new_line(jvm, &this).await
522        })
523        .await
524    }
525
526    async fn println_int(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, value: i32) -> Result<()> {
527        Self::with_monitor(jvm, &this, async {
528            let _: () = jvm.invoke_virtual(&this, "java/io/PrintStream", "print", "(I)V", (value,)).await?;
529            Self::new_line(jvm, &this).await
530        })
531        .await
532    }
533
534    async fn println_long(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, value: i64) -> Result<()> {
535        Self::with_monitor(jvm, &this, async {
536            let _: () = jvm.invoke_virtual(&this, "java/io/PrintStream", "print", "(J)V", (value,)).await?;
537            Self::new_line(jvm, &this).await
538        })
539        .await
540    }
541
542    async fn println_char(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, value: JavaChar) -> Result<()> {
543        Self::with_monitor(jvm, &this, async {
544            let _: () = jvm.invoke_virtual(&this, "java/io/PrintStream", "print", "(C)V", (value,)).await?;
545            Self::new_line(jvm, &this).await
546        })
547        .await
548    }
549
550    async fn println_chars(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, value: ClassInstanceRef<Array<JavaChar>>) -> Result<()> {
551        Self::with_monitor(jvm, &this, async {
552            let _: () = jvm.invoke_virtual(&this, "java/io/PrintStream", "print", "([C)V", (value,)).await?;
553            Self::new_line(jvm, &this).await
554        })
555        .await
556    }
557
558    async fn println_bool(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, value: bool) -> Result<()> {
559        Self::with_monitor(jvm, &this, async {
560            let _: () = jvm.invoke_virtual(&this, "java/io/PrintStream", "print", "(Z)V", (value,)).await?;
561            Self::new_line(jvm, &this).await
562        })
563        .await
564    }
565
566    async fn println_float(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, value: f32) -> Result<()> {
567        Self::with_monitor(jvm, &this, async {
568            let _: () = jvm.invoke_virtual(&this, "java/io/PrintStream", "print", "(F)V", (value,)).await?;
569            Self::new_line(jvm, &this).await
570        })
571        .await
572    }
573
574    async fn println_double(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, value: f64) -> Result<()> {
575        Self::with_monitor(jvm, &this, async {
576            let _: () = jvm.invoke_virtual(&this, "java/io/PrintStream", "print", "(D)V", (value,)).await?;
577            Self::new_line(jvm, &this).await
578        })
579        .await
580    }
581
582    async fn printf(
583        jvm: &Jvm,
584        _: &mut RuntimeContext,
585        this: ClassInstanceRef<Self>,
586        format: ClassInstanceRef<String>,
587        arguments: ClassInstanceRef<Array<Object>>,
588    ) -> Result<ClassInstanceRef<Self>> {
589        jvm.invoke_virtual(
590            &this,
591            "java/io/PrintStream",
592            "format",
593            "(Ljava/lang/String;[Ljava/lang/Object;)Ljava/io/PrintStream;",
594            (format, arguments),
595        )
596        .await
597    }
598
599    async fn printf_with_locale(
600        jvm: &Jvm,
601        _: &mut RuntimeContext,
602        this: ClassInstanceRef<Self>,
603        locale: ClassInstanceRef<Locale>,
604        format: ClassInstanceRef<String>,
605        arguments: ClassInstanceRef<Array<Object>>,
606    ) -> Result<ClassInstanceRef<Self>> {
607        jvm.invoke_virtual(
608            &this,
609            "java/io/PrintStream",
610            "format",
611            "(Ljava/util/Locale;Ljava/lang/String;[Ljava/lang/Object;)Ljava/io/PrintStream;",
612            (locale, format, arguments),
613        )
614        .await
615    }
616
617    async fn format(
618        jvm: &Jvm,
619        _: &mut RuntimeContext,
620        this: ClassInstanceRef<Self>,
621        format: ClassInstanceRef<String>,
622        arguments: ClassInstanceRef<Array<Object>>,
623    ) -> Result<ClassInstanceRef<Self>> {
624        let locale: ClassInstanceRef<Locale> = jvm.invoke_static("java/util/Locale", "getDefault", "()Ljava/util/Locale;", ()).await?;
625        jvm.invoke_virtual(
626            &this,
627            "java/io/PrintStream",
628            "format",
629            "(Ljava/util/Locale;Ljava/lang/String;[Ljava/lang/Object;)Ljava/io/PrintStream;",
630            (locale, format, arguments),
631        )
632        .await
633    }
634
635    async fn format_with_locale(
636        jvm: &Jvm,
637        _: &mut RuntimeContext,
638        this: ClassInstanceRef<Self>,
639        locale: ClassInstanceRef<Locale>,
640        format: ClassInstanceRef<String>,
641        arguments: ClassInstanceRef<Array<Object>>,
642    ) -> Result<ClassInstanceRef<Self>> {
643        Self::with_monitor(jvm, &this, async {
644            let appendable: ClassInstanceRef<Appendable> = this.instance.clone().into();
645            let formatter: ClassInstanceRef<Formatter> = jvm
646                .new_class("java/util/Formatter", "(Ljava/lang/Appendable;Ljava/util/Locale;)V", (appendable, locale))
647                .await?
648                .into();
649            let _: ClassInstanceRef<Formatter> = jvm
650                .invoke_virtual(
651                    &formatter,
652                    "java/util/Formatter",
653                    "format",
654                    "(Ljava/lang/String;[Ljava/lang/Object;)Ljava/util/Formatter;",
655                    (format, arguments),
656                )
657                .await?;
658            Ok(this.clone())
659        })
660        .await
661    }
662
663    async fn append_char_sequence(
664        jvm: &Jvm,
665        _: &mut RuntimeContext,
666        this: ClassInstanceRef<Self>,
667        sequence: ClassInstanceRef<CharSequence>,
668    ) -> Result<ClassInstanceRef<Self>> {
669        let string: ClassInstanceRef<String> = if sequence.is_null() {
670            JavaLangString::from_rust_string(jvm, "null").await?.into()
671        } else {
672            jvm.invoke_virtual(&sequence, &sequence.class_definition().name(), "toString", "()Ljava/lang/String;", ())
673                .await?
674        };
675        let _: () = jvm
676            .invoke_virtual(&this, "java/io/PrintStream", "print", "(Ljava/lang/String;)V", (string,))
677            .await?;
678        Ok(this)
679    }
680
681    async fn append_char_sequence_range(
682        jvm: &Jvm,
683        _: &mut RuntimeContext,
684        this: ClassInstanceRef<Self>,
685        sequence: ClassInstanceRef<CharSequence>,
686        start: i32,
687        end: i32,
688    ) -> Result<ClassInstanceRef<Self>> {
689        let sequence: ClassInstanceRef<CharSequence> = if sequence.is_null() {
690            JavaLangString::from_rust_string(jvm, "null").await?.into()
691        } else {
692            sequence
693        };
694        let subsequence: ClassInstanceRef<CharSequence> = jvm
695            .invoke_virtual(
696                &sequence,
697                &sequence.class_definition().name(),
698                "subSequence",
699                "(II)Ljava/lang/CharSequence;",
700                (start, end),
701            )
702            .await?;
703        let string: ClassInstanceRef<String> = jvm
704            .invoke_virtual(
705                &subsequence,
706                &subsequence.class_definition().name(),
707                "toString",
708                "()Ljava/lang/String;",
709                (),
710            )
711            .await?;
712        let _: () = jvm
713            .invoke_virtual(&this, "java/io/PrintStream", "print", "(Ljava/lang/String;)V", (string,))
714            .await?;
715        Ok(this)
716    }
717
718    async fn append_char(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, character: JavaChar) -> Result<ClassInstanceRef<Self>> {
719        let _: () = jvm.invoke_virtual(&this, "java/io/PrintStream", "print", "(C)V", (character,)).await?;
720        Ok(this)
721    }
722
723    async fn write_string(jvm: &Jvm, this: &ClassInstanceRef<Self>, value: ClassInstanceRef<String>) -> Result<()> {
724        let chars: ClassInstanceRef<Array<JavaChar>> = jvm.invoke_virtual(&value, "java/lang/String", "toCharArray", "()[C", ()).await?;
725        Self::write_characters(jvm, this, chars).await
726    }
727
728    async fn write_characters(jvm: &Jvm, this: &ClassInstanceRef<Self>, chars: ClassInstanceRef<Array<JavaChar>>) -> Result<()> {
729        Self::with_monitor(jvm, this, async {
730            if chars.is_null() {
731                return Err(jvm.exception("java/lang/NullPointerException", "chars is null").await);
732            }
733
734            let out: ClassInstanceRef<OutputStream> = jvm.get_field(this, "out", "Ljava/io/OutputStream;").await?;
735            if out.is_null() {
736                let mut this = this.clone();
737                jvm.put_field(&mut this, "trouble", "Z", true).await?;
738                return Ok(());
739            }
740
741            let length = jvm.array_length(&chars).await?;
742            let values: Vec<JavaChar> = jvm.load_array(&chars, 0, length).await?;
743            let char_out: ClassInstanceRef<OutputStreamWriter> = jvm.get_field(this, "charOut", "Ljava/io/OutputStreamWriter;").await?;
744            let result = jvm
745                .invoke_virtual(&char_out, "java/io/OutputStreamWriter", "write", "([CII)V", (chars, 0, length as i32))
746                .await;
747            if !Self::suppress_io_exception(jvm, this, result).await? {
748                return Ok(());
749            }
750
751            if jvm.get_field::<bool>(this, "autoFlush", "Z").await? && values.contains(&('\n' as JavaChar)) {
752                let result = jvm.invoke_virtual(&out, "java/io/OutputStream", "flush", "()V", ()).await;
753                Self::suppress_io_exception(jvm, this, result).await?;
754            }
755            Ok(())
756        })
757        .await
758    }
759
760    async fn new_line(jvm: &Jvm, this: &ClassInstanceRef<Self>) -> Result<()> {
761        Self::with_monitor(jvm, this, async {
762            let out: ClassInstanceRef<OutputStream> = jvm.get_field(this, "out", "Ljava/io/OutputStream;").await?;
763            if out.is_null() {
764                let mut this = this.clone();
765                jvm.put_field(&mut this, "trouble", "Z", true).await?;
766                return Ok(());
767            }
768
769            let key = JavaLangString::from_rust_string(jvm, "line.separator").await?;
770            let separator: ClassInstanceRef<String> = jvm
771                .invoke_static("java/lang/System", "getProperty", "(Ljava/lang/String;)Ljava/lang/String;", (key,))
772                .await?;
773            let separator = if separator.is_null() {
774                JavaLangString::from_rust_string(jvm, "\n").await?.into()
775            } else {
776                separator
777            };
778            let chars: ClassInstanceRef<Array<JavaChar>> = jvm.invoke_virtual(&separator, "java/lang/String", "toCharArray", "()[C", ()).await?;
779            let length = jvm.array_length(&chars).await?;
780            let char_out: ClassInstanceRef<OutputStreamWriter> = jvm.get_field(this, "charOut", "Ljava/io/OutputStreamWriter;").await?;
781            let result = jvm
782                .invoke_virtual(&char_out, "java/io/OutputStreamWriter", "write", "([CII)V", (chars, 0, length as i32))
783                .await;
784            if !Self::suppress_io_exception(jvm, this, result).await? {
785                return Ok(());
786            }
787
788            if jvm.get_field::<bool>(this, "autoFlush", "Z").await? {
789                let result = jvm.invoke_virtual(&out, "java/io/OutputStream", "flush", "()V", ()).await;
790                Self::suppress_io_exception(jvm, this, result).await?;
791            }
792            Ok(())
793        })
794        .await
795    }
796
797    async fn suppress_io_exception(jvm: &Jvm, this: &ClassInstanceRef<Self>, result: Result<()>) -> Result<bool> {
798        match result {
799            Ok(()) => Ok(true),
800            Err(JavaError::JavaException(exception)) if jvm.is_instance(&*exception, "java/io/IOException") => {
801                let mut this = this.clone();
802                jvm.put_field(&mut this, "trouble", "Z", true).await?;
803                Ok(false)
804            }
805            Err(error) => Err(error),
806        }
807    }
808}