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