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