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
18pub 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, ¤t).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}