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, "name", "Ljava/lang/String;", name).await?;
303        jvm.put_field(&mut this, "handlers", "Ljava/util/Vector;", handlers).await?;
304        jvm.put_field(&mut this, "useParentHandlers", "Z", true).await?;
305        jvm.put_field(&mut this, "resourceBundleName", "Ljava/lang/String;", resource_bundle_name)
306            .await
307    }
308
309    async fn get_logger(jvm: &Jvm, _: &mut RuntimeContext, name: ClassInstanceRef<String>) -> Result<ClassInstanceRef<Self>> {
310        tracing::debug!("java.util.logging.Logger::getLogger({name:?})");
311
312        let resource_bundle_name: ClassInstanceRef<String> = None.into();
313        jvm.invoke_static(
314            "java/util/logging/Logger",
315            "getLogger",
316            "(Ljava/lang/String;Ljava/lang/String;)Ljava/util/logging/Logger;",
317            (name, resource_bundle_name),
318        )
319        .await
320    }
321
322    async fn get_logger_with_resource_bundle(
323        jvm: &Jvm,
324        _: &mut RuntimeContext,
325        name: ClassInstanceRef<String>,
326        resource_bundle_name: ClassInstanceRef<String>,
327    ) -> Result<ClassInstanceRef<Self>> {
328        tracing::debug!("java.util.logging.Logger::getLogger({name:?}, {resource_bundle_name:?})");
329
330        if name.is_null() {
331            return Err(jvm.exception("java/lang/NullPointerException", "name").await);
332        }
333
334        let manager: ClassInstanceRef<LogManager> = jvm
335            .invoke_static("java/util/logging/LogManager", "getLogManager", "()Ljava/util/logging/LogManager;", ())
336            .await?;
337        let mut logger: ClassInstanceRef<Self> = jvm
338            .invoke_virtual(
339                &manager,
340                "java/util/logging/LogManager",
341                "getLogger",
342                "(Ljava/lang/String;)Ljava/util/logging/Logger;",
343                (name.clone(),),
344            )
345            .await?;
346        if logger.is_null() {
347            let candidate: ClassInstanceRef<Self> = jvm
348                .new_class(
349                    "java/util/logging/Logger",
350                    "(Ljava/lang/String;Ljava/lang/String;)V",
351                    (name.clone(), resource_bundle_name.clone()),
352                )
353                .await?
354                .into();
355            let added: bool = jvm
356                .invoke_virtual(
357                    &manager,
358                    "java/util/logging/LogManager",
359                    "addLogger",
360                    "(Ljava/util/logging/Logger;)Z",
361                    (candidate.clone(),),
362                )
363                .await?;
364            logger = if added {
365                candidate
366            } else {
367                jvm.invoke_virtual(
368                    &manager,
369                    "java/util/logging/LogManager",
370                    "getLogger",
371                    "(Ljava/lang/String;)Ljava/util/logging/Logger;",
372                    (name,),
373                )
374                .await?
375            };
376        }
377
378        let _: () = jvm
379            .invoke_special(
380                &logger,
381                "java/util/logging/Logger",
382                "configureResourceBundle",
383                "(Ljava/lang/String;)V",
384                (resource_bundle_name,),
385            )
386            .await?;
387        Ok(logger)
388    }
389
390    async fn configure_resource_bundle(
391        jvm: &Jvm,
392        _: &mut RuntimeContext,
393        mut this: ClassInstanceRef<Self>,
394        resource_bundle_name: ClassInstanceRef<String>,
395    ) -> Result<()> {
396        if resource_bundle_name.is_null() {
397            return Ok(());
398        }
399
400        let current: ClassInstanceRef<String> = jvm.get_field(&this, "resourceBundleName", "Ljava/lang/String;").await?;
401        if current.is_null() {
402            return jvm
403                .put_field(&mut this, "resourceBundleName", "Ljava/lang/String;", resource_bundle_name)
404                .await;
405        }
406        if JavaLangString::to_rust_string(jvm, &current).await? != JavaLangString::to_rust_string(jvm, &resource_bundle_name).await? {
407            return Err(jvm
408                .exception("java/lang/IllegalArgumentException", "logger already uses a different resource bundle")
409                .await);
410        }
411        Ok(())
412    }
413
414    async fn get_anonymous_logger(jvm: &Jvm, _: &mut RuntimeContext) -> Result<ClassInstanceRef<Self>> {
415        tracing::debug!("java.util.logging.Logger::getAnonymousLogger()");
416
417        let resource_bundle_name: ClassInstanceRef<String> = None.into();
418        jvm.invoke_static(
419            "java/util/logging/Logger",
420            "getAnonymousLogger",
421            "(Ljava/lang/String;)Ljava/util/logging/Logger;",
422            (resource_bundle_name,),
423        )
424        .await
425    }
426
427    async fn get_anonymous_logger_with_resource_bundle(
428        jvm: &Jvm,
429        _: &mut RuntimeContext,
430        resource_bundle_name: ClassInstanceRef<String>,
431    ) -> Result<ClassInstanceRef<Self>> {
432        tracing::debug!("java.util.logging.Logger::getAnonymousLogger({resource_bundle_name:?})");
433
434        let name: ClassInstanceRef<String> = None.into();
435        let mut logger: ClassInstanceRef<Self> = jvm
436            .new_class(
437                "java/util/logging/Logger",
438                "(Ljava/lang/String;Ljava/lang/String;)V",
439                (name, resource_bundle_name),
440            )
441            .await?
442            .into();
443        let manager: ClassInstanceRef<LogManager> = jvm
444            .invoke_static("java/util/logging/LogManager", "getLogManager", "()Ljava/util/logging/LogManager;", ())
445            .await?;
446        let root_name = JavaLangString::from_rust_string(jvm, "").await?;
447        let root: ClassInstanceRef<Self> = jvm
448            .invoke_virtual(
449                &manager,
450                "java/util/logging/LogManager",
451                "getLogger",
452                "(Ljava/lang/String;)Ljava/util/logging/Logger;",
453                (root_name,),
454            )
455            .await?;
456        jvm.put_field(&mut logger, "parent", "Ljava/util/logging/Logger;", root).await?;
457        Ok(logger)
458    }
459
460    async fn get_global(jvm: &Jvm, _: &mut RuntimeContext) -> Result<ClassInstanceRef<Self>> {
461        tracing::debug!("java.util.logging.Logger::getGlobal()");
462        jvm.get_static_field("java/util/logging/Logger", "global", "Ljava/util/logging/Logger;")
463            .await
464    }
465
466    async fn get_name(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<String>> {
467        tracing::debug!("java.util.logging.Logger::getName({this:?})");
468        jvm.get_field(&this, "name", "Ljava/lang/String;").await
469    }
470
471    async fn get_filter(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Filter>> {
472        tracing::debug!("java.util.logging.Logger::getFilter({this:?})");
473        jvm.get_field(&this, "filter", "Ljava/util/logging/Filter;").await
474    }
475
476    async fn set_filter(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>, filter: ClassInstanceRef<Filter>) -> Result<()> {
477        tracing::debug!("java.util.logging.Logger::setFilter({this:?}, {filter:?})");
478        jvm.put_field(&mut this, "filter", "Ljava/util/logging/Filter;", filter).await
479    }
480
481    async fn get_level(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Level>> {
482        tracing::debug!("java.util.logging.Logger::getLevel({this:?})");
483        jvm.get_field(&this, "level", "Ljava/util/logging/Level;").await
484    }
485
486    async fn set_level(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>, level: ClassInstanceRef<Level>) -> Result<()> {
487        tracing::debug!("java.util.logging.Logger::setLevel({this:?}, {level:?})");
488        jvm.put_field(&mut this, "level", "Ljava/util/logging/Level;", level).await
489    }
490
491    async fn get_parent(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Self>> {
492        tracing::debug!("java.util.logging.Logger::getParent({this:?})");
493        jvm.get_field(&this, "parent", "Ljava/util/logging/Logger;").await
494    }
495
496    async fn set_parent(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>, parent: ClassInstanceRef<Self>) -> Result<()> {
497        tracing::debug!("java.util.logging.Logger::setParent({this:?}, {parent:?})");
498        if parent.is_null() {
499            return Err(jvm.exception("java/lang/NullPointerException", "parent").await);
500        }
501        jvm.put_field(&mut this, "parent", "Ljava/util/logging/Logger;", parent).await
502    }
503
504    async fn get_use_parent_handlers(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<bool> {
505        tracing::debug!("java.util.logging.Logger::getUseParentHandlers({this:?})");
506        jvm.get_field(&this, "useParentHandlers", "Z").await
507    }
508
509    async fn set_use_parent_handlers(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>, value: bool) -> Result<()> {
510        tracing::debug!("java.util.logging.Logger::setUseParentHandlers({this:?}, {value})");
511        jvm.put_field(&mut this, "useParentHandlers", "Z", value).await
512    }
513
514    async fn add_handler(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, handler: ClassInstanceRef<Handler>) -> Result<()> {
515        tracing::debug!("java.util.logging.Logger::addHandler({this:?}, {handler:?})");
516        if handler.is_null() {
517            return Err(jvm.exception("java/lang/NullPointerException", "handler").await);
518        }
519        let handlers: ClassInstanceRef<Vector> = jvm.get_field(&this, "handlers", "Ljava/util/Vector;").await?;
520        jvm.invoke_virtual(&handlers, "java/util/Vector", "addElement", "(Ljava/lang/Object;)V", (handler,))
521            .await
522    }
523
524    async fn remove_handler(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, handler: ClassInstanceRef<Handler>) -> Result<()> {
525        tracing::debug!("java.util.logging.Logger::removeHandler({this:?}, {handler:?})");
526        if handler.is_null() {
527            return Ok(());
528        }
529        let handlers: ClassInstanceRef<Vector> = jvm.get_field(&this, "handlers", "Ljava/util/Vector;").await?;
530        let _: bool = jvm
531            .invoke_virtual(&handlers, "java/util/Vector", "removeElement", "(Ljava/lang/Object;)Z", (handler,))
532            .await?;
533        Ok(())
534    }
535
536    async fn get_handlers(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Array<Handler>>> {
537        tracing::debug!("java.util.logging.Logger::getHandlers({this:?})");
538        let handlers: ClassInstanceRef<Vector> = jvm.get_field(&this, "handlers", "Ljava/util/Vector;").await?;
539        let size: i32 = jvm.invoke_virtual(&handlers, "java/util/Vector", "size", "()I", ()).await?;
540        let mut result: ClassInstanceRef<Array<Handler>> = jvm.instantiate_array("Ljava/util/logging/Handler;", size as usize).await?.into();
541        for index in 0..size {
542            let handler: ClassInstanceRef<Handler> = jvm
543                .invoke_virtual(&handlers, "java/util/Vector", "elementAt", "(I)Ljava/lang/Object;", (index,))
544                .await?;
545            jvm.store_array(&mut result, index as usize, [handler]).await?;
546        }
547        Ok(result)
548    }
549
550    async fn is_loggable(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, level: ClassInstanceRef<Level>) -> Result<bool> {
551        tracing::debug!("java.util.logging.Logger::isLoggable({this:?}, {level:?})");
552        if level.is_null() {
553            return Err(jvm.exception("java/lang/NullPointerException", "level").await);
554        }
555
556        let requested: i32 = jvm.invoke_virtual(&level, "java/util/logging/Level", "intValue", "()I", ()).await?;
557        let mut logger = this;
558        let effective = loop {
559            let configured: ClassInstanceRef<Level> = jvm.get_field(&logger, "level", "Ljava/util/logging/Level;").await?;
560            if !configured.is_null() {
561                break jvm.invoke_virtual(&configured, "java/util/logging/Level", "intValue", "()I", ()).await?;
562            }
563            let parent: ClassInstanceRef<Self> = jvm.get_field(&logger, "parent", "Ljava/util/logging/Logger;").await?;
564            if parent.is_null() {
565                let info: ClassInstanceRef<Level> = jvm
566                    .get_static_field("java/util/logging/Level", "INFO", "Ljava/util/logging/Level;")
567                    .await?;
568                break jvm.invoke_virtual(&info, "java/util/logging/Level", "intValue", "()I", ()).await?;
569            }
570            logger = parent;
571        };
572
573        Ok(effective != i32::MAX && requested >= effective)
574    }
575
576    async fn log_record(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, mut record: ClassInstanceRef<LogRecord>) -> Result<()> {
577        tracing::debug!("java.util.logging.Logger::log({this:?}, {record:?})");
578        if record.is_null() {
579            return Err(jvm.exception("java/lang/NullPointerException", "record").await);
580        }
581        let level: ClassInstanceRef<Level> = jvm
582            .invoke_virtual(&record, "java/util/logging/LogRecord", "getLevel", "()Ljava/util/logging/Level;", ())
583            .await?;
584        if !jvm
585            .invoke_virtual::<_, bool>(&this, "java/util/logging/Logger", "isLoggable", "(Ljava/util/logging/Level;)Z", (level,))
586            .await?
587        {
588            return Ok(());
589        }
590
591        let filter: ClassInstanceRef<Filter> = jvm.get_field(&this, "filter", "Ljava/util/logging/Filter;").await?;
592        if !filter.is_null()
593            && !jvm
594                .invoke_virtual::<_, bool>(
595                    &filter,
596                    &filter.class_definition().name(),
597                    "isLoggable",
598                    "(Ljava/util/logging/LogRecord;)Z",
599                    (record.clone(),),
600                )
601                .await?
602        {
603            return Ok(());
604        }
605
606        let logger_name: ClassInstanceRef<String> = jvm
607            .invoke_virtual(&record, "java/util/logging/LogRecord", "getLoggerName", "()Ljava/lang/String;", ())
608            .await?;
609        if logger_name.is_null() {
610            let name: ClassInstanceRef<String> = jvm.get_field(&this, "name", "Ljava/lang/String;").await?;
611            jvm.put_field(&mut record, "loggerName", "Ljava/lang/String;", name).await?;
612        }
613
614        let mut logger = this;
615        loop {
616            let handlers: ClassInstanceRef<Array<Handler>> = jvm
617                .invoke_virtual(&logger, "java/util/logging/Logger", "getHandlers", "()[Ljava/util/logging/Handler;", ())
618                .await?;
619            let length = jvm.array_length(&handlers).await?;
620            let handlers: Vec<ClassInstanceRef<Handler>> = jvm.load_array(&handlers, 0, length).await?;
621            for handler in handlers {
622                let _: () = jvm
623                    .invoke_virtual(
624                        &handler,
625                        "java/util/logging/Handler",
626                        "publish",
627                        "(Ljava/util/logging/LogRecord;)V",
628                        (record.clone(),),
629                    )
630                    .await?;
631            }
632
633            let use_parent: bool = jvm.get_field(&logger, "useParentHandlers", "Z").await?;
634            if !use_parent {
635                break;
636            }
637            let parent: ClassInstanceRef<Self> = jvm.get_field(&logger, "parent", "Ljava/util/logging/Logger;").await?;
638            if parent.is_null() {
639                break;
640            }
641            logger = parent;
642        }
643        Ok(())
644    }
645
646    async fn log(
647        jvm: &Jvm,
648        _: &mut RuntimeContext,
649        this: ClassInstanceRef<Self>,
650        level: ClassInstanceRef<Level>,
651        message: ClassInstanceRef<String>,
652    ) -> Result<()> {
653        let parameters: ClassInstanceRef<Array<Object>> = None.into();
654        let thrown: ClassInstanceRef<Throwable> = None.into();
655        let source_class: ClassInstanceRef<String> = None.into();
656        let source_method: ClassInstanceRef<String> = None.into();
657        let resource_bundle_name: ClassInstanceRef<String> = None.into();
658        Self::log_values(
659            jvm,
660            this,
661            level,
662            message,
663            parameters,
664            thrown,
665            source_class,
666            source_method,
667            resource_bundle_name,
668        )
669        .await
670    }
671
672    async fn log_with_parameter(
673        jvm: &Jvm,
674        _: &mut RuntimeContext,
675        this: ClassInstanceRef<Self>,
676        level: ClassInstanceRef<Level>,
677        message: ClassInstanceRef<String>,
678        parameter: ClassInstanceRef<Object>,
679    ) -> Result<()> {
680        let mut parameters: ClassInstanceRef<Array<Object>> = jvm.instantiate_array("Ljava/lang/Object;", 1).await?.into();
681        jvm.store_array(&mut parameters, 0, [parameter]).await?;
682        let thrown: ClassInstanceRef<Throwable> = None.into();
683        let source_class: ClassInstanceRef<String> = None.into();
684        let source_method: ClassInstanceRef<String> = None.into();
685        let resource_bundle_name: ClassInstanceRef<String> = None.into();
686        Self::log_values(
687            jvm,
688            this,
689            level,
690            message,
691            parameters,
692            thrown,
693            source_class,
694            source_method,
695            resource_bundle_name,
696        )
697        .await
698    }
699
700    async fn log_with_parameters(
701        jvm: &Jvm,
702        _: &mut RuntimeContext,
703        this: ClassInstanceRef<Self>,
704        level: ClassInstanceRef<Level>,
705        message: ClassInstanceRef<String>,
706        parameters: ClassInstanceRef<Array<Object>>,
707    ) -> Result<()> {
708        let thrown: ClassInstanceRef<Throwable> = None.into();
709        let source_class: ClassInstanceRef<String> = None.into();
710        let source_method: ClassInstanceRef<String> = None.into();
711        let resource_bundle_name: ClassInstanceRef<String> = None.into();
712        Self::log_values(
713            jvm,
714            this,
715            level,
716            message,
717            parameters,
718            thrown,
719            source_class,
720            source_method,
721            resource_bundle_name,
722        )
723        .await
724    }
725
726    async fn log_with_throwable(
727        jvm: &Jvm,
728        _: &mut RuntimeContext,
729        this: ClassInstanceRef<Self>,
730        level: ClassInstanceRef<Level>,
731        message: ClassInstanceRef<String>,
732        thrown: ClassInstanceRef<Throwable>,
733    ) -> Result<()> {
734        let parameters: ClassInstanceRef<Array<Object>> = None.into();
735        let source_class: ClassInstanceRef<String> = None.into();
736        let source_method: ClassInstanceRef<String> = None.into();
737        let resource_bundle_name: ClassInstanceRef<String> = None.into();
738        Self::log_values(
739            jvm,
740            this,
741            level,
742            message,
743            parameters,
744            thrown,
745            source_class,
746            source_method,
747            resource_bundle_name,
748        )
749        .await
750    }
751
752    async fn logp(
753        jvm: &Jvm,
754        _: &mut RuntimeContext,
755        this: ClassInstanceRef<Self>,
756        level: ClassInstanceRef<Level>,
757        source_class: ClassInstanceRef<String>,
758        source_method: ClassInstanceRef<String>,
759        message: ClassInstanceRef<String>,
760    ) -> Result<()> {
761        let parameters: ClassInstanceRef<Array<Object>> = None.into();
762        let thrown: ClassInstanceRef<Throwable> = None.into();
763        let resource_bundle_name: ClassInstanceRef<String> = None.into();
764        Self::log_values(
765            jvm,
766            this,
767            level,
768            message,
769            parameters,
770            thrown,
771            source_class,
772            source_method,
773            resource_bundle_name,
774        )
775        .await
776    }
777
778    #[allow(clippy::too_many_arguments)]
779    async fn logp_with_parameter(
780        jvm: &Jvm,
781        _: &mut RuntimeContext,
782        this: ClassInstanceRef<Self>,
783        level: ClassInstanceRef<Level>,
784        source_class: ClassInstanceRef<String>,
785        source_method: ClassInstanceRef<String>,
786        message: ClassInstanceRef<String>,
787        parameter: ClassInstanceRef<Object>,
788    ) -> Result<()> {
789        let mut parameters: ClassInstanceRef<Array<Object>> = jvm.instantiate_array("Ljava/lang/Object;", 1).await?.into();
790        jvm.store_array(&mut parameters, 0, [parameter]).await?;
791        let thrown: ClassInstanceRef<Throwable> = None.into();
792        let resource_bundle_name: ClassInstanceRef<String> = None.into();
793        Self::log_values(
794            jvm,
795            this,
796            level,
797            message,
798            parameters,
799            thrown,
800            source_class,
801            source_method,
802            resource_bundle_name,
803        )
804        .await
805    }
806
807    #[allow(clippy::too_many_arguments)]
808    async fn logp_with_parameters(
809        jvm: &Jvm,
810        _: &mut RuntimeContext,
811        this: ClassInstanceRef<Self>,
812        level: ClassInstanceRef<Level>,
813        source_class: ClassInstanceRef<String>,
814        source_method: ClassInstanceRef<String>,
815        message: ClassInstanceRef<String>,
816        parameters: ClassInstanceRef<Array<Object>>,
817    ) -> Result<()> {
818        let thrown: ClassInstanceRef<Throwable> = None.into();
819        let resource_bundle_name: ClassInstanceRef<String> = None.into();
820        Self::log_values(
821            jvm,
822            this,
823            level,
824            message,
825            parameters,
826            thrown,
827            source_class,
828            source_method,
829            resource_bundle_name,
830        )
831        .await
832    }
833
834    #[allow(clippy::too_many_arguments)]
835    async fn logp_with_throwable(
836        jvm: &Jvm,
837        _: &mut RuntimeContext,
838        this: ClassInstanceRef<Self>,
839        level: ClassInstanceRef<Level>,
840        source_class: ClassInstanceRef<String>,
841        source_method: ClassInstanceRef<String>,
842        message: ClassInstanceRef<String>,
843        thrown: ClassInstanceRef<Throwable>,
844    ) -> Result<()> {
845        let parameters: ClassInstanceRef<Array<Object>> = None.into();
846        let resource_bundle_name: ClassInstanceRef<String> = None.into();
847        Self::log_values(
848            jvm,
849            this,
850            level,
851            message,
852            parameters,
853            thrown,
854            source_class,
855            source_method,
856            resource_bundle_name,
857        )
858        .await
859    }
860
861    #[allow(clippy::too_many_arguments)]
862    async fn logrb(
863        jvm: &Jvm,
864        _: &mut RuntimeContext,
865        this: ClassInstanceRef<Self>,
866        level: ClassInstanceRef<Level>,
867        source_class: ClassInstanceRef<String>,
868        source_method: ClassInstanceRef<String>,
869        resource_bundle_name: ClassInstanceRef<String>,
870        message: ClassInstanceRef<String>,
871    ) -> Result<()> {
872        let parameters: ClassInstanceRef<Array<Object>> = None.into();
873        let thrown: ClassInstanceRef<Throwable> = None.into();
874        Self::log_values(
875            jvm,
876            this,
877            level,
878            message,
879            parameters,
880            thrown,
881            source_class,
882            source_method,
883            resource_bundle_name,
884        )
885        .await
886    }
887
888    #[allow(clippy::too_many_arguments)]
889    async fn logrb_with_parameter(
890        jvm: &Jvm,
891        _: &mut RuntimeContext,
892        this: ClassInstanceRef<Self>,
893        level: ClassInstanceRef<Level>,
894        source_class: ClassInstanceRef<String>,
895        source_method: ClassInstanceRef<String>,
896        resource_bundle_name: ClassInstanceRef<String>,
897        message: ClassInstanceRef<String>,
898        parameter: ClassInstanceRef<Object>,
899    ) -> Result<()> {
900        let mut parameters: ClassInstanceRef<Array<Object>> = jvm.instantiate_array("Ljava/lang/Object;", 1).await?.into();
901        jvm.store_array(&mut parameters, 0, [parameter]).await?;
902        let thrown: ClassInstanceRef<Throwable> = None.into();
903        Self::log_values(
904            jvm,
905            this,
906            level,
907            message,
908            parameters,
909            thrown,
910            source_class,
911            source_method,
912            resource_bundle_name,
913        )
914        .await
915    }
916
917    #[allow(clippy::too_many_arguments)]
918    async fn logrb_with_parameters(
919        jvm: &Jvm,
920        _: &mut RuntimeContext,
921        this: ClassInstanceRef<Self>,
922        level: ClassInstanceRef<Level>,
923        source_class: ClassInstanceRef<String>,
924        source_method: ClassInstanceRef<String>,
925        resource_bundle_name: ClassInstanceRef<String>,
926        message: ClassInstanceRef<String>,
927        parameters: ClassInstanceRef<Array<Object>>,
928    ) -> Result<()> {
929        let thrown: ClassInstanceRef<Throwable> = None.into();
930        Self::log_values(
931            jvm,
932            this,
933            level,
934            message,
935            parameters,
936            thrown,
937            source_class,
938            source_method,
939            resource_bundle_name,
940        )
941        .await
942    }
943
944    #[allow(clippy::too_many_arguments)]
945    async fn logrb_with_throwable(
946        jvm: &Jvm,
947        _: &mut RuntimeContext,
948        this: ClassInstanceRef<Self>,
949        level: ClassInstanceRef<Level>,
950        source_class: ClassInstanceRef<String>,
951        source_method: ClassInstanceRef<String>,
952        resource_bundle_name: ClassInstanceRef<String>,
953        message: ClassInstanceRef<String>,
954        thrown: ClassInstanceRef<Throwable>,
955    ) -> Result<()> {
956        let parameters: ClassInstanceRef<Array<Object>> = None.into();
957        Self::log_values(
958            jvm,
959            this,
960            level,
961            message,
962            parameters,
963            thrown,
964            source_class,
965            source_method,
966            resource_bundle_name,
967        )
968        .await
969    }
970
971    async fn severe(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, message: ClassInstanceRef<String>) -> Result<()> {
972        Self::log_at(jvm, this, "SEVERE", message).await
973    }
974
975    async fn warning(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, message: ClassInstanceRef<String>) -> Result<()> {
976        Self::log_at(jvm, this, "WARNING", message).await
977    }
978
979    async fn info(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, message: ClassInstanceRef<String>) -> Result<()> {
980        Self::log_at(jvm, this, "INFO", message).await
981    }
982
983    async fn config(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, message: ClassInstanceRef<String>) -> Result<()> {
984        Self::log_at(jvm, this, "CONFIG", message).await
985    }
986
987    async fn fine(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, message: ClassInstanceRef<String>) -> Result<()> {
988        Self::log_at(jvm, this, "FINE", message).await
989    }
990
991    async fn finer(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, message: ClassInstanceRef<String>) -> Result<()> {
992        Self::log_at(jvm, this, "FINER", message).await
993    }
994
995    async fn finest(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, message: ClassInstanceRef<String>) -> Result<()> {
996        Self::log_at(jvm, this, "FINEST", message).await
997    }
998
999    async fn entering(
1000        jvm: &Jvm,
1001        _: &mut RuntimeContext,
1002        this: ClassInstanceRef<Self>,
1003        source_class: ClassInstanceRef<String>,
1004        source_method: ClassInstanceRef<String>,
1005    ) -> Result<()> {
1006        let level = jvm
1007            .get_static_field("java/util/logging/Level", "FINER", "Ljava/util/logging/Level;")
1008            .await?;
1009        let message: ClassInstanceRef<String> = JavaLangString::from_rust_string(jvm, "ENTRY").await?.into();
1010        let parameters: ClassInstanceRef<Array<Object>> = None.into();
1011        let thrown: ClassInstanceRef<Throwable> = None.into();
1012        let resource_bundle_name: ClassInstanceRef<String> = None.into();
1013        Self::log_values(
1014            jvm,
1015            this,
1016            level,
1017            message,
1018            parameters,
1019            thrown,
1020            source_class,
1021            source_method,
1022            resource_bundle_name,
1023        )
1024        .await
1025    }
1026
1027    async fn entering_with_parameter(
1028        jvm: &Jvm,
1029        _: &mut RuntimeContext,
1030        this: ClassInstanceRef<Self>,
1031        source_class: ClassInstanceRef<String>,
1032        source_method: ClassInstanceRef<String>,
1033        parameter: ClassInstanceRef<Object>,
1034    ) -> Result<()> {
1035        let level = jvm
1036            .get_static_field("java/util/logging/Level", "FINER", "Ljava/util/logging/Level;")
1037            .await?;
1038        let message: ClassInstanceRef<String> = JavaLangString::from_rust_string(jvm, "ENTRY {0}").await?.into();
1039        let mut parameters: ClassInstanceRef<Array<Object>> = jvm.instantiate_array("Ljava/lang/Object;", 1).await?.into();
1040        jvm.store_array(&mut parameters, 0, [parameter]).await?;
1041        let thrown: ClassInstanceRef<Throwable> = None.into();
1042        let resource_bundle_name: ClassInstanceRef<String> = None.into();
1043        Self::log_values(
1044            jvm,
1045            this,
1046            level,
1047            message,
1048            parameters,
1049            thrown,
1050            source_class,
1051            source_method,
1052            resource_bundle_name,
1053        )
1054        .await
1055    }
1056
1057    async fn entering_with_parameters(
1058        jvm: &Jvm,
1059        _: &mut RuntimeContext,
1060        this: ClassInstanceRef<Self>,
1061        source_class: ClassInstanceRef<String>,
1062        source_method: ClassInstanceRef<String>,
1063        parameters: ClassInstanceRef<Array<Object>>,
1064    ) -> Result<()> {
1065        let level = jvm
1066            .get_static_field("java/util/logging/Level", "FINER", "Ljava/util/logging/Level;")
1067            .await?;
1068        let message: ClassInstanceRef<String> = JavaLangString::from_rust_string(jvm, "ENTRY").await?.into();
1069        let thrown: ClassInstanceRef<Throwable> = None.into();
1070        let resource_bundle_name: ClassInstanceRef<String> = None.into();
1071        Self::log_values(
1072            jvm,
1073            this,
1074            level,
1075            message,
1076            parameters,
1077            thrown,
1078            source_class,
1079            source_method,
1080            resource_bundle_name,
1081        )
1082        .await
1083    }
1084
1085    async fn exiting(
1086        jvm: &Jvm,
1087        _: &mut RuntimeContext,
1088        this: ClassInstanceRef<Self>,
1089        source_class: ClassInstanceRef<String>,
1090        source_method: ClassInstanceRef<String>,
1091    ) -> Result<()> {
1092        let level = jvm
1093            .get_static_field("java/util/logging/Level", "FINER", "Ljava/util/logging/Level;")
1094            .await?;
1095        let message: ClassInstanceRef<String> = JavaLangString::from_rust_string(jvm, "RETURN").await?.into();
1096        let parameters: ClassInstanceRef<Array<Object>> = None.into();
1097        let thrown: ClassInstanceRef<Throwable> = None.into();
1098        let resource_bundle_name: ClassInstanceRef<String> = None.into();
1099        Self::log_values(
1100            jvm,
1101            this,
1102            level,
1103            message,
1104            parameters,
1105            thrown,
1106            source_class,
1107            source_method,
1108            resource_bundle_name,
1109        )
1110        .await
1111    }
1112
1113    async fn exiting_with_result(
1114        jvm: &Jvm,
1115        _: &mut RuntimeContext,
1116        this: ClassInstanceRef<Self>,
1117        source_class: ClassInstanceRef<String>,
1118        source_method: ClassInstanceRef<String>,
1119        result: ClassInstanceRef<Object>,
1120    ) -> Result<()> {
1121        let level = jvm
1122            .get_static_field("java/util/logging/Level", "FINER", "Ljava/util/logging/Level;")
1123            .await?;
1124        let message: ClassInstanceRef<String> = JavaLangString::from_rust_string(jvm, "RETURN {0}").await?.into();
1125        let mut parameters: ClassInstanceRef<Array<Object>> = jvm.instantiate_array("Ljava/lang/Object;", 1).await?.into();
1126        jvm.store_array(&mut parameters, 0, [result]).await?;
1127        let thrown: ClassInstanceRef<Throwable> = None.into();
1128        let resource_bundle_name: ClassInstanceRef<String> = None.into();
1129        Self::log_values(
1130            jvm,
1131            this,
1132            level,
1133            message,
1134            parameters,
1135            thrown,
1136            source_class,
1137            source_method,
1138            resource_bundle_name,
1139        )
1140        .await
1141    }
1142
1143    async fn throwing(
1144        jvm: &Jvm,
1145        _: &mut RuntimeContext,
1146        this: ClassInstanceRef<Self>,
1147        source_class: ClassInstanceRef<String>,
1148        source_method: ClassInstanceRef<String>,
1149        thrown: ClassInstanceRef<Throwable>,
1150    ) -> Result<()> {
1151        let level = jvm
1152            .get_static_field("java/util/logging/Level", "FINER", "Ljava/util/logging/Level;")
1153            .await?;
1154        let message: ClassInstanceRef<String> = JavaLangString::from_rust_string(jvm, "THROW").await?.into();
1155        let parameters: ClassInstanceRef<Array<Object>> = None.into();
1156        let resource_bundle_name: ClassInstanceRef<String> = None.into();
1157        Self::log_values(
1158            jvm,
1159            this,
1160            level,
1161            message,
1162            parameters,
1163            thrown,
1164            source_class,
1165            source_method,
1166            resource_bundle_name,
1167        )
1168        .await
1169    }
1170
1171    async fn get_resource_bundle_name(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<String>> {
1172        tracing::debug!("java.util.logging.Logger::getResourceBundleName({this:?})");
1173        jvm.get_field(&this, "resourceBundleName", "Ljava/lang/String;").await
1174    }
1175
1176    async fn get_resource_bundle(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Object>> {
1177        tracing::debug!("java.util.logging.Logger::getResourceBundle({this:?})");
1178        jvm.get_field(&this, "resourceBundle", "Ljava/util/ResourceBundle;").await
1179    }
1180
1181    async fn reset(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>, root: bool) -> Result<ClassInstanceRef<Array<Handler>>> {
1182        let handlers: ClassInstanceRef<Vector> = jvm.get_field(&this, "handlers", "Ljava/util/Vector;").await?;
1183        let size: i32 = jvm.invoke_virtual(&handlers, "java/util/Vector", "size", "()I", ()).await?;
1184        let mut removed: ClassInstanceRef<Array<Handler>> = jvm.instantiate_array("Ljava/util/logging/Handler;", size as usize).await?.into();
1185        for index in 0..size {
1186            let handler: ClassInstanceRef<Handler> = jvm
1187                .invoke_virtual(&handlers, "java/util/Vector", "elementAt", "(I)Ljava/lang/Object;", (index,))
1188                .await?;
1189            jvm.store_array(&mut removed, index as usize, [handler]).await?;
1190        }
1191        let _: () = jvm.invoke_virtual(&handlers, "java/util/Vector", "removeAllElements", "()V", ()).await?;
1192
1193        let level: ClassInstanceRef<Level> = if root {
1194            jvm.get_static_field("java/util/logging/Level", "INFO", "Ljava/util/logging/Level;")
1195                .await?
1196        } else {
1197            None.into()
1198        };
1199        jvm.put_field(&mut this, "level", "Ljava/util/logging/Level;", level).await?;
1200        Ok(removed)
1201    }
1202
1203    async fn log_at(jvm: &Jvm, this: ClassInstanceRef<Self>, field: &str, message: ClassInstanceRef<String>) -> Result<()> {
1204        let level: ClassInstanceRef<Level> = jvm
1205            .get_static_field("java/util/logging/Level", field, "Ljava/util/logging/Level;")
1206            .await?;
1207        jvm.invoke_virtual(
1208            &this,
1209            "java/util/logging/Logger",
1210            "log",
1211            "(Ljava/util/logging/Level;Ljava/lang/String;)V",
1212            (level, message),
1213        )
1214        .await
1215    }
1216
1217    #[allow(clippy::too_many_arguments)]
1218    async fn log_values(
1219        jvm: &Jvm,
1220        this: ClassInstanceRef<Self>,
1221        level: ClassInstanceRef<Level>,
1222        message: ClassInstanceRef<String>,
1223        parameters: ClassInstanceRef<Array<Object>>,
1224        thrown: ClassInstanceRef<Throwable>,
1225        source_class: ClassInstanceRef<String>,
1226        source_method: ClassInstanceRef<String>,
1227        resource_bundle_name: ClassInstanceRef<String>,
1228    ) -> Result<()> {
1229        if !jvm
1230            .invoke_virtual::<_, bool>(
1231                &this,
1232                "java/util/logging/Logger",
1233                "isLoggable",
1234                "(Ljava/util/logging/Level;)Z",
1235                (level.clone(),),
1236            )
1237            .await?
1238        {
1239            return Ok(());
1240        }
1241
1242        let mut record: ClassInstanceRef<LogRecord> = jvm
1243            .new_class(
1244                "java/util/logging/LogRecord",
1245                "(Ljava/util/logging/Level;Ljava/lang/String;)V",
1246                (level, message),
1247            )
1248            .await?
1249            .into();
1250        if !parameters.is_null() {
1251            jvm.put_field(&mut record, "parameters", "[Ljava/lang/Object;", parameters).await?;
1252        }
1253        if !thrown.is_null() {
1254            jvm.put_field(&mut record, "thrown", "Ljava/lang/Throwable;", thrown).await?;
1255        }
1256        if !source_class.is_null() {
1257            jvm.put_field(&mut record, "sourceClassName", "Ljava/lang/String;", source_class).await?;
1258        }
1259        if !source_method.is_null() {
1260            jvm.put_field(&mut record, "sourceMethodName", "Ljava/lang/String;", source_method)
1261                .await?;
1262        }
1263        if !resource_bundle_name.is_null() {
1264            jvm.put_field(&mut record, "resourceBundleName", "Ljava/lang/String;", resource_bundle_name)
1265                .await?;
1266        }
1267        jvm.invoke_virtual(&this, "java/util/logging/Logger", "log", "(Ljava/util/logging/LogRecord;)V", (record,))
1268            .await
1269    }
1270}