Skip to main content

rustjava_runtime/classes/java/util/logging/
stream_handler.rs

1use alloc::vec;
2
3use jvm::{ClassInstanceRef, JavaError, Jvm, Result};
4use jvm_class_proto::{JavaFieldProto, JavaMethodProto};
5use jvm_types::{ClassAccessFlags, FieldAccessFlags, MethodAccessFlags};
6
7use crate::{
8    RuntimeClassProto, RuntimeContext,
9    classes::java::{
10        io::{OutputStream, OutputStreamWriter},
11        lang::{Exception, String},
12    },
13};
14
15use super::{Formatter, Level, LogRecord, SimpleFormatter};
16
17// public class java.util.logging.StreamHandler
18pub struct StreamHandler;
19
20impl StreamHandler {
21    pub fn as_proto() -> RuntimeClassProto {
22        RuntimeClassProto {
23            name: "java/util/logging/StreamHandler",
24            parent_class: Some("java/util/logging/Handler"),
25            interfaces: vec![],
26            methods: vec![
27                JavaMethodProto::new("<init>", "()V", Self::init, MethodAccessFlags::PUBLIC),
28                JavaMethodProto::new(
29                    "<init>",
30                    "(Ljava/io/OutputStream;Ljava/util/logging/Formatter;)V",
31                    Self::init_with_output,
32                    MethodAccessFlags::PUBLIC,
33                ),
34                JavaMethodProto::new("close", "()V", Self::close, MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED),
35                JavaMethodProto::new("flush", "()V", Self::flush, MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED),
36                JavaMethodProto::new(
37                    "isLoggable",
38                    "(Ljava/util/logging/LogRecord;)Z",
39                    Self::is_loggable,
40                    MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED,
41                ),
42                JavaMethodProto::new(
43                    "publish",
44                    "(Ljava/util/logging/LogRecord;)V",
45                    Self::publish,
46                    MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED,
47                ),
48                JavaMethodProto::new(
49                    "setEncoding",
50                    "(Ljava/lang/String;)V",
51                    Self::set_encoding,
52                    MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED,
53                ),
54                JavaMethodProto::new(
55                    "setOutputStream",
56                    "(Ljava/io/OutputStream;)V",
57                    Self::set_output_stream,
58                    MethodAccessFlags::PROTECTED | MethodAccessFlags::SYNCHRONIZED,
59                ),
60            ],
61            fields: vec![
62                JavaFieldProto::new("output", "Ljava/io/OutputStream;", FieldAccessFlags::PRIVATE),
63                JavaFieldProto::new("writer", "Ljava/io/OutputStreamWriter;", FieldAccessFlags::PRIVATE),
64                JavaFieldProto::new("headerWritten", "Z", FieldAccessFlags::PRIVATE),
65            ],
66            access_flags: ClassAccessFlags::PUBLIC,
67        }
68    }
69
70    async fn init(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>) -> Result<()> {
71        tracing::debug!("java.util.logging.StreamHandler::<init>({this:?})");
72
73        let _: () = jvm.invoke_special(&this, "java/util/logging/Handler", "<init>", "()V", ()).await?;
74        let formatter: ClassInstanceRef<SimpleFormatter> = jvm.new_class("java/util/logging/SimpleFormatter", "()V", ()).await?.into();
75        let level: ClassInstanceRef<Level> = jvm
76            .get_static_field("java/util/logging/Level", "INFO", "Ljava/util/logging/Level;")
77            .await?;
78        let _: () = jvm
79            .invoke_special(
80                &this,
81                "java/util/logging/Handler",
82                "setFormatter",
83                "(Ljava/util/logging/Formatter;)V",
84                (formatter,),
85            )
86            .await?;
87        let _: () = jvm
88            .invoke_special(&this, "java/util/logging/Handler", "setLevel", "(Ljava/util/logging/Level;)V", (level,))
89            .await?;
90        jvm.put_field(&mut this, "java/util/logging/StreamHandler", "headerWritten", "Z", false)
91            .await
92    }
93
94    async fn init_with_output(
95        jvm: &Jvm,
96        _: &mut RuntimeContext,
97        this: ClassInstanceRef<Self>,
98        output: ClassInstanceRef<OutputStream>,
99        formatter: ClassInstanceRef<Formatter>,
100    ) -> Result<()> {
101        tracing::debug!("java.util.logging.StreamHandler::<init>({this:?}, {output:?}, {formatter:?})");
102
103        if output.is_null() {
104            return Err(jvm.exception("java/lang/NullPointerException", "output").await);
105        }
106        if formatter.is_null() {
107            return Err(jvm.exception("java/lang/NullPointerException", "formatter").await);
108        }
109
110        let _: () = jvm.invoke_special(&this, "java/util/logging/StreamHandler", "<init>", "()V", ()).await?;
111        let _: () = jvm
112            .invoke_special(
113                &this,
114                "java/util/logging/Handler",
115                "setFormatter",
116                "(Ljava/util/logging/Formatter;)V",
117                (formatter,),
118            )
119            .await?;
120        jvm.invoke_special(
121            &this,
122            "java/util/logging/StreamHandler",
123            "setOutputStream",
124            "(Ljava/io/OutputStream;)V",
125            (output,),
126        )
127        .await
128    }
129
130    async fn close(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>) -> Result<()> {
131        tracing::debug!("java.util.logging.StreamHandler::close({this:?})");
132
133        let writer: ClassInstanceRef<OutputStreamWriter> = jvm
134            .get_field(&this, "java/util/logging/StreamHandler", "writer", "Ljava/io/OutputStreamWriter;")
135            .await?;
136        if writer.is_null() {
137            return Ok(());
138        }
139
140        Self::write_tail(jvm, &this).await?;
141        let _: () = jvm.invoke_virtual(&writer, "java/io/OutputStreamWriter", "flush", "()V", ()).await?;
142        let _: () = jvm.invoke_virtual(&writer, "java/io/OutputStreamWriter", "close", "()V", ()).await?;
143        let output: ClassInstanceRef<OutputStream> = None.into();
144        let writer: ClassInstanceRef<OutputStreamWriter> = None.into();
145        jvm.put_field(&mut this, "java/util/logging/StreamHandler", "output", "Ljava/io/OutputStream;", output)
146            .await?;
147        jvm.put_field(
148            &mut this,
149            "java/util/logging/StreamHandler",
150            "writer",
151            "Ljava/io/OutputStreamWriter;",
152            writer,
153        )
154        .await?;
155        jvm.put_field(&mut this, "java/util/logging/StreamHandler", "headerWritten", "Z", false)
156            .await
157    }
158
159    async fn flush(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<()> {
160        tracing::debug!("java.util.logging.StreamHandler::flush({this:?})");
161
162        let writer: ClassInstanceRef<OutputStreamWriter> = jvm
163            .get_field(&this, "java/util/logging/StreamHandler", "writer", "Ljava/io/OutputStreamWriter;")
164            .await?;
165        if writer.is_null() {
166            return Ok(());
167        }
168        jvm.invoke_virtual(&writer, "java/io/OutputStreamWriter", "flush", "()V", ()).await
169    }
170
171    async fn is_loggable(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, record: ClassInstanceRef<LogRecord>) -> Result<bool> {
172        tracing::debug!("java.util.logging.StreamHandler::isLoggable({this:?}, {record:?})");
173
174        let output: ClassInstanceRef<OutputStream> = jvm
175            .get_field(&this, "java/util/logging/StreamHandler", "output", "Ljava/io/OutputStream;")
176            .await?;
177        if output.is_null() || record.is_null() {
178            return Ok(false);
179        }
180
181        jvm.invoke_special(
182            &this,
183            "java/util/logging/Handler",
184            "isLoggable",
185            "(Ljava/util/logging/LogRecord;)Z",
186            (record,),
187        )
188        .await
189    }
190
191    async fn publish(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, record: ClassInstanceRef<LogRecord>) -> Result<()> {
192        tracing::debug!("java.util.logging.StreamHandler::publish({this:?}, {record:?})");
193
194        let loggable: bool = jvm
195            .invoke_virtual(
196                &this,
197                "java/util/logging/StreamHandler",
198                "isLoggable",
199                "(Ljava/util/logging/LogRecord;)Z",
200                (record.clone(),),
201            )
202            .await?;
203        if !loggable {
204            return Ok(());
205        }
206
207        if let Err(JavaError::JavaException(exception)) = Self::write_head(jvm, &this).await {
208            if !jvm.is_instance(&*exception, "java/lang/Exception") {
209                return Err(JavaError::JavaException(exception));
210            }
211            let message: ClassInstanceRef<String> = None.into();
212            let exception: ClassInstanceRef<Exception> = exception.into();
213            let _: () = jvm
214                .invoke_virtual(
215                    &this,
216                    "java/util/logging/StreamHandler",
217                    "reportError",
218                    "(Ljava/lang/String;Ljava/lang/Exception;I)V",
219                    (message, exception, 1),
220                )
221                .await?;
222            return Ok(());
223        }
224        let formatter: ClassInstanceRef<Formatter> = jvm
225            .get_field(&this, "java/util/logging/StreamHandler", "formatter", "Ljava/util/logging/Formatter;")
226            .await?;
227        let formatted: ClassInstanceRef<String> = match jvm
228            .invoke_virtual(
229                &formatter,
230                "java/util/logging/Formatter",
231                "format",
232                "(Ljava/util/logging/LogRecord;)Ljava/lang/String;",
233                (record,),
234            )
235            .await
236        {
237            Ok(formatted) => formatted,
238            Err(JavaError::JavaException(exception)) => {
239                if !jvm.is_instance(&*exception, "java/lang/Exception") {
240                    return Err(JavaError::JavaException(exception));
241                }
242                let message: ClassInstanceRef<String> = None.into();
243                let exception: ClassInstanceRef<Exception> = exception.into();
244                let _: () = jvm
245                    .invoke_virtual(
246                        &this,
247                        "java/util/logging/StreamHandler",
248                        "reportError",
249                        "(Ljava/lang/String;Ljava/lang/Exception;I)V",
250                        (message, exception, 5),
251                    )
252                    .await?;
253                return Ok(());
254            }
255        };
256        let writer: ClassInstanceRef<OutputStreamWriter> = jvm
257            .get_field(&this, "java/util/logging/StreamHandler", "writer", "Ljava/io/OutputStreamWriter;")
258            .await?;
259        if let Err(JavaError::JavaException(exception)) = jvm
260            .invoke_virtual::<_, ()>(&writer, "java/io/OutputStreamWriter", "write", "(Ljava/lang/String;)V", (formatted,))
261            .await
262        {
263            if !jvm.is_instance(&*exception, "java/lang/Exception") {
264                return Err(JavaError::JavaException(exception));
265            }
266            let message: ClassInstanceRef<String> = None.into();
267            let exception: ClassInstanceRef<Exception> = exception.into();
268            let _: () = jvm
269                .invoke_virtual(
270                    &this,
271                    "java/util/logging/StreamHandler",
272                    "reportError",
273                    "(Ljava/lang/String;Ljava/lang/Exception;I)V",
274                    (message, exception, 1),
275                )
276                .await?;
277        }
278        Ok(())
279    }
280
281    async fn set_encoding(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>, encoding: ClassInstanceRef<String>) -> Result<()> {
282        tracing::debug!("java.util.logging.StreamHandler::setEncoding({this:?}, {encoding:?})");
283
284        let _: () = jvm
285            .invoke_special(
286                &this,
287                "java/util/logging/Handler",
288                "setEncoding",
289                "(Ljava/lang/String;)V",
290                (encoding.clone(),),
291            )
292            .await?;
293
294        let output: ClassInstanceRef<OutputStream> = jvm
295            .get_field(&this, "java/util/logging/StreamHandler", "output", "Ljava/io/OutputStream;")
296            .await?;
297        if output.is_null() {
298            return Ok(());
299        }
300
301        let writer: ClassInstanceRef<OutputStreamWriter> = jvm
302            .get_field(&this, "java/util/logging/StreamHandler", "writer", "Ljava/io/OutputStreamWriter;")
303            .await?;
304        let _: () = jvm.invoke_virtual(&writer, "java/io/OutputStreamWriter", "flush", "()V", ()).await?;
305        let writer: ClassInstanceRef<OutputStreamWriter> = if encoding.is_null() {
306            jvm.new_class("java/io/OutputStreamWriter", "(Ljava/io/OutputStream;)V", (output,))
307                .await?
308                .into()
309        } else {
310            jvm.new_class(
311                "java/io/OutputStreamWriter",
312                "(Ljava/io/OutputStream;Ljava/lang/String;)V",
313                (output, encoding),
314            )
315            .await?
316            .into()
317        };
318        jvm.put_field(
319            &mut this,
320            "java/util/logging/StreamHandler",
321            "writer",
322            "Ljava/io/OutputStreamWriter;",
323            writer,
324        )
325        .await
326    }
327
328    async fn set_output_stream(
329        jvm: &Jvm,
330        _: &mut RuntimeContext,
331        mut this: ClassInstanceRef<Self>,
332        output: ClassInstanceRef<OutputStream>,
333    ) -> Result<()> {
334        tracing::debug!("java.util.logging.StreamHandler::setOutputStream({this:?}, {output:?})");
335
336        if output.is_null() {
337            return Err(jvm.exception("java/lang/NullPointerException", "output").await);
338        }
339
340        let current_writer: ClassInstanceRef<OutputStreamWriter> = jvm
341            .get_field(&this, "java/util/logging/StreamHandler", "writer", "Ljava/io/OutputStreamWriter;")
342            .await?;
343        if !current_writer.is_null() {
344            Self::write_tail(jvm, &this).await?;
345            let _: () = jvm
346                .invoke_virtual(&current_writer, "java/io/OutputStreamWriter", "flush", "()V", ())
347                .await?;
348            let _: () = jvm
349                .invoke_virtual(&current_writer, "java/io/OutputStreamWriter", "close", "()V", ())
350                .await?;
351        }
352
353        let encoding: ClassInstanceRef<String> = jvm
354            .get_field(&this, "java/util/logging/StreamHandler", "encoding", "Ljava/lang/String;")
355            .await?;
356        let writer: ClassInstanceRef<OutputStreamWriter> = if encoding.is_null() {
357            jvm.new_class("java/io/OutputStreamWriter", "(Ljava/io/OutputStream;)V", (output.clone(),))
358                .await?
359                .into()
360        } else {
361            jvm.new_class(
362                "java/io/OutputStreamWriter",
363                "(Ljava/io/OutputStream;Ljava/lang/String;)V",
364                (output.clone(), encoding),
365            )
366            .await?
367            .into()
368        };
369        jvm.put_field(&mut this, "java/util/logging/StreamHandler", "output", "Ljava/io/OutputStream;", output)
370            .await?;
371        jvm.put_field(
372            &mut this,
373            "java/util/logging/StreamHandler",
374            "writer",
375            "Ljava/io/OutputStreamWriter;",
376            writer,
377        )
378        .await?;
379        jvm.put_field(&mut this, "java/util/logging/StreamHandler", "headerWritten", "Z", false)
380            .await
381    }
382
383    async fn write_head(jvm: &Jvm, this: &ClassInstanceRef<Self>) -> Result<()> {
384        if jvm
385            .get_field::<bool>(this, "java/util/logging/StreamHandler", "headerWritten", "Z")
386            .await?
387        {
388            return Ok(());
389        }
390
391        let formatter: ClassInstanceRef<Formatter> = jvm
392            .get_field(this, "java/util/logging/StreamHandler", "formatter", "Ljava/util/logging/Formatter;")
393            .await?;
394        let head: ClassInstanceRef<String> = jvm
395            .invoke_virtual(
396                &formatter,
397                "java/util/logging/Formatter",
398                "getHead",
399                "(Ljava/util/logging/Handler;)Ljava/lang/String;",
400                (this.clone(),),
401            )
402            .await?;
403        let writer: ClassInstanceRef<OutputStreamWriter> = jvm
404            .get_field(this, "java/util/logging/StreamHandler", "writer", "Ljava/io/OutputStreamWriter;")
405            .await?;
406        let _: () = jvm
407            .invoke_virtual(&writer, "java/io/OutputStreamWriter", "write", "(Ljava/lang/String;)V", (head,))
408            .await?;
409        let mut this = this.clone();
410        jvm.put_field(&mut this, "java/util/logging/StreamHandler", "headerWritten", "Z", true)
411            .await
412    }
413
414    async fn write_tail(jvm: &Jvm, this: &ClassInstanceRef<Self>) -> Result<()> {
415        Self::write_head(jvm, this).await?;
416        let formatter: ClassInstanceRef<Formatter> = jvm
417            .get_field(this, "java/util/logging/StreamHandler", "formatter", "Ljava/util/logging/Formatter;")
418            .await?;
419        let tail: ClassInstanceRef<String> = jvm
420            .invoke_virtual(
421                &formatter,
422                "java/util/logging/Formatter",
423                "getTail",
424                "(Ljava/util/logging/Handler;)Ljava/lang/String;",
425                (this.clone(),),
426            )
427            .await?;
428        let writer: ClassInstanceRef<OutputStreamWriter> = jvm
429            .get_field(this, "java/util/logging/StreamHandler", "writer", "Ljava/io/OutputStreamWriter;")
430            .await?;
431        jvm.invoke_virtual(&writer, "java/io/OutputStreamWriter", "write", "(Ljava/lang/String;)V", (tail,))
432            .await
433    }
434}