Skip to main content

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

1use alloc::{vec, vec::Vec};
2
3use jvm::{Array, ClassInstanceRef, Jvm, Result, runtime::JavaLangString};
4use jvm_class_proto::{JavaFieldProto, JavaMethodProto};
5use jvm_types::{ClassAccessFlags, FieldAccessFlags, MethodAccessFlags};
6
7use crate::{
8    RuntimeClassProto, RuntimeContext,
9    classes::java::{
10        lang::{Object, String, Throwable},
11        util::{
12            Vector,
13            logging::{Filter, Handler, Level, LogManager, LogRecord},
14        },
15    },
16};
17
18// public class java.util.logging.Logger
19pub struct Logger;
20
21impl Logger {
22    pub fn as_proto() -> RuntimeClassProto {
23        RuntimeClassProto {
24            name: "java/util/logging/Logger",
25            parent_class: Some("java/lang/Object"),
26            interfaces: vec![],
27            methods: vec![
28                JavaMethodProto::new("<clinit>", "()V", Self::clinit, MethodAccessFlags::STATIC),
29                JavaMethodProto::new(
30                    "<init>",
31                    "(Ljava/lang/String;Ljava/lang/String;)V",
32                    Self::init,
33                    MethodAccessFlags::PROTECTED,
34                ),
35                JavaMethodProto::new(
36                    "getLogger",
37                    "(Ljava/lang/String;)Ljava/util/logging/Logger;",
38                    Self::get_logger,
39                    MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC,
40                ),
41                JavaMethodProto::new(
42                    "getLogger",
43                    "(Ljava/lang/String;Ljava/lang/String;)Ljava/util/logging/Logger;",
44                    Self::get_logger_with_resource_bundle,
45                    MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC,
46                ),
47                JavaMethodProto::new(
48                    "configureResourceBundle",
49                    "(Ljava/lang/String;)V",
50                    Self::configure_resource_bundle,
51                    MethodAccessFlags::PRIVATE | MethodAccessFlags::SYNCHRONIZED,
52                ),
53                JavaMethodProto::new(
54                    "getAnonymousLogger",
55                    "()Ljava/util/logging/Logger;",
56                    Self::get_anonymous_logger,
57                    MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC,
58                ),
59                JavaMethodProto::new(
60                    "getAnonymousLogger",
61                    "(Ljava/lang/String;)Ljava/util/logging/Logger;",
62                    Self::get_anonymous_logger_with_resource_bundle,
63                    MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC,
64                ),
65                JavaMethodProto::new(
66                    "getGlobal",
67                    "()Ljava/util/logging/Logger;",
68                    Self::get_global,
69                    MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC | MethodAccessFlags::FINAL,
70                ),
71                JavaMethodProto::new("getName", "()Ljava/lang/String;", Self::get_name, MethodAccessFlags::PUBLIC),
72                JavaMethodProto::new("getFilter", "()Ljava/util/logging/Filter;", Self::get_filter, MethodAccessFlags::PUBLIC),
73                JavaMethodProto::new(
74                    "setFilter",
75                    "(Ljava/util/logging/Filter;)V",
76                    Self::set_filter,
77                    MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED,
78                ),
79                JavaMethodProto::new("getLevel", "()Ljava/util/logging/Level;", Self::get_level, MethodAccessFlags::PUBLIC),
80                JavaMethodProto::new(
81                    "setLevel",
82                    "(Ljava/util/logging/Level;)V",
83                    Self::set_level,
84                    MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED,
85                ),
86                JavaMethodProto::new("getParent", "()Ljava/util/logging/Logger;", Self::get_parent, MethodAccessFlags::PUBLIC),
87                JavaMethodProto::new(
88                    "setParent",
89                    "(Ljava/util/logging/Logger;)V",
90                    Self::set_parent,
91                    MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED,
92                ),
93                JavaMethodProto::new("getUseParentHandlers", "()Z", Self::get_use_parent_handlers, MethodAccessFlags::PUBLIC),
94                JavaMethodProto::new(
95                    "setUseParentHandlers",
96                    "(Z)V",
97                    Self::set_use_parent_handlers,
98                    MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED,
99                ),
100                JavaMethodProto::new(
101                    "addHandler",
102                    "(Ljava/util/logging/Handler;)V",
103                    Self::add_handler,
104                    MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED,
105                ),
106                JavaMethodProto::new(
107                    "removeHandler",
108                    "(Ljava/util/logging/Handler;)V",
109                    Self::remove_handler,
110                    MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED,
111                ),
112                JavaMethodProto::new(
113                    "getHandlers",
114                    "()[Ljava/util/logging/Handler;",
115                    Self::get_handlers,
116                    MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED,
117                ),
118                JavaMethodProto::new("isLoggable", "(Ljava/util/logging/Level;)Z", Self::is_loggable, MethodAccessFlags::PUBLIC),
119                JavaMethodProto::new("log", "(Ljava/util/logging/LogRecord;)V", Self::log_record, MethodAccessFlags::PUBLIC),
120                JavaMethodProto::new(
121                    "log",
122                    "(Ljava/util/logging/Level;Ljava/lang/String;)V",
123                    Self::log,
124                    MethodAccessFlags::PUBLIC,
125                ),
126                JavaMethodProto::new(
127                    "log",
128                    "(Ljava/util/logging/Level;Ljava/lang/String;Ljava/lang/Object;)V",
129                    Self::log_with_parameter,
130                    MethodAccessFlags::PUBLIC,
131                ),
132                JavaMethodProto::new(
133                    "log",
134                    "(Ljava/util/logging/Level;Ljava/lang/String;[Ljava/lang/Object;)V",
135                    Self::log_with_parameters,
136                    MethodAccessFlags::PUBLIC,
137                ),
138                JavaMethodProto::new(
139                    "log",
140                    "(Ljava/util/logging/Level;Ljava/lang/String;Ljava/lang/Throwable;)V",
141                    Self::log_with_throwable,
142                    MethodAccessFlags::PUBLIC,
143                ),
144                JavaMethodProto::new(
145                    "logp",
146                    "(Ljava/util/logging/Level;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)V",
147                    Self::logp,
148                    MethodAccessFlags::PUBLIC,
149                ),
150                JavaMethodProto::new(
151                    "logp",
152                    "(Ljava/util/logging/Level;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/Object;)V",
153                    Self::logp_with_parameter,
154                    MethodAccessFlags::PUBLIC,
155                ),
156                JavaMethodProto::new(
157                    "logp",
158                    "(Ljava/util/logging/Level;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;[Ljava/lang/Object;)V",
159                    Self::logp_with_parameters,
160                    MethodAccessFlags::PUBLIC,
161                ),
162                JavaMethodProto::new(
163                    "logp",
164                    "(Ljava/util/logging/Level;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/Throwable;)V",
165                    Self::logp_with_throwable,
166                    MethodAccessFlags::PUBLIC,
167                ),
168                JavaMethodProto::new(
169                    "logrb",
170                    "(Ljava/util/logging/Level;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)V",
171                    Self::logrb,
172                    MethodAccessFlags::PUBLIC,
173                ),
174                JavaMethodProto::new(
175                    "logrb",
176                    "(Ljava/util/logging/Level;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/Object;)V",
177                    Self::logrb_with_parameter,
178                    MethodAccessFlags::PUBLIC,
179                ),
180                JavaMethodProto::new(
181                    "logrb",
182                    "(Ljava/util/logging/Level;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;[Ljava/lang/Object;)V",
183                    Self::logrb_with_parameters,
184                    MethodAccessFlags::PUBLIC,
185                ),
186                JavaMethodProto::new(
187                    "logrb",
188                    "(Ljava/util/logging/Level;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/Throwable;)V",
189                    Self::logrb_with_throwable,
190                    MethodAccessFlags::PUBLIC,
191                ),
192                JavaMethodProto::new("severe", "(Ljava/lang/String;)V", Self::severe, MethodAccessFlags::PUBLIC),
193                JavaMethodProto::new("warning", "(Ljava/lang/String;)V", Self::warning, MethodAccessFlags::PUBLIC),
194                JavaMethodProto::new("info", "(Ljava/lang/String;)V", Self::info, MethodAccessFlags::PUBLIC),
195                JavaMethodProto::new("config", "(Ljava/lang/String;)V", Self::config, MethodAccessFlags::PUBLIC),
196                JavaMethodProto::new("fine", "(Ljava/lang/String;)V", Self::fine, MethodAccessFlags::PUBLIC),
197                JavaMethodProto::new("finer", "(Ljava/lang/String;)V", Self::finer, MethodAccessFlags::PUBLIC),
198                JavaMethodProto::new("finest", "(Ljava/lang/String;)V", Self::finest, MethodAccessFlags::PUBLIC),
199                JavaMethodProto::new(
200                    "entering",
201                    "(Ljava/lang/String;Ljava/lang/String;)V",
202                    Self::entering,
203                    MethodAccessFlags::PUBLIC,
204                ),
205                JavaMethodProto::new(
206                    "entering",
207                    "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/Object;)V",
208                    Self::entering_with_parameter,
209                    MethodAccessFlags::PUBLIC,
210                ),
211                JavaMethodProto::new(
212                    "entering",
213                    "(Ljava/lang/String;Ljava/lang/String;[Ljava/lang/Object;)V",
214                    Self::entering_with_parameters,
215                    MethodAccessFlags::PUBLIC,
216                ),
217                JavaMethodProto::new(
218                    "exiting",
219                    "(Ljava/lang/String;Ljava/lang/String;)V",
220                    Self::exiting,
221                    MethodAccessFlags::PUBLIC,
222                ),
223                JavaMethodProto::new(
224                    "exiting",
225                    "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/Object;)V",
226                    Self::exiting_with_result,
227                    MethodAccessFlags::PUBLIC,
228                ),
229                JavaMethodProto::new(
230                    "throwing",
231                    "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/Throwable;)V",
232                    Self::throwing,
233                    MethodAccessFlags::PUBLIC,
234                ),
235                JavaMethodProto::new(
236                    "getResourceBundleName",
237                    "()Ljava/lang/String;",
238                    Self::get_resource_bundle_name,
239                    MethodAccessFlags::PUBLIC,
240                ),
241                JavaMethodProto::new(
242                    "getResourceBundle",
243                    "()Ljava/util/ResourceBundle;",
244                    Self::get_resource_bundle,
245                    MethodAccessFlags::PUBLIC,
246                ),
247                JavaMethodProto::new("reset", "(Z)[Ljava/util/logging/Handler;", Self::reset, MethodAccessFlags::SYNCHRONIZED),
248            ],
249            fields: vec![
250                JavaFieldProto::new(
251                    "global",
252                    "Ljava/util/logging/Logger;",
253                    FieldAccessFlags::PUBLIC | FieldAccessFlags::STATIC | FieldAccessFlags::FINAL,
254                ),
255                JavaFieldProto::new(
256                    "GLOBAL_LOGGER_NAME",
257                    "Ljava/lang/String;",
258                    FieldAccessFlags::PUBLIC | FieldAccessFlags::STATIC | FieldAccessFlags::FINAL,
259                ),
260                JavaFieldProto::new("name", "Ljava/lang/String;", FieldAccessFlags::PRIVATE),
261                JavaFieldProto::new("level", "Ljava/util/logging/Level;", FieldAccessFlags::PRIVATE),
262                JavaFieldProto::new("filter", "Ljava/util/logging/Filter;", FieldAccessFlags::PRIVATE),
263                JavaFieldProto::new("handlers", "Ljava/util/Vector;", FieldAccessFlags::PRIVATE),
264                JavaFieldProto::new("parent", "Ljava/util/logging/Logger;", FieldAccessFlags::PRIVATE),
265                JavaFieldProto::new("useParentHandlers", "Z", FieldAccessFlags::PRIVATE),
266                JavaFieldProto::new("resourceBundleName", "Ljava/lang/String;", FieldAccessFlags::PRIVATE),
267                JavaFieldProto::new("resourceBundle", "Ljava/util/ResourceBundle;", FieldAccessFlags::PRIVATE),
268            ],
269            access_flags: ClassAccessFlags::PUBLIC,
270        }
271    }
272
273    async fn clinit(jvm: &Jvm, _: &mut RuntimeContext) -> Result<()> {
274        tracing::debug!("java.util.logging.Logger::<clinit>()");
275
276        let name = JavaLangString::from_rust_string(jvm, "global").await?;
277        jvm.put_static_field("java/util/logging/Logger", "GLOBAL_LOGGER_NAME", "Ljava/lang/String;", name.clone())
278            .await?;
279        let resource_bundle_name: ClassInstanceRef<String> = None.into();
280        let global = jvm
281            .new_class(
282                "java/util/logging/Logger",
283                "(Ljava/lang/String;Ljava/lang/String;)V",
284                (name.clone(), resource_bundle_name),
285            )
286            .await?;
287        jvm.put_static_field("java/util/logging/Logger", "global", "Ljava/util/logging/Logger;", global)
288            .await
289    }
290
291    async fn init(
292        jvm: &Jvm,
293        _: &mut RuntimeContext,
294        mut this: ClassInstanceRef<Self>,
295        name: ClassInstanceRef<String>,
296        resource_bundle_name: ClassInstanceRef<String>,
297    ) -> Result<()> {
298        tracing::debug!("java.util.logging.Logger::<init>({this:?}, {name:?}, {resource_bundle_name:?})");
299
300        let _: () = jvm.invoke_special(&this, "java/lang/Object", "<init>", "()V", ()).await?;
301        let handlers = jvm.new_class("java/util/Vector", "()V", ()).await?;
302        jvm.put_field(&mut this, "java/util/logging/Logger", "name", "Ljava/lang/String;", name)
303            .await?;
304        jvm.put_field(&mut this, "java/util/logging/Logger", "handlers", "Ljava/util/Vector;", handlers)
305            .await?;
306        jvm.put_field(&mut this, "java/util/logging/Logger", "useParentHandlers", "Z", true)
307            .await?;
308        jvm.put_field(
309            &mut this,
310            "java/util/logging/Logger",
311            "resourceBundleName",
312            "Ljava/lang/String;",
313            resource_bundle_name,
314        )
315        .await
316    }
317
318    async fn get_logger(jvm: &Jvm, _: &mut RuntimeContext, name: ClassInstanceRef<String>) -> Result<ClassInstanceRef<Self>> {
319        tracing::debug!("java.util.logging.Logger::getLogger({name:?})");
320
321        let resource_bundle_name: ClassInstanceRef<String> = None.into();
322        jvm.invoke_static(
323            "java/util/logging/Logger",
324            "getLogger",
325            "(Ljava/lang/String;Ljava/lang/String;)Ljava/util/logging/Logger;",
326            (name, resource_bundle_name),
327        )
328        .await
329    }
330
331    async fn get_logger_with_resource_bundle(
332        jvm: &Jvm,
333        _: &mut RuntimeContext,
334        name: ClassInstanceRef<String>,
335        resource_bundle_name: ClassInstanceRef<String>,
336    ) -> Result<ClassInstanceRef<Self>> {
337        tracing::debug!("java.util.logging.Logger::getLogger({name:?}, {resource_bundle_name:?})");
338
339        if name.is_null() {
340            return Err(jvm.exception("java/lang/NullPointerException", "name").await);
341        }
342
343        let manager: ClassInstanceRef<LogManager> = jvm
344            .invoke_static("java/util/logging/LogManager", "getLogManager", "()Ljava/util/logging/LogManager;", ())
345            .await?;
346        let mut logger: ClassInstanceRef<Self> = jvm
347            .invoke_virtual(
348                &manager,
349                "java/util/logging/LogManager",
350                "getLogger",
351                "(Ljava/lang/String;)Ljava/util/logging/Logger;",
352                (name.clone(),),
353            )
354            .await?;
355        if logger.is_null() {
356            let candidate: ClassInstanceRef<Self> = jvm
357                .new_class(
358                    "java/util/logging/Logger",
359                    "(Ljava/lang/String;Ljava/lang/String;)V",
360                    (name.clone(), resource_bundle_name.clone()),
361                )
362                .await?
363                .into();
364            let added: bool = jvm
365                .invoke_virtual(
366                    &manager,
367                    "java/util/logging/LogManager",
368                    "addLogger",
369                    "(Ljava/util/logging/Logger;)Z",
370                    (candidate.clone(),),
371                )
372                .await?;
373            logger = if added {
374                candidate
375            } else {
376                jvm.invoke_virtual(
377                    &manager,
378                    "java/util/logging/LogManager",
379                    "getLogger",
380                    "(Ljava/lang/String;)Ljava/util/logging/Logger;",
381                    (name,),
382                )
383                .await?
384            };
385        }
386
387        let _: () = jvm
388            .invoke_special(
389                &logger,
390                "java/util/logging/Logger",
391                "configureResourceBundle",
392                "(Ljava/lang/String;)V",
393                (resource_bundle_name,),
394            )
395            .await?;
396        Ok(logger)
397    }
398
399    async fn configure_resource_bundle(
400        jvm: &Jvm,
401        _: &mut RuntimeContext,
402        mut this: ClassInstanceRef<Self>,
403        resource_bundle_name: ClassInstanceRef<String>,
404    ) -> Result<()> {
405        if resource_bundle_name.is_null() {
406            return Ok(());
407        }
408
409        let current: ClassInstanceRef<String> = jvm
410            .get_field(&this, "java/util/logging/Logger", "resourceBundleName", "Ljava/lang/String;")
411            .await?;
412        if current.is_null() {
413            return jvm
414                .put_field(
415                    &mut this,
416                    "java/util/logging/Logger",
417                    "resourceBundleName",
418                    "Ljava/lang/String;",
419                    resource_bundle_name,
420                )
421                .await;
422        }
423        if JavaLangString::to_rust_string(jvm, &current).await? != JavaLangString::to_rust_string(jvm, &resource_bundle_name).await? {
424            return Err(jvm
425                .exception("java/lang/IllegalArgumentException", "logger already uses a different resource bundle")
426                .await);
427        }
428        Ok(())
429    }
430
431    async fn get_anonymous_logger(jvm: &Jvm, _: &mut RuntimeContext) -> Result<ClassInstanceRef<Self>> {
432        tracing::debug!("java.util.logging.Logger::getAnonymousLogger()");
433
434        let resource_bundle_name: ClassInstanceRef<String> = None.into();
435        jvm.invoke_static(
436            "java/util/logging/Logger",
437            "getAnonymousLogger",
438            "(Ljava/lang/String;)Ljava/util/logging/Logger;",
439            (resource_bundle_name,),
440        )
441        .await
442    }
443
444    async fn get_anonymous_logger_with_resource_bundle(
445        jvm: &Jvm,
446        _: &mut RuntimeContext,
447        resource_bundle_name: ClassInstanceRef<String>,
448    ) -> Result<ClassInstanceRef<Self>> {
449        tracing::debug!("java.util.logging.Logger::getAnonymousLogger({resource_bundle_name:?})");
450
451        let name: ClassInstanceRef<String> = None.into();
452        let mut logger: ClassInstanceRef<Self> = jvm
453            .new_class(
454                "java/util/logging/Logger",
455                "(Ljava/lang/String;Ljava/lang/String;)V",
456                (name, resource_bundle_name),
457            )
458            .await?
459            .into();
460        let manager: ClassInstanceRef<LogManager> = jvm
461            .invoke_static("java/util/logging/LogManager", "getLogManager", "()Ljava/util/logging/LogManager;", ())
462            .await?;
463        let root_name = JavaLangString::from_rust_string(jvm, "").await?;
464        let root: ClassInstanceRef<Self> = jvm
465            .invoke_virtual(
466                &manager,
467                "java/util/logging/LogManager",
468                "getLogger",
469                "(Ljava/lang/String;)Ljava/util/logging/Logger;",
470                (root_name,),
471            )
472            .await?;
473        jvm.put_field(&mut logger, "java/util/logging/Logger", "parent", "Ljava/util/logging/Logger;", root)
474            .await?;
475        Ok(logger)
476    }
477
478    async fn get_global(jvm: &Jvm, _: &mut RuntimeContext) -> Result<ClassInstanceRef<Self>> {
479        tracing::debug!("java.util.logging.Logger::getGlobal()");
480        jvm.get_static_field("java/util/logging/Logger", "global", "Ljava/util/logging/Logger;")
481            .await
482    }
483
484    async fn get_name(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<String>> {
485        tracing::debug!("java.util.logging.Logger::getName({this:?})");
486        jvm.get_field(&this, "java/util/logging/Logger", "name", "Ljava/lang/String;").await
487    }
488
489    async fn get_filter(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Filter>> {
490        tracing::debug!("java.util.logging.Logger::getFilter({this:?})");
491        jvm.get_field(&this, "java/util/logging/Logger", "filter", "Ljava/util/logging/Filter;")
492            .await
493    }
494
495    async fn set_filter(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>, filter: ClassInstanceRef<Filter>) -> Result<()> {
496        tracing::debug!("java.util.logging.Logger::setFilter({this:?}, {filter:?})");
497        jvm.put_field(&mut this, "java/util/logging/Logger", "filter", "Ljava/util/logging/Filter;", filter)
498            .await
499    }
500
501    async fn get_level(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Level>> {
502        tracing::debug!("java.util.logging.Logger::getLevel({this:?})");
503        jvm.get_field(&this, "java/util/logging/Logger", "level", "Ljava/util/logging/Level;")
504            .await
505    }
506
507    async fn set_level(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>, level: ClassInstanceRef<Level>) -> Result<()> {
508        tracing::debug!("java.util.logging.Logger::setLevel({this:?}, {level:?})");
509        jvm.put_field(&mut this, "java/util/logging/Logger", "level", "Ljava/util/logging/Level;", level)
510            .await
511    }
512
513    async fn get_parent(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Self>> {
514        tracing::debug!("java.util.logging.Logger::getParent({this:?})");
515        jvm.get_field(&this, "java/util/logging/Logger", "parent", "Ljava/util/logging/Logger;")
516            .await
517    }
518
519    async fn set_parent(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>, parent: ClassInstanceRef<Self>) -> Result<()> {
520        tracing::debug!("java.util.logging.Logger::setParent({this:?}, {parent:?})");
521        if parent.is_null() {
522            return Err(jvm.exception("java/lang/NullPointerException", "parent").await);
523        }
524        jvm.put_field(&mut this, "java/util/logging/Logger", "parent", "Ljava/util/logging/Logger;", parent)
525            .await
526    }
527
528    async fn get_use_parent_handlers(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<bool> {
529        tracing::debug!("java.util.logging.Logger::getUseParentHandlers({this:?})");
530        jvm.get_field(&this, "java/util/logging/Logger", "useParentHandlers", "Z").await
531    }
532
533    async fn set_use_parent_handlers(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>, value: bool) -> Result<()> {
534        tracing::debug!("java.util.logging.Logger::setUseParentHandlers({this:?}, {value})");
535        jvm.put_field(&mut this, "java/util/logging/Logger", "useParentHandlers", "Z", value)
536            .await
537    }
538
539    async fn add_handler(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, handler: ClassInstanceRef<Handler>) -> Result<()> {
540        tracing::debug!("java.util.logging.Logger::addHandler({this:?}, {handler:?})");
541        if handler.is_null() {
542            return Err(jvm.exception("java/lang/NullPointerException", "handler").await);
543        }
544        let handlers: ClassInstanceRef<Vector> = jvm.get_field(&this, "java/util/logging/Logger", "handlers", "Ljava/util/Vector;").await?;
545        jvm.invoke_virtual(&handlers, "java/util/Vector", "addElement", "(Ljava/lang/Object;)V", (handler,))
546            .await
547    }
548
549    async fn remove_handler(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, handler: ClassInstanceRef<Handler>) -> Result<()> {
550        tracing::debug!("java.util.logging.Logger::removeHandler({this:?}, {handler:?})");
551        if handler.is_null() {
552            return Ok(());
553        }
554        let handlers: ClassInstanceRef<Vector> = jvm.get_field(&this, "java/util/logging/Logger", "handlers", "Ljava/util/Vector;").await?;
555        let _: bool = jvm
556            .invoke_virtual(&handlers, "java/util/Vector", "removeElement", "(Ljava/lang/Object;)Z", (handler,))
557            .await?;
558        Ok(())
559    }
560
561    async fn get_handlers(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Array<Handler>>> {
562        tracing::debug!("java.util.logging.Logger::getHandlers({this:?})");
563        let handlers: ClassInstanceRef<Vector> = jvm.get_field(&this, "java/util/logging/Logger", "handlers", "Ljava/util/Vector;").await?;
564        let size: i32 = jvm.invoke_virtual(&handlers, "java/util/Vector", "size", "()I", ()).await?;
565        let mut result: ClassInstanceRef<Array<Handler>> = jvm.instantiate_array("Ljava/util/logging/Handler;", size as usize).await?.into();
566        for index in 0..size {
567            let handler: ClassInstanceRef<Handler> = jvm
568                .invoke_virtual(&handlers, "java/util/Vector", "elementAt", "(I)Ljava/lang/Object;", (index,))
569                .await?;
570            jvm.store_array(&mut result, index as usize, [handler]).await?;
571        }
572        Ok(result)
573    }
574
575    async fn is_loggable(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, level: ClassInstanceRef<Level>) -> Result<bool> {
576        tracing::debug!("java.util.logging.Logger::isLoggable({this:?}, {level:?})");
577        if level.is_null() {
578            return Err(jvm.exception("java/lang/NullPointerException", "level").await);
579        }
580
581        let requested: i32 = jvm.invoke_virtual(&level, "java/util/logging/Level", "intValue", "()I", ()).await?;
582        let mut logger = this;
583        let effective = loop {
584            let configured: ClassInstanceRef<Level> = jvm
585                .get_field(&logger, "java/util/logging/Logger", "level", "Ljava/util/logging/Level;")
586                .await?;
587            if !configured.is_null() {
588                break jvm.invoke_virtual(&configured, "java/util/logging/Level", "intValue", "()I", ()).await?;
589            }
590            let parent: ClassInstanceRef<Self> = jvm
591                .get_field(&logger, "java/util/logging/Logger", "parent", "Ljava/util/logging/Logger;")
592                .await?;
593            if parent.is_null() {
594                let info: ClassInstanceRef<Level> = jvm
595                    .get_static_field("java/util/logging/Level", "INFO", "Ljava/util/logging/Level;")
596                    .await?;
597                break jvm.invoke_virtual(&info, "java/util/logging/Level", "intValue", "()I", ()).await?;
598            }
599            logger = parent;
600        };
601
602        Ok(effective != i32::MAX && requested >= effective)
603    }
604
605    async fn log_record(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, mut record: ClassInstanceRef<LogRecord>) -> Result<()> {
606        tracing::debug!("java.util.logging.Logger::log({this:?}, {record:?})");
607        if record.is_null() {
608            return Err(jvm.exception("java/lang/NullPointerException", "record").await);
609        }
610        let level: ClassInstanceRef<Level> = jvm
611            .invoke_virtual(&record, "java/util/logging/LogRecord", "getLevel", "()Ljava/util/logging/Level;", ())
612            .await?;
613        if !jvm
614            .invoke_virtual::<_, bool>(&this, "java/util/logging/Logger", "isLoggable", "(Ljava/util/logging/Level;)Z", (level,))
615            .await?
616        {
617            return Ok(());
618        }
619
620        let filter: ClassInstanceRef<Filter> = jvm
621            .get_field(&this, "java/util/logging/Logger", "filter", "Ljava/util/logging/Filter;")
622            .await?;
623        if !filter.is_null()
624            && !jvm
625                .invoke_virtual::<_, bool>(
626                    &filter,
627                    &filter.class_definition().name(),
628                    "isLoggable",
629                    "(Ljava/util/logging/LogRecord;)Z",
630                    (record.clone(),),
631                )
632                .await?
633        {
634            return Ok(());
635        }
636
637        let logger_name: ClassInstanceRef<String> = jvm
638            .invoke_virtual(&record, "java/util/logging/LogRecord", "getLoggerName", "()Ljava/lang/String;", ())
639            .await?;
640        if logger_name.is_null() {
641            let name: ClassInstanceRef<String> = jvm.get_field(&this, "java/util/logging/Logger", "name", "Ljava/lang/String;").await?;
642            jvm.put_field(&mut record, "java/util/logging/LogRecord", "loggerName", "Ljava/lang/String;", name)
643                .await?;
644        }
645
646        let mut logger = this;
647        loop {
648            let handlers: ClassInstanceRef<Array<Handler>> = jvm
649                .invoke_virtual(&logger, "java/util/logging/Logger", "getHandlers", "()[Ljava/util/logging/Handler;", ())
650                .await?;
651            let length = jvm.array_length(&handlers).await?;
652            let handlers: Vec<ClassInstanceRef<Handler>> = jvm.load_array(&handlers, 0, length).await?;
653            for handler in handlers {
654                let _: () = jvm
655                    .invoke_virtual(
656                        &handler,
657                        "java/util/logging/Handler",
658                        "publish",
659                        "(Ljava/util/logging/LogRecord;)V",
660                        (record.clone(),),
661                    )
662                    .await?;
663            }
664
665            let use_parent: bool = jvm.get_field(&logger, "java/util/logging/Logger", "useParentHandlers", "Z").await?;
666            if !use_parent {
667                break;
668            }
669            let parent: ClassInstanceRef<Self> = jvm
670                .get_field(&logger, "java/util/logging/Logger", "parent", "Ljava/util/logging/Logger;")
671                .await?;
672            if parent.is_null() {
673                break;
674            }
675            logger = parent;
676        }
677        Ok(())
678    }
679
680    async fn log(
681        jvm: &Jvm,
682        _: &mut RuntimeContext,
683        this: ClassInstanceRef<Self>,
684        level: ClassInstanceRef<Level>,
685        message: ClassInstanceRef<String>,
686    ) -> Result<()> {
687        let parameters: ClassInstanceRef<Array<Object>> = None.into();
688        let thrown: ClassInstanceRef<Throwable> = None.into();
689        let source_class: ClassInstanceRef<String> = None.into();
690        let source_method: ClassInstanceRef<String> = None.into();
691        let resource_bundle_name: ClassInstanceRef<String> = None.into();
692        Self::log_values(
693            jvm,
694            this,
695            level,
696            message,
697            parameters,
698            thrown,
699            source_class,
700            source_method,
701            resource_bundle_name,
702        )
703        .await
704    }
705
706    async fn log_with_parameter(
707        jvm: &Jvm,
708        _: &mut RuntimeContext,
709        this: ClassInstanceRef<Self>,
710        level: ClassInstanceRef<Level>,
711        message: ClassInstanceRef<String>,
712        parameter: ClassInstanceRef<Object>,
713    ) -> Result<()> {
714        let mut parameters: ClassInstanceRef<Array<Object>> = jvm.instantiate_array("Ljava/lang/Object;", 1).await?.into();
715        jvm.store_array(&mut parameters, 0, [parameter]).await?;
716        let thrown: ClassInstanceRef<Throwable> = None.into();
717        let source_class: ClassInstanceRef<String> = None.into();
718        let source_method: ClassInstanceRef<String> = None.into();
719        let resource_bundle_name: ClassInstanceRef<String> = None.into();
720        Self::log_values(
721            jvm,
722            this,
723            level,
724            message,
725            parameters,
726            thrown,
727            source_class,
728            source_method,
729            resource_bundle_name,
730        )
731        .await
732    }
733
734    async fn log_with_parameters(
735        jvm: &Jvm,
736        _: &mut RuntimeContext,
737        this: ClassInstanceRef<Self>,
738        level: ClassInstanceRef<Level>,
739        message: ClassInstanceRef<String>,
740        parameters: ClassInstanceRef<Array<Object>>,
741    ) -> Result<()> {
742        let thrown: ClassInstanceRef<Throwable> = None.into();
743        let source_class: ClassInstanceRef<String> = None.into();
744        let source_method: ClassInstanceRef<String> = None.into();
745        let resource_bundle_name: ClassInstanceRef<String> = None.into();
746        Self::log_values(
747            jvm,
748            this,
749            level,
750            message,
751            parameters,
752            thrown,
753            source_class,
754            source_method,
755            resource_bundle_name,
756        )
757        .await
758    }
759
760    async fn log_with_throwable(
761        jvm: &Jvm,
762        _: &mut RuntimeContext,
763        this: ClassInstanceRef<Self>,
764        level: ClassInstanceRef<Level>,
765        message: ClassInstanceRef<String>,
766        thrown: ClassInstanceRef<Throwable>,
767    ) -> Result<()> {
768        let parameters: ClassInstanceRef<Array<Object>> = None.into();
769        let source_class: ClassInstanceRef<String> = None.into();
770        let source_method: ClassInstanceRef<String> = None.into();
771        let resource_bundle_name: ClassInstanceRef<String> = None.into();
772        Self::log_values(
773            jvm,
774            this,
775            level,
776            message,
777            parameters,
778            thrown,
779            source_class,
780            source_method,
781            resource_bundle_name,
782        )
783        .await
784    }
785
786    async fn logp(
787        jvm: &Jvm,
788        _: &mut RuntimeContext,
789        this: ClassInstanceRef<Self>,
790        level: ClassInstanceRef<Level>,
791        source_class: ClassInstanceRef<String>,
792        source_method: ClassInstanceRef<String>,
793        message: ClassInstanceRef<String>,
794    ) -> Result<()> {
795        let parameters: ClassInstanceRef<Array<Object>> = None.into();
796        let thrown: ClassInstanceRef<Throwable> = None.into();
797        let resource_bundle_name: ClassInstanceRef<String> = None.into();
798        Self::log_values(
799            jvm,
800            this,
801            level,
802            message,
803            parameters,
804            thrown,
805            source_class,
806            source_method,
807            resource_bundle_name,
808        )
809        .await
810    }
811
812    #[allow(clippy::too_many_arguments)]
813    async fn logp_with_parameter(
814        jvm: &Jvm,
815        _: &mut RuntimeContext,
816        this: ClassInstanceRef<Self>,
817        level: ClassInstanceRef<Level>,
818        source_class: ClassInstanceRef<String>,
819        source_method: ClassInstanceRef<String>,
820        message: ClassInstanceRef<String>,
821        parameter: ClassInstanceRef<Object>,
822    ) -> Result<()> {
823        let mut parameters: ClassInstanceRef<Array<Object>> = jvm.instantiate_array("Ljava/lang/Object;", 1).await?.into();
824        jvm.store_array(&mut parameters, 0, [parameter]).await?;
825        let thrown: ClassInstanceRef<Throwable> = None.into();
826        let resource_bundle_name: ClassInstanceRef<String> = None.into();
827        Self::log_values(
828            jvm,
829            this,
830            level,
831            message,
832            parameters,
833            thrown,
834            source_class,
835            source_method,
836            resource_bundle_name,
837        )
838        .await
839    }
840
841    #[allow(clippy::too_many_arguments)]
842    async fn logp_with_parameters(
843        jvm: &Jvm,
844        _: &mut RuntimeContext,
845        this: ClassInstanceRef<Self>,
846        level: ClassInstanceRef<Level>,
847        source_class: ClassInstanceRef<String>,
848        source_method: ClassInstanceRef<String>,
849        message: ClassInstanceRef<String>,
850        parameters: ClassInstanceRef<Array<Object>>,
851    ) -> Result<()> {
852        let thrown: ClassInstanceRef<Throwable> = None.into();
853        let resource_bundle_name: ClassInstanceRef<String> = None.into();
854        Self::log_values(
855            jvm,
856            this,
857            level,
858            message,
859            parameters,
860            thrown,
861            source_class,
862            source_method,
863            resource_bundle_name,
864        )
865        .await
866    }
867
868    #[allow(clippy::too_many_arguments)]
869    async fn logp_with_throwable(
870        jvm: &Jvm,
871        _: &mut RuntimeContext,
872        this: ClassInstanceRef<Self>,
873        level: ClassInstanceRef<Level>,
874        source_class: ClassInstanceRef<String>,
875        source_method: ClassInstanceRef<String>,
876        message: ClassInstanceRef<String>,
877        thrown: ClassInstanceRef<Throwable>,
878    ) -> Result<()> {
879        let parameters: ClassInstanceRef<Array<Object>> = None.into();
880        let resource_bundle_name: ClassInstanceRef<String> = None.into();
881        Self::log_values(
882            jvm,
883            this,
884            level,
885            message,
886            parameters,
887            thrown,
888            source_class,
889            source_method,
890            resource_bundle_name,
891        )
892        .await
893    }
894
895    #[allow(clippy::too_many_arguments)]
896    async fn logrb(
897        jvm: &Jvm,
898        _: &mut RuntimeContext,
899        this: ClassInstanceRef<Self>,
900        level: ClassInstanceRef<Level>,
901        source_class: ClassInstanceRef<String>,
902        source_method: ClassInstanceRef<String>,
903        resource_bundle_name: ClassInstanceRef<String>,
904        message: ClassInstanceRef<String>,
905    ) -> Result<()> {
906        let parameters: ClassInstanceRef<Array<Object>> = None.into();
907        let thrown: ClassInstanceRef<Throwable> = None.into();
908        Self::log_values(
909            jvm,
910            this,
911            level,
912            message,
913            parameters,
914            thrown,
915            source_class,
916            source_method,
917            resource_bundle_name,
918        )
919        .await
920    }
921
922    #[allow(clippy::too_many_arguments)]
923    async fn logrb_with_parameter(
924        jvm: &Jvm,
925        _: &mut RuntimeContext,
926        this: ClassInstanceRef<Self>,
927        level: ClassInstanceRef<Level>,
928        source_class: ClassInstanceRef<String>,
929        source_method: ClassInstanceRef<String>,
930        resource_bundle_name: ClassInstanceRef<String>,
931        message: ClassInstanceRef<String>,
932        parameter: ClassInstanceRef<Object>,
933    ) -> Result<()> {
934        let mut parameters: ClassInstanceRef<Array<Object>> = jvm.instantiate_array("Ljava/lang/Object;", 1).await?.into();
935        jvm.store_array(&mut parameters, 0, [parameter]).await?;
936        let thrown: ClassInstanceRef<Throwable> = None.into();
937        Self::log_values(
938            jvm,
939            this,
940            level,
941            message,
942            parameters,
943            thrown,
944            source_class,
945            source_method,
946            resource_bundle_name,
947        )
948        .await
949    }
950
951    #[allow(clippy::too_many_arguments)]
952    async fn logrb_with_parameters(
953        jvm: &Jvm,
954        _: &mut RuntimeContext,
955        this: ClassInstanceRef<Self>,
956        level: ClassInstanceRef<Level>,
957        source_class: ClassInstanceRef<String>,
958        source_method: ClassInstanceRef<String>,
959        resource_bundle_name: ClassInstanceRef<String>,
960        message: ClassInstanceRef<String>,
961        parameters: ClassInstanceRef<Array<Object>>,
962    ) -> Result<()> {
963        let thrown: ClassInstanceRef<Throwable> = None.into();
964        Self::log_values(
965            jvm,
966            this,
967            level,
968            message,
969            parameters,
970            thrown,
971            source_class,
972            source_method,
973            resource_bundle_name,
974        )
975        .await
976    }
977
978    #[allow(clippy::too_many_arguments)]
979    async fn logrb_with_throwable(
980        jvm: &Jvm,
981        _: &mut RuntimeContext,
982        this: ClassInstanceRef<Self>,
983        level: ClassInstanceRef<Level>,
984        source_class: ClassInstanceRef<String>,
985        source_method: ClassInstanceRef<String>,
986        resource_bundle_name: ClassInstanceRef<String>,
987        message: ClassInstanceRef<String>,
988        thrown: ClassInstanceRef<Throwable>,
989    ) -> Result<()> {
990        let parameters: ClassInstanceRef<Array<Object>> = None.into();
991        Self::log_values(
992            jvm,
993            this,
994            level,
995            message,
996            parameters,
997            thrown,
998            source_class,
999            source_method,
1000            resource_bundle_name,
1001        )
1002        .await
1003    }
1004
1005    async fn severe(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, message: ClassInstanceRef<String>) -> Result<()> {
1006        Self::log_at(jvm, this, "SEVERE", message).await
1007    }
1008
1009    async fn warning(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, message: ClassInstanceRef<String>) -> Result<()> {
1010        Self::log_at(jvm, this, "WARNING", message).await
1011    }
1012
1013    async fn info(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, message: ClassInstanceRef<String>) -> Result<()> {
1014        Self::log_at(jvm, this, "INFO", message).await
1015    }
1016
1017    async fn config(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, message: ClassInstanceRef<String>) -> Result<()> {
1018        Self::log_at(jvm, this, "CONFIG", message).await
1019    }
1020
1021    async fn fine(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, message: ClassInstanceRef<String>) -> Result<()> {
1022        Self::log_at(jvm, this, "FINE", message).await
1023    }
1024
1025    async fn finer(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, message: ClassInstanceRef<String>) -> Result<()> {
1026        Self::log_at(jvm, this, "FINER", message).await
1027    }
1028
1029    async fn finest(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, message: ClassInstanceRef<String>) -> Result<()> {
1030        Self::log_at(jvm, this, "FINEST", message).await
1031    }
1032
1033    async fn entering(
1034        jvm: &Jvm,
1035        _: &mut RuntimeContext,
1036        this: ClassInstanceRef<Self>,
1037        source_class: ClassInstanceRef<String>,
1038        source_method: ClassInstanceRef<String>,
1039    ) -> Result<()> {
1040        let level = jvm
1041            .get_static_field("java/util/logging/Level", "FINER", "Ljava/util/logging/Level;")
1042            .await?;
1043        let message: ClassInstanceRef<String> = JavaLangString::from_rust_string(jvm, "ENTRY").await?.into();
1044        let parameters: ClassInstanceRef<Array<Object>> = None.into();
1045        let thrown: ClassInstanceRef<Throwable> = None.into();
1046        let resource_bundle_name: ClassInstanceRef<String> = None.into();
1047        Self::log_values(
1048            jvm,
1049            this,
1050            level,
1051            message,
1052            parameters,
1053            thrown,
1054            source_class,
1055            source_method,
1056            resource_bundle_name,
1057        )
1058        .await
1059    }
1060
1061    async fn entering_with_parameter(
1062        jvm: &Jvm,
1063        _: &mut RuntimeContext,
1064        this: ClassInstanceRef<Self>,
1065        source_class: ClassInstanceRef<String>,
1066        source_method: ClassInstanceRef<String>,
1067        parameter: ClassInstanceRef<Object>,
1068    ) -> Result<()> {
1069        let level = jvm
1070            .get_static_field("java/util/logging/Level", "FINER", "Ljava/util/logging/Level;")
1071            .await?;
1072        let message: ClassInstanceRef<String> = JavaLangString::from_rust_string(jvm, "ENTRY {0}").await?.into();
1073        let mut parameters: ClassInstanceRef<Array<Object>> = jvm.instantiate_array("Ljava/lang/Object;", 1).await?.into();
1074        jvm.store_array(&mut parameters, 0, [parameter]).await?;
1075        let thrown: ClassInstanceRef<Throwable> = None.into();
1076        let resource_bundle_name: ClassInstanceRef<String> = None.into();
1077        Self::log_values(
1078            jvm,
1079            this,
1080            level,
1081            message,
1082            parameters,
1083            thrown,
1084            source_class,
1085            source_method,
1086            resource_bundle_name,
1087        )
1088        .await
1089    }
1090
1091    async fn entering_with_parameters(
1092        jvm: &Jvm,
1093        _: &mut RuntimeContext,
1094        this: ClassInstanceRef<Self>,
1095        source_class: ClassInstanceRef<String>,
1096        source_method: ClassInstanceRef<String>,
1097        parameters: ClassInstanceRef<Array<Object>>,
1098    ) -> Result<()> {
1099        let level = jvm
1100            .get_static_field("java/util/logging/Level", "FINER", "Ljava/util/logging/Level;")
1101            .await?;
1102        let message: ClassInstanceRef<String> = JavaLangString::from_rust_string(jvm, "ENTRY").await?.into();
1103        let thrown: ClassInstanceRef<Throwable> = None.into();
1104        let resource_bundle_name: ClassInstanceRef<String> = None.into();
1105        Self::log_values(
1106            jvm,
1107            this,
1108            level,
1109            message,
1110            parameters,
1111            thrown,
1112            source_class,
1113            source_method,
1114            resource_bundle_name,
1115        )
1116        .await
1117    }
1118
1119    async fn exiting(
1120        jvm: &Jvm,
1121        _: &mut RuntimeContext,
1122        this: ClassInstanceRef<Self>,
1123        source_class: ClassInstanceRef<String>,
1124        source_method: ClassInstanceRef<String>,
1125    ) -> Result<()> {
1126        let level = jvm
1127            .get_static_field("java/util/logging/Level", "FINER", "Ljava/util/logging/Level;")
1128            .await?;
1129        let message: ClassInstanceRef<String> = JavaLangString::from_rust_string(jvm, "RETURN").await?.into();
1130        let parameters: ClassInstanceRef<Array<Object>> = None.into();
1131        let thrown: ClassInstanceRef<Throwable> = None.into();
1132        let resource_bundle_name: ClassInstanceRef<String> = None.into();
1133        Self::log_values(
1134            jvm,
1135            this,
1136            level,
1137            message,
1138            parameters,
1139            thrown,
1140            source_class,
1141            source_method,
1142            resource_bundle_name,
1143        )
1144        .await
1145    }
1146
1147    async fn exiting_with_result(
1148        jvm: &Jvm,
1149        _: &mut RuntimeContext,
1150        this: ClassInstanceRef<Self>,
1151        source_class: ClassInstanceRef<String>,
1152        source_method: ClassInstanceRef<String>,
1153        result: ClassInstanceRef<Object>,
1154    ) -> Result<()> {
1155        let level = jvm
1156            .get_static_field("java/util/logging/Level", "FINER", "Ljava/util/logging/Level;")
1157            .await?;
1158        let message: ClassInstanceRef<String> = JavaLangString::from_rust_string(jvm, "RETURN {0}").await?.into();
1159        let mut parameters: ClassInstanceRef<Array<Object>> = jvm.instantiate_array("Ljava/lang/Object;", 1).await?.into();
1160        jvm.store_array(&mut parameters, 0, [result]).await?;
1161        let thrown: ClassInstanceRef<Throwable> = None.into();
1162        let resource_bundle_name: ClassInstanceRef<String> = None.into();
1163        Self::log_values(
1164            jvm,
1165            this,
1166            level,
1167            message,
1168            parameters,
1169            thrown,
1170            source_class,
1171            source_method,
1172            resource_bundle_name,
1173        )
1174        .await
1175    }
1176
1177    async fn throwing(
1178        jvm: &Jvm,
1179        _: &mut RuntimeContext,
1180        this: ClassInstanceRef<Self>,
1181        source_class: ClassInstanceRef<String>,
1182        source_method: ClassInstanceRef<String>,
1183        thrown: ClassInstanceRef<Throwable>,
1184    ) -> Result<()> {
1185        let level = jvm
1186            .get_static_field("java/util/logging/Level", "FINER", "Ljava/util/logging/Level;")
1187            .await?;
1188        let message: ClassInstanceRef<String> = JavaLangString::from_rust_string(jvm, "THROW").await?.into();
1189        let parameters: ClassInstanceRef<Array<Object>> = None.into();
1190        let resource_bundle_name: ClassInstanceRef<String> = None.into();
1191        Self::log_values(
1192            jvm,
1193            this,
1194            level,
1195            message,
1196            parameters,
1197            thrown,
1198            source_class,
1199            source_method,
1200            resource_bundle_name,
1201        )
1202        .await
1203    }
1204
1205    async fn get_resource_bundle_name(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<String>> {
1206        tracing::debug!("java.util.logging.Logger::getResourceBundleName({this:?})");
1207        jvm.get_field(&this, "java/util/logging/Logger", "resourceBundleName", "Ljava/lang/String;")
1208            .await
1209    }
1210
1211    async fn get_resource_bundle(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Object>> {
1212        tracing::debug!("java.util.logging.Logger::getResourceBundle({this:?})");
1213        jvm.get_field(&this, "java/util/logging/Logger", "resourceBundle", "Ljava/util/ResourceBundle;")
1214            .await
1215    }
1216
1217    async fn reset(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>, root: bool) -> Result<ClassInstanceRef<Array<Handler>>> {
1218        let handlers: ClassInstanceRef<Vector> = jvm.get_field(&this, "java/util/logging/Logger", "handlers", "Ljava/util/Vector;").await?;
1219        let size: i32 = jvm.invoke_virtual(&handlers, "java/util/Vector", "size", "()I", ()).await?;
1220        let mut removed: ClassInstanceRef<Array<Handler>> = jvm.instantiate_array("Ljava/util/logging/Handler;", size as usize).await?.into();
1221        for index in 0..size {
1222            let handler: ClassInstanceRef<Handler> = jvm
1223                .invoke_virtual(&handlers, "java/util/Vector", "elementAt", "(I)Ljava/lang/Object;", (index,))
1224                .await?;
1225            jvm.store_array(&mut removed, index as usize, [handler]).await?;
1226        }
1227        let _: () = jvm.invoke_virtual(&handlers, "java/util/Vector", "removeAllElements", "()V", ()).await?;
1228
1229        let level: ClassInstanceRef<Level> = if root {
1230            jvm.get_static_field("java/util/logging/Level", "INFO", "Ljava/util/logging/Level;")
1231                .await?
1232        } else {
1233            None.into()
1234        };
1235        jvm.put_field(&mut this, "java/util/logging/Logger", "level", "Ljava/util/logging/Level;", level)
1236            .await?;
1237        Ok(removed)
1238    }
1239
1240    async fn log_at(jvm: &Jvm, this: ClassInstanceRef<Self>, field: &str, message: ClassInstanceRef<String>) -> Result<()> {
1241        let level: ClassInstanceRef<Level> = jvm
1242            .get_static_field("java/util/logging/Level", field, "Ljava/util/logging/Level;")
1243            .await?;
1244        jvm.invoke_virtual(
1245            &this,
1246            "java/util/logging/Logger",
1247            "log",
1248            "(Ljava/util/logging/Level;Ljava/lang/String;)V",
1249            (level, message),
1250        )
1251        .await
1252    }
1253
1254    #[allow(clippy::too_many_arguments)]
1255    async fn log_values(
1256        jvm: &Jvm,
1257        this: ClassInstanceRef<Self>,
1258        level: ClassInstanceRef<Level>,
1259        message: ClassInstanceRef<String>,
1260        parameters: ClassInstanceRef<Array<Object>>,
1261        thrown: ClassInstanceRef<Throwable>,
1262        source_class: ClassInstanceRef<String>,
1263        source_method: ClassInstanceRef<String>,
1264        resource_bundle_name: ClassInstanceRef<String>,
1265    ) -> Result<()> {
1266        if !jvm
1267            .invoke_virtual::<_, bool>(
1268                &this,
1269                "java/util/logging/Logger",
1270                "isLoggable",
1271                "(Ljava/util/logging/Level;)Z",
1272                (level.clone(),),
1273            )
1274            .await?
1275        {
1276            return Ok(());
1277        }
1278
1279        let mut record: ClassInstanceRef<LogRecord> = jvm
1280            .new_class(
1281                "java/util/logging/LogRecord",
1282                "(Ljava/util/logging/Level;Ljava/lang/String;)V",
1283                (level, message),
1284            )
1285            .await?
1286            .into();
1287        if !parameters.is_null() {
1288            jvm.put_field(
1289                &mut record,
1290                "java/util/logging/LogRecord",
1291                "parameters",
1292                "[Ljava/lang/Object;",
1293                parameters,
1294            )
1295            .await?;
1296        }
1297        if !thrown.is_null() {
1298            jvm.put_field(&mut record, "java/util/logging/LogRecord", "thrown", "Ljava/lang/Throwable;", thrown)
1299                .await?;
1300        }
1301        if !source_class.is_null() {
1302            jvm.put_field(
1303                &mut record,
1304                "java/util/logging/LogRecord",
1305                "sourceClassName",
1306                "Ljava/lang/String;",
1307                source_class,
1308            )
1309            .await?;
1310        }
1311        if !source_method.is_null() {
1312            jvm.put_field(
1313                &mut record,
1314                "java/util/logging/LogRecord",
1315                "sourceMethodName",
1316                "Ljava/lang/String;",
1317                source_method,
1318            )
1319            .await?;
1320        }
1321        if !resource_bundle_name.is_null() {
1322            jvm.put_field(
1323                &mut record,
1324                "java/util/logging/LogRecord",
1325                "resourceBundleName",
1326                "Ljava/lang/String;",
1327                resource_bundle_name,
1328            )
1329            .await?;
1330        }
1331        jvm.invoke_virtual(&this, "java/util/logging/Logger", "log", "(Ljava/util/logging/LogRecord;)V", (record,))
1332            .await
1333    }
1334}