Skip to main content

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

1use alloc::{string::String as RustString, vec, vec::Vec};
2
3use jvm::{Array, ClassInstanceRef, Jvm, Result, runtime::JavaLangString};
4use jvm_class_proto::JavaMethodProto;
5use jvm_types::{ClassAccessFlags, MethodAccessFlags};
6
7use crate::{
8    RuntimeClassProto, RuntimeContext,
9    classes::java::lang::{Object, String},
10};
11
12use super::LogRecord;
13
14// public abstract class java.util.logging.Formatter
15pub struct Formatter;
16
17impl Formatter {
18    pub fn as_proto() -> RuntimeClassProto {
19        RuntimeClassProto {
20            name: "java/util/logging/Formatter",
21            parent_class: Some("java/lang/Object"),
22            interfaces: vec![],
23            methods: vec![
24                JavaMethodProto::new("<init>", "()V", Self::init, MethodAccessFlags::PROTECTED),
25                JavaMethodProto::new_abstract(
26                    "format",
27                    "(Ljava/util/logging/LogRecord;)Ljava/lang/String;",
28                    MethodAccessFlags::PUBLIC | MethodAccessFlags::ABSTRACT,
29                ),
30                JavaMethodProto::new(
31                    "formatMessage",
32                    "(Ljava/util/logging/LogRecord;)Ljava/lang/String;",
33                    Self::format_message,
34                    MethodAccessFlags::PUBLIC,
35                ),
36                JavaMethodProto::new(
37                    "getHead",
38                    "(Ljava/util/logging/Handler;)Ljava/lang/String;",
39                    Self::get_head,
40                    MethodAccessFlags::PUBLIC,
41                ),
42                JavaMethodProto::new(
43                    "getTail",
44                    "(Ljava/util/logging/Handler;)Ljava/lang/String;",
45                    Self::get_tail,
46                    MethodAccessFlags::PUBLIC,
47                ),
48            ],
49            fields: vec![],
50            access_flags: ClassAccessFlags::PUBLIC | ClassAccessFlags::ABSTRACT,
51        }
52    }
53
54    async fn init(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<()> {
55        tracing::debug!("java.util.logging.Formatter::<init>({this:?})");
56
57        jvm.invoke_special(&this, "java/lang/Object", "<init>", "()V", ()).await
58    }
59
60    async fn format_message(
61        jvm: &Jvm,
62        _: &mut RuntimeContext,
63        this: ClassInstanceRef<Self>,
64        record: ClassInstanceRef<LogRecord>,
65    ) -> Result<ClassInstanceRef<String>> {
66        tracing::debug!("java.util.logging.Formatter::formatMessage({this:?}, {record:?})");
67
68        if record.is_null() {
69            return Err(jvm.exception("java/lang/NullPointerException", "record").await);
70        }
71
72        let message: ClassInstanceRef<String> = jvm
73            .invoke_virtual(&record, "java/util/logging/LogRecord", "getMessage", "()Ljava/lang/String;", ())
74            .await?;
75        if message.is_null() {
76            return Ok(message);
77        }
78
79        let parameters: ClassInstanceRef<Array<Object>> = jvm
80            .invoke_virtual(&record, "java/util/logging/LogRecord", "getParameters", "()[Ljava/lang/Object;", ())
81            .await?;
82        if parameters.is_null() {
83            return Ok(message);
84        }
85
86        let parameter_count = jvm.array_length(&parameters).await?;
87        if parameter_count == 0 {
88            return Ok(message);
89        }
90
91        let parameters: Vec<ClassInstanceRef<Object>> = jvm.load_array(&parameters, 0, parameter_count).await?;
92        let mut replacements = Vec::with_capacity(parameter_count);
93        for parameter in parameters {
94            replacements.push(if parameter.is_null() {
95                RustString::from("null")
96            } else {
97                let value: ClassInstanceRef<String> = jvm
98                    .invoke_virtual(&parameter, "java/lang/Object", "toString", "()Ljava/lang/String;", ())
99                    .await?;
100                if value.is_null() {
101                    RustString::from("null")
102                } else {
103                    JavaLangString::to_rust_string(jvm, &value).await?
104                }
105            });
106        }
107
108        let message = JavaLangString::to_rust_string(jvm, &message).await?;
109        let characters: Vec<char> = message.chars().collect();
110        let mut formatted = RustString::new();
111        let mut index = 0;
112        while index < characters.len() {
113            if characters[index] == '{' {
114                let mut cursor = index + 1;
115                let mut parameter_index = Some(0usize);
116                let mut has_digit = false;
117                while cursor < characters.len() && characters[cursor].is_ascii_digit() {
118                    has_digit = true;
119                    let digit = (characters[cursor] as u8 - b'0') as usize;
120                    parameter_index = parameter_index.and_then(|value| value.checked_mul(10)?.checked_add(digit));
121                    cursor += 1;
122                }
123                if has_digit && cursor < characters.len() && characters[cursor] == '}' {
124                    if let Some(replacement) = parameter_index.and_then(|parameter_index| replacements.get(parameter_index)) {
125                        formatted.push_str(replacement);
126                    } else {
127                        formatted.extend(&characters[index..=cursor]);
128                    }
129                    index = cursor + 1;
130                    continue;
131                }
132            }
133            formatted.push(characters[index]);
134            index += 1;
135        }
136
137        Ok(JavaLangString::from_rust_string(jvm, &formatted).await?.into())
138    }
139
140    async fn get_head(
141        jvm: &Jvm,
142        _: &mut RuntimeContext,
143        this: ClassInstanceRef<Self>,
144        _: ClassInstanceRef<super::Handler>,
145    ) -> Result<ClassInstanceRef<String>> {
146        tracing::debug!("java.util.logging.Formatter::getHead({this:?})");
147
148        Ok(JavaLangString::from_rust_string(jvm, "").await?.into())
149    }
150
151    async fn get_tail(
152        jvm: &Jvm,
153        _: &mut RuntimeContext,
154        this: ClassInstanceRef<Self>,
155        _: ClassInstanceRef<super::Handler>,
156    ) -> Result<ClassInstanceRef<String>> {
157        tracing::debug!("java.util.logging.Formatter::getTail({this:?})");
158
159        Ok(JavaLangString::from_rust_string(jvm, "").await?.into())
160    }
161}