Skip to main content

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

1use alloc::{format, string::String as RustString, vec};
2
3use jvm::{ClassInstanceRef, Jvm, Result, runtime::JavaLangString};
4use jvm_class_proto::JavaMethodProto;
5use jvm_types::{ClassAccessFlags, MethodAccessFlags};
6
7use crate::{
8    RuntimeClassProto, RuntimeContext,
9    classes::java::{
10        io::{PrintWriter, StringWriter},
11        lang::{String, Throwable},
12    },
13};
14
15use super::{Level, LogRecord};
16
17// public class java.util.logging.SimpleFormatter
18pub struct SimpleFormatter;
19
20impl SimpleFormatter {
21    pub fn as_proto() -> RuntimeClassProto {
22        RuntimeClassProto {
23            name: "java/util/logging/SimpleFormatter",
24            parent_class: Some("java/util/logging/Formatter"),
25            interfaces: vec![],
26            methods: vec![
27                JavaMethodProto::new("<init>", "()V", Self::init, MethodAccessFlags::PUBLIC),
28                JavaMethodProto::new(
29                    "format",
30                    "(Ljava/util/logging/LogRecord;)Ljava/lang/String;",
31                    Self::format,
32                    MethodAccessFlags::PUBLIC,
33                ),
34            ],
35            fields: vec![],
36            access_flags: ClassAccessFlags::PUBLIC,
37        }
38    }
39
40    async fn init(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<()> {
41        tracing::debug!("java.util.logging.SimpleFormatter::<init>({this:?})");
42
43        jvm.invoke_special(&this, "java/util/logging/Formatter", "<init>", "()V", ()).await
44    }
45
46    async fn format(
47        jvm: &Jvm,
48        _: &mut RuntimeContext,
49        this: ClassInstanceRef<Self>,
50        record: ClassInstanceRef<LogRecord>,
51    ) -> Result<ClassInstanceRef<String>> {
52        tracing::debug!("java.util.logging.SimpleFormatter::format({this:?}, {record:?})");
53
54        if record.is_null() {
55            return Err(jvm.exception("java/lang/NullPointerException", "record").await);
56        }
57
58        let source_class: ClassInstanceRef<String> = jvm
59            .invoke_virtual(&record, "java/util/logging/LogRecord", "getSourceClassName", "()Ljava/lang/String;", ())
60            .await?;
61        let source_method: ClassInstanceRef<String> = jvm
62            .invoke_virtual(&record, "java/util/logging/LogRecord", "getSourceMethodName", "()Ljava/lang/String;", ())
63            .await?;
64        let logger_name: ClassInstanceRef<String> = jvm
65            .invoke_virtual(&record, "java/util/logging/LogRecord", "getLoggerName", "()Ljava/lang/String;", ())
66            .await?;
67        let mut source = if source_class.is_null() {
68            if logger_name.is_null() {
69                RustString::new()
70            } else {
71                JavaLangString::to_rust_string(jvm, &logger_name).await?
72            }
73        } else {
74            JavaLangString::to_rust_string(jvm, &source_class).await?
75        };
76        if !source_method.is_null() {
77            if !source.is_empty() {
78                source.push(' ');
79            }
80            source.push_str(&JavaLangString::to_rust_string(jvm, &source_method).await?);
81        }
82
83        let level: ClassInstanceRef<Level> = jvm
84            .invoke_virtual(&record, "java/util/logging/LogRecord", "getLevel", "()Ljava/util/logging/Level;", ())
85            .await?;
86        let level_name: ClassInstanceRef<String> = jvm
87            .invoke_virtual(&level, "java/util/logging/Level", "getName", "()Ljava/lang/String;", ())
88            .await?;
89        let level_name = JavaLangString::to_rust_string(jvm, &level_name).await?;
90        let message: ClassInstanceRef<String> = jvm
91            .invoke_virtual(
92                &this,
93                "java/util/logging/SimpleFormatter",
94                "formatMessage",
95                "(Ljava/util/logging/LogRecord;)Ljava/lang/String;",
96                (record.clone(),),
97            )
98            .await?;
99        let message = if message.is_null() {
100            RustString::from("null")
101        } else {
102            JavaLangString::to_rust_string(jvm, &message).await?
103        };
104
105        let mut formatted = if source.is_empty() {
106            format!("{level_name}: {message}\n")
107        } else {
108            format!("{source} {level_name}: {message}\n")
109        };
110        let thrown: ClassInstanceRef<Throwable> = jvm
111            .invoke_virtual(&record, "java/util/logging/LogRecord", "getThrown", "()Ljava/lang/Throwable;", ())
112            .await?;
113        if !thrown.is_null() {
114            let string_writer: ClassInstanceRef<StringWriter> = jvm.new_class("java/io/StringWriter", "()V", ()).await?.into();
115            let print_writer: ClassInstanceRef<PrintWriter> = jvm
116                .new_class("java/io/PrintWriter", "(Ljava/io/Writer;)V", (string_writer.clone(),))
117                .await?
118                .into();
119            let _: () = jvm
120                .invoke_virtual(
121                    &thrown,
122                    "java/lang/Throwable",
123                    "printStackTrace",
124                    "(Ljava/io/PrintWriter;)V",
125                    (print_writer,),
126                )
127                .await?;
128            let trace: ClassInstanceRef<String> = jvm
129                .invoke_virtual(&string_writer, "java/lang/Object", "toString", "()Ljava/lang/String;", ())
130                .await?;
131            formatted.push_str(&JavaLangString::to_rust_string(jvm, &trace).await?);
132        }
133
134        Ok(JavaLangString::from_rust_string(jvm, &formatted).await?.into())
135    }
136}