rustjava_runtime/classes/java/util/logging/
formatter.rs1use 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
14pub 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(¶meters).await?;
87 if parameter_count == 0 {
88 return Ok(message);
89 }
90
91 let parameters: Vec<ClassInstanceRef<Object>> = jvm.load_array(¶meters, 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(¶meter, "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}