1 /*
2 * The contents of this file are subject to the terms of the Common Development and
3 * Distribution License (the License). You may not use this file except in compliance with the
4 * License.
5 *
6 * You can obtain a copy of the License at legal/CDDLv1.0.txt. See the License for the
7 * specific language governing permission and limitations under the License.
8 *
9 * When distributing Covered Software, include this CDDL Header Notice in each file and include
10 * the License file at legal/CDDLv1.0.txt. If applicable, add the following below the CDDL
11 * Header, with the fields enclosed by brackets [] replaced by your own identifying
12 * information: "Portions Copyrighted [year] [name of copyright owner]".
13 *
14 * Copyright 2011 ForgeRock AS
15 */
16
17 package org.forgerock.i18n.jul;
18
19 import java.util.Locale;
20 import java.util.logging.Level;
21 import java.util.logging.Logger;
22
23 import org.forgerock.i18n.LocalizableMessage;
24 import org.forgerock.i18n.LocalizableMessageDescriptor.Arg0;
25 import org.forgerock.i18n.LocalizableMessageDescriptor.Arg1;
26 import org.forgerock.i18n.LocalizableMessageDescriptor.Arg2;
27 import org.forgerock.i18n.LocalizableMessageDescriptor.Arg3;
28 import org.forgerock.i18n.LocalizableMessageDescriptor.Arg4;
29 import org.forgerock.i18n.LocalizableMessageDescriptor.Arg5;
30 import org.forgerock.i18n.LocalizableMessageDescriptor.Arg6;
31 import org.forgerock.i18n.LocalizableMessageDescriptor.Arg7;
32 import org.forgerock.i18n.LocalizableMessageDescriptor.Arg8;
33 import org.forgerock.i18n.LocalizableMessageDescriptor.Arg9;
34 import org.forgerock.i18n.LocalizableMessageDescriptor.ArgN;
35
36 /**
37 * A logger implementation which formats and localizes messages before
38 * forwarding them to an underlying Java {@link Logger}. For performance reasons
39 * this implementation will only localize and format messages if logging has
40 * been enabled for the associated log level and marker (if present).
41 */
42 public final class LocalizedLogger {
43 /**
44 * Returns a localized logger which will forward log messages to an
45 * anonymous Java {@code Logger} obtained by calling
46 * {@link Logger#getAnonymousLogger()} . The messages will be localized
47 * using the default locale.
48 *
49 * @return The localized logger.
50 * @see Logger#getAnonymousLogger()
51 */
52 public static LocalizedLogger getLocalizedAnonymousLogger() {
53 final Logger logger = Logger.getAnonymousLogger();
54 return new LocalizedLogger(logger, Locale.getDefault());
55 }
56
57 /**
58 * Returns a localized logger which will forward log messages to the
59 * provided Java {@code Logger}. The messages will be localized using the
60 * default locale.
61 *
62 * @param logger
63 * The wrapped Java {@code Logger}.
64 * @return The localized logger.
65 */
66 public static LocalizedLogger getLocalizedLogger(final Logger logger) {
67 return new LocalizedLogger(logger, Locale.getDefault());
68 }
69
70 /**
71 * Returns a localized logger which will forward log messages to the named
72 * Java {@code Logger} obtained by calling {@link Logger#getLogger(String)}.
73 * The messages will be localized using the default locale.
74 *
75 * @param name
76 * The name of the wrapped Java {@code Logger}.
77 * @return The localized logger.
78 * @see Logger#getLogger(String)
79 */
80 public static LocalizedLogger getLocalizedLogger(final String name) {
81 final Logger logger = Logger.getLogger(name);
82 return new LocalizedLogger(logger, Locale.getDefault());
83 }
84
85 private final Logger logger;
86
87 private final Locale locale;
88
89 /**
90 * Creates a new localized logger which will log localizable messages to the
91 * provided Java {@code Logger} in the specified locale.
92 *
93 * @param logger
94 * The underlying Java {@code Logger} wrapped by this logger.
95 * @param locale
96 * The locale to which this logger will localize all log
97 * messages.
98 */
99 LocalizedLogger(final Logger logger, final Locale locale) {
100 this.locale = locale;
101 this.logger = logger;
102 }
103
104 /**
105 * Logs a CONFIG message.
106 *
107 * @param d
108 * The message descriptor.
109 * @see java.util.logging.Logger#config(String)
110 */
111 public void config(final Arg0 d) {
112 if (logger.isLoggable(Level.CONFIG)) {
113 logger.config(d.get().toString(locale));
114 }
115 }
116
117 /**
118 * Logs a CONFIG message.
119 *
120 * @param <T1>
121 * The type of the first message argument.
122 * @param d
123 * The message descriptor.
124 * @param a1
125 * The first message argument.
126 * @see java.util.logging.Logger#config(String)
127 */
128 public <T1> void config(final Arg1<T1> d, final T1 a1) {
129 if (logger.isLoggable(Level.CONFIG)) {
130 logger.config(d.get(a1).toString(locale));
131 }
132 }
133
134 /**
135 * Logs a CONFIG message.
136 *
137 * @param <T1>
138 * The type of the first message argument.
139 * @param <T2>
140 * The type of the second message argument.
141 * @param d
142 * The message descriptor.
143 * @param a1
144 * The first message argument.
145 * @param a2
146 * The second message argument.
147 * @see java.util.logging.Logger#config(String)
148 */
149 public <T1, T2> void config(final Arg2<T1, T2> d, final T1 a1, final T2 a2) {
150 if (logger.isLoggable(Level.CONFIG)) {
151 logger.config(d.get(a1, a2).toString(locale));
152 }
153 }
154
155 /**
156 * Logs a CONFIG message.
157 *
158 * @param <T1>
159 * The type of the first message argument.
160 * @param <T2>
161 * The type of the second message argument.
162 * @param <T3>
163 * The type of the third message argument.
164 * @param d
165 * The message descriptor.
166 * @param a1
167 * The first message argument.
168 * @param a2
169 * The second message argument.
170 * @param a3
171 * The third message argument.
172 * @see java.util.logging.Logger#config(String)
173 */
174 public <T1, T2, T3> void config(final Arg3<T1, T2, T3> d, final T1 a1,
175 final T2 a2, final T3 a3) {
176 if (logger.isLoggable(Level.CONFIG)) {
177 logger.config(d.get(a1, a2, a3).toString(locale));
178 }
179 }
180
181 /**
182 * Logs a CONFIG message.
183 *
184 * @param <T1>
185 * The type of the first message argument.
186 * @param <T2>
187 * The type of the second message argument.
188 * @param <T3>
189 * The type of the third message argument.
190 * @param <T4>
191 * The type of the fourth message argument.
192 * @param d
193 * The message descriptor.
194 * @param a1
195 * The first message argument.
196 * @param a2
197 * The second message argument.
198 * @param a3
199 * The third message argument.
200 * @param a4
201 * The fourth message argument.
202 * @see java.util.logging.Logger#config(String)
203 */
204 public <T1, T2, T3, T4> void config(final Arg4<T1, T2, T3, T4> d,
205 final T1 a1, final T2 a2, final T3 a3, final T4 a4) {
206 if (logger.isLoggable(Level.CONFIG)) {
207 logger.config(d.get(a1, a2, a3, a4).toString(locale));
208 }
209 }
210
211 /**
212 * Logs a CONFIG message.
213 *
214 * @param <T1>
215 * The type of the first message argument.
216 * @param <T2>
217 * The type of the second message argument.
218 * @param <T3>
219 * The type of the third message argument.
220 * @param <T4>
221 * The type of the fourth message argument.
222 * @param <T5>
223 * The type of the fifth message argument.
224 * @param d
225 * The message descriptor.
226 * @param a1
227 * The first message argument.
228 * @param a2
229 * The second message argument.
230 * @param a3
231 * The third message argument.
232 * @param a4
233 * The fourth message argument.
234 * @param a5
235 * The fifth message argument.
236 * @see java.util.logging.Logger#config(String)
237 */
238 public <T1, T2, T3, T4, T5> void config(final Arg5<T1, T2, T3, T4, T5> d,
239 final T1 a1, final T2 a2, final T3 a3, final T4 a4, final T5 a5) {
240 if (logger.isLoggable(Level.CONFIG)) {
241 logger.config(d.get(a1, a2, a3, a4, a5).toString(locale));
242 }
243 }
244
245 /**
246 * Logs a CONFIG message.
247 *
248 * @param <T1>
249 * The type of the first message argument.
250 * @param <T2>
251 * The type of the second message argument.
252 * @param <T3>
253 * The type of the third message argument.
254 * @param <T4>
255 * The type of the fourth message argument.
256 * @param <T5>
257 * The type of the fifth message argument.
258 * @param <T6>
259 * The type of the sixth message argument.
260 * @param d
261 * The message descriptor.
262 * @param a1
263 * The first message argument.
264 * @param a2
265 * The second message argument.
266 * @param a3
267 * The third message argument.
268 * @param a4
269 * The fourth message argument.
270 * @param a5
271 * The fifth message argument.
272 * @param a6
273 * The sixth message argument.
274 * @see java.util.logging.Logger#config(String)
275 */
276 public <T1, T2, T3, T4, T5, T6> void config(
277 final Arg6<T1, T2, T3, T4, T5, T6> d, final T1 a1, final T2 a2,
278 final T3 a3, final T4 a4, final T5 a5, final T6 a6) {
279 if (logger.isLoggable(Level.CONFIG)) {
280 logger.config(d.get(a1, a2, a3, a4, a5, a6).toString(locale));
281 }
282 }
283
284 /**
285 * Logs a CONFIG message.
286 *
287 * @param <T1>
288 * The type of the first message argument.
289 * @param <T2>
290 * The type of the second message argument.
291 * @param <T3>
292 * The type of the third message argument.
293 * @param <T4>
294 * The type of the fourth message argument.
295 * @param <T5>
296 * The type of the fifth message argument.
297 * @param <T6>
298 * The type of the sixth message argument.
299 * @param <T7>
300 * The type of the seventh message argument.
301 * @param d
302 * The message descriptor.
303 * @param a1
304 * The first message argument.
305 * @param a2
306 * The second message argument.
307 * @param a3
308 * The third message argument.
309 * @param a4
310 * The fourth message argument.
311 * @param a5
312 * The fifth message argument.
313 * @param a6
314 * The sixth message argument.
315 * @param a7
316 * The seventh message argument.
317 * @see java.util.logging.Logger#config(String)
318 */
319 public <T1, T2, T3, T4, T5, T6, T7> void config(
320 final Arg7<T1, T2, T3, T4, T5, T6, T7> d, final T1 a1, final T2 a2,
321 final T3 a3, final T4 a4, final T5 a5, final T6 a6, final T7 a7) {
322 if (logger.isLoggable(Level.CONFIG)) {
323 logger.config(d.get(a1, a2, a3, a4, a5, a6, a7).toString(locale));
324 }
325 }
326
327 /**
328 * Logs a CONFIG message.
329 *
330 * @param <T1>
331 * The type of the first message argument.
332 * @param <T2>
333 * The type of the second message argument.
334 * @param <T3>
335 * The type of the third message argument.
336 * @param <T4>
337 * The type of the fourth message argument.
338 * @param <T5>
339 * The type of the fifth message argument.
340 * @param <T6>
341 * The type of the sixth message argument.
342 * @param <T7>
343 * The type of the seventh message argument.
344 * @param <T8>
345 * The type of the eighth message argument.
346 * @param d
347 * The message descriptor.
348 * @param a1
349 * The first message argument.
350 * @param a2
351 * The second message argument.
352 * @param a3
353 * The third message argument.
354 * @param a4
355 * The fourth message argument.
356 * @param a5
357 * The fifth message argument.
358 * @param a6
359 * The sixth message argument.
360 * @param a7
361 * The seventh message argument.
362 * @param a8
363 * The eighth message argument.
364 * @see java.util.logging.Logger#config(String)
365 */
366 public <T1, T2, T3, T4, T5, T6, T7, T8> void config(
367 final Arg8<T1, T2, T3, T4, T5, T6, T7, T8> d, final T1 a1,
368 final T2 a2, final T3 a3, final T4 a4, final T5 a5, final T6 a6,
369 final T7 a7, final T8 a8) {
370 if (logger.isLoggable(Level.CONFIG)) {
371 logger.config(d.get(a1, a2, a3, a4, a5, a6, a7, a8)
372 .toString(locale));
373 }
374 }
375
376 /**
377 * Logs a CONFIG message.
378 *
379 * @param <T1>
380 * The type of the first message argument.
381 * @param <T2>
382 * The type of the second message argument.
383 * @param <T3>
384 * The type of the third message argument.
385 * @param <T4>
386 * The type of the fourth message argument.
387 * @param <T5>
388 * The type of the fifth message argument.
389 * @param <T6>
390 * The type of the sixth message argument.
391 * @param <T7>
392 * The type of the seventh message argument.
393 * @param <T8>
394 * The type of the eighth message argument.
395 * @param <T9>
396 * The type of the ninth message argument.
397 * @param d
398 * The message descriptor.
399 * @param a1
400 * The first message argument.
401 * @param a2
402 * The second message argument.
403 * @param a3
404 * The third message argument.
405 * @param a4
406 * The fourth message argument.
407 * @param a5
408 * The fifth message argument.
409 * @param a6
410 * The sixth message argument.
411 * @param a7
412 * The seventh message argument.
413 * @param a8
414 * The eighth message argument.
415 * @param a9
416 * The ninth message argument.
417 * @see java.util.logging.Logger#config(String)
418 */
419 public <T1, T2, T3, T4, T5, T6, T7, T8, T9> void config(
420 final Arg9<T1, T2, T3, T4, T5, T6, T7, T8, T9> d, final T1 a1,
421 final T2 a2, final T3 a3, final T4 a4, final T5 a5, final T6 a6,
422 final T7 a7, final T8 a8, final T9 a9) {
423 if (logger.isLoggable(Level.CONFIG)) {
424 logger.config(d.get(a1, a2, a3, a4, a5, a6, a7, a8, a9).toString(
425 locale));
426 }
427 }
428
429 /**
430 * Logs a CONFIG message.
431 *
432 * @param d
433 * The message descriptor.
434 * @param args
435 * The message arguments.
436 * @see java.util.logging.Logger#config(String)
437 */
438 public void config(final ArgN d, final Object... args) {
439 if (logger.isLoggable(Level.CONFIG)) {
440 logger.config(d.get(args).toString(locale));
441 }
442 }
443
444 /**
445 * Logs a CONFIG message.
446 *
447 * @param m
448 * The pre-formatted message.
449 * @see java.util.logging.Logger#config(String)
450 */
451 public void config(final LocalizableMessage m) {
452 if (logger.isLoggable(Level.CONFIG)) {
453 logger.config(m.toString(locale));
454 }
455 }
456
457 /**
458 * Logs a FINE message.
459 *
460 * @param d
461 * The message descriptor.
462 * @see java.util.logging.Logger#fine(String)
463 */
464 public void fine(final Arg0 d) {
465 if (logger.isLoggable(Level.FINE)) {
466 logger.fine(d.get().toString(locale));
467 }
468 }
469
470 /**
471 * Logs a FINE message.
472 *
473 * @param <T1>
474 * The type of the first message argument.
475 * @param d
476 * The message descriptor.
477 * @param a1
478 * The first message argument.
479 * @see java.util.logging.Logger#fine(String)
480 */
481 public <T1> void fine(final Arg1<T1> d, final T1 a1) {
482 if (logger.isLoggable(Level.FINE)) {
483 logger.fine(d.get(a1).toString(locale));
484 }
485 }
486
487 /**
488 * Logs a FINE message.
489 *
490 * @param <T1>
491 * The type of the first message argument.
492 * @param <T2>
493 * The type of the second message argument.
494 * @param d
495 * The message descriptor.
496 * @param a1
497 * The first message argument.
498 * @param a2
499 * The second message argument.
500 * @see java.util.logging.Logger#fine(String)
501 */
502 public <T1, T2> void fine(final Arg2<T1, T2> d, final T1 a1, final T2 a2) {
503 if (logger.isLoggable(Level.FINE)) {
504 logger.fine(d.get(a1, a2).toString(locale));
505 }
506 }
507
508 /**
509 * Logs a FINE message.
510 *
511 * @param <T1>
512 * The type of the first message argument.
513 * @param <T2>
514 * The type of the second message argument.
515 * @param <T3>
516 * The type of the third message argument.
517 * @param d
518 * The message descriptor.
519 * @param a1
520 * The first message argument.
521 * @param a2
522 * The second message argument.
523 * @param a3
524 * The third message argument.
525 * @see java.util.logging.Logger#fine(String)
526 */
527 public <T1, T2, T3> void fine(final Arg3<T1, T2, T3> d, final T1 a1,
528 final T2 a2, final T3 a3) {
529 if (logger.isLoggable(Level.FINE)) {
530 logger.fine(d.get(a1, a2, a3).toString(locale));
531 }
532 }
533
534 /**
535 * Logs a FINE message.
536 *
537 * @param <T1>
538 * The type of the first message argument.
539 * @param <T2>
540 * The type of the second message argument.
541 * @param <T3>
542 * The type of the third message argument.
543 * @param <T4>
544 * The type of the fourth message argument.
545 * @param d
546 * The message descriptor.
547 * @param a1
548 * The first message argument.
549 * @param a2
550 * The second message argument.
551 * @param a3
552 * The third message argument.
553 * @param a4
554 * The fourth message argument.
555 * @see java.util.logging.Logger#fine(String)
556 */
557 public <T1, T2, T3, T4> void fine(final Arg4<T1, T2, T3, T4> d,
558 final T1 a1, final T2 a2, final T3 a3, final T4 a4) {
559 if (logger.isLoggable(Level.FINE)) {
560 logger.fine(d.get(a1, a2, a3, a4).toString(locale));
561 }
562 }
563
564 /**
565 * Logs a FINE message.
566 *
567 * @param <T1>
568 * The type of the first message argument.
569 * @param <T2>
570 * The type of the second message argument.
571 * @param <T3>
572 * The type of the third message argument.
573 * @param <T4>
574 * The type of the fourth message argument.
575 * @param <T5>
576 * The type of the fifth message argument.
577 * @param d
578 * The message descriptor.
579 * @param a1
580 * The first message argument.
581 * @param a2
582 * The second message argument.
583 * @param a3
584 * The third message argument.
585 * @param a4
586 * The fourth message argument.
587 * @param a5
588 * The fifth message argument.
589 * @see java.util.logging.Logger#fine(String)
590 */
591 public <T1, T2, T3, T4, T5> void fine(final Arg5<T1, T2, T3, T4, T5> d,
592 final T1 a1, final T2 a2, final T3 a3, final T4 a4, final T5 a5) {
593 if (logger.isLoggable(Level.FINE)) {
594 logger.fine(d.get(a1, a2, a3, a4, a5).toString(locale));
595 }
596 }
597
598 /**
599 * Logs a FINE message.
600 *
601 * @param <T1>
602 * The type of the first message argument.
603 * @param <T2>
604 * The type of the second message argument.
605 * @param <T3>
606 * The type of the third message argument.
607 * @param <T4>
608 * The type of the fourth message argument.
609 * @param <T5>
610 * The type of the fifth message argument.
611 * @param <T6>
612 * The type of the sixth message argument.
613 * @param d
614 * The message descriptor.
615 * @param a1
616 * The first message argument.
617 * @param a2
618 * The second message argument.
619 * @param a3
620 * The third message argument.
621 * @param a4
622 * The fourth message argument.
623 * @param a5
624 * The fifth message argument.
625 * @param a6
626 * The sixth message argument.
627 * @see java.util.logging.Logger#fine(String)
628 */
629 public <T1, T2, T3, T4, T5, T6> void fine(
630 final Arg6<T1, T2, T3, T4, T5, T6> d, final T1 a1, final T2 a2,
631 final T3 a3, final T4 a4, final T5 a5, final T6 a6) {
632 if (logger.isLoggable(Level.FINE)) {
633 logger.fine(d.get(a1, a2, a3, a4, a5, a6).toString(locale));
634 }
635 }
636
637 /**
638 * Logs a FINE message.
639 *
640 * @param <T1>
641 * The type of the first message argument.
642 * @param <T2>
643 * The type of the second message argument.
644 * @param <T3>
645 * The type of the third message argument.
646 * @param <T4>
647 * The type of the fourth message argument.
648 * @param <T5>
649 * The type of the fifth message argument.
650 * @param <T6>
651 * The type of the sixth message argument.
652 * @param <T7>
653 * The type of the seventh message argument.
654 * @param d
655 * The message descriptor.
656 * @param a1
657 * The first message argument.
658 * @param a2
659 * The second message argument.
660 * @param a3
661 * The third message argument.
662 * @param a4
663 * The fourth message argument.
664 * @param a5
665 * The fifth message argument.
666 * @param a6
667 * The sixth message argument.
668 * @param a7
669 * The seventh message argument.
670 * @see java.util.logging.Logger#fine(String)
671 */
672 public <T1, T2, T3, T4, T5, T6, T7> void fine(
673 final Arg7<T1, T2, T3, T4, T5, T6, T7> d, final T1 a1, final T2 a2,
674 final T3 a3, final T4 a4, final T5 a5, final T6 a6, final T7 a7) {
675 if (logger.isLoggable(Level.FINE)) {
676 logger.fine(d.get(a1, a2, a3, a4, a5, a6, a7).toString(locale));
677 }
678 }
679
680 /**
681 * Logs a FINE message.
682 *
683 * @param <T1>
684 * The type of the first message argument.
685 * @param <T2>
686 * The type of the second message argument.
687 * @param <T3>
688 * The type of the third message argument.
689 * @param <T4>
690 * The type of the fourth message argument.
691 * @param <T5>
692 * The type of the fifth message argument.
693 * @param <T6>
694 * The type of the sixth message argument.
695 * @param <T7>
696 * The type of the seventh message argument.
697 * @param <T8>
698 * The type of the eighth message argument.
699 * @param d
700 * The message descriptor.
701 * @param a1
702 * The first message argument.
703 * @param a2
704 * The second message argument.
705 * @param a3
706 * The third message argument.
707 * @param a4
708 * The fourth message argument.
709 * @param a5
710 * The fifth message argument.
711 * @param a6
712 * The sixth message argument.
713 * @param a7
714 * The seventh message argument.
715 * @param a8
716 * The eighth message argument.
717 * @see java.util.logging.Logger#fine(String)
718 */
719 public <T1, T2, T3, T4, T5, T6, T7, T8> void fine(
720 final Arg8<T1, T2, T3, T4, T5, T6, T7, T8> d, final T1 a1,
721 final T2 a2, final T3 a3, final T4 a4, final T5 a5, final T6 a6,
722 final T7 a7, final T8 a8) {
723 if (logger.isLoggable(Level.FINE)) {
724 logger.fine(d.get(a1, a2, a3, a4, a5, a6, a7, a8).toString(locale));
725 }
726 }
727
728 /**
729 * Logs a FINE message.
730 *
731 * @param <T1>
732 * The type of the first message argument.
733 * @param <T2>
734 * The type of the second message argument.
735 * @param <T3>
736 * The type of the third message argument.
737 * @param <T4>
738 * The type of the fourth message argument.
739 * @param <T5>
740 * The type of the fifth message argument.
741 * @param <T6>
742 * The type of the sixth message argument.
743 * @param <T7>
744 * The type of the seventh message argument.
745 * @param <T8>
746 * The type of the eighth message argument.
747 * @param <T9>
748 * The type of the ninth message argument.
749 * @param d
750 * The message descriptor.
751 * @param a1
752 * The first message argument.
753 * @param a2
754 * The second message argument.
755 * @param a3
756 * The third message argument.
757 * @param a4
758 * The fourth message argument.
759 * @param a5
760 * The fifth message argument.
761 * @param a6
762 * The sixth message argument.
763 * @param a7
764 * The seventh message argument.
765 * @param a8
766 * The eighth message argument.
767 * @param a9
768 * The ninth message argument.
769 * @see java.util.logging.Logger#fine(String)
770 */
771 public <T1, T2, T3, T4, T5, T6, T7, T8, T9> void fine(
772 final Arg9<T1, T2, T3, T4, T5, T6, T7, T8, T9> d, final T1 a1,
773 final T2 a2, final T3 a3, final T4 a4, final T5 a5, final T6 a6,
774 final T7 a7, final T8 a8, final T9 a9) {
775 if (logger.isLoggable(Level.FINE)) {
776 logger.fine(d.get(a1, a2, a3, a4, a5, a6, a7, a8, a9).toString(
777 locale));
778 }
779 }
780
781 /**
782 * Logs a FINE message.
783 *
784 * @param d
785 * The message descriptor.
786 * @param args
787 * The message arguments.
788 * @see java.util.logging.Logger#fine(String)
789 */
790 public void fine(final ArgN d, final Object... args) {
791 if (logger.isLoggable(Level.FINE)) {
792 logger.fine(d.get(args).toString(locale));
793 }
794 }
795
796 /**
797 * Logs a FINE message.
798 *
799 * @param m
800 * The pre-formatted message.
801 * @see java.util.logging.Logger#fine(String)
802 */
803 public void fine(final LocalizableMessage m) {
804 if (logger.isLoggable(Level.FINE)) {
805 logger.fine(m.toString(locale));
806 }
807 }
808
809 /**
810 * Logs a FINER message.
811 *
812 * @param d
813 * The message descriptor.
814 * @see java.util.logging.Logger#finer(String)
815 */
816 public void finer(final Arg0 d) {
817 if (logger.isLoggable(Level.FINER)) {
818 logger.finer(d.get().toString(locale));
819 }
820 }
821
822 /**
823 * Logs a FINER message.
824 *
825 * @param <T1>
826 * The type of the first message argument.
827 * @param d
828 * The message descriptor.
829 * @param a1
830 * The first message argument.
831 * @see java.util.logging.Logger#finer(String)
832 */
833 public <T1> void finer(final Arg1<T1> d, final T1 a1) {
834 if (logger.isLoggable(Level.FINER)) {
835 logger.finer(d.get(a1).toString(locale));
836 }
837 }
838
839 /**
840 * Logs a FINER message.
841 *
842 * @param <T1>
843 * The type of the first message argument.
844 * @param <T2>
845 * The type of the second message argument.
846 * @param d
847 * The message descriptor.
848 * @param a1
849 * The first message argument.
850 * @param a2
851 * The second message argument.
852 * @see java.util.logging.Logger#finer(String)
853 */
854 public <T1, T2> void finer(final Arg2<T1, T2> d, final T1 a1, final T2 a2) {
855 if (logger.isLoggable(Level.FINER)) {
856 logger.finer(d.get(a1, a2).toString(locale));
857 }
858 }
859
860 /**
861 * Logs a FINER message.
862 *
863 * @param <T1>
864 * The type of the first message argument.
865 * @param <T2>
866 * The type of the second message argument.
867 * @param <T3>
868 * The type of the third message argument.
869 * @param d
870 * The message descriptor.
871 * @param a1
872 * The first message argument.
873 * @param a2
874 * The second message argument.
875 * @param a3
876 * The third message argument.
877 * @see java.util.logging.Logger#finer(String)
878 */
879 public <T1, T2, T3> void finer(final Arg3<T1, T2, T3> d, final T1 a1,
880 final T2 a2, final T3 a3) {
881 if (logger.isLoggable(Level.FINER)) {
882 logger.finer(d.get(a1, a2, a3).toString(locale));
883 }
884 }
885
886 /**
887 * Logs a FINER message.
888 *
889 * @param <T1>
890 * The type of the first message argument.
891 * @param <T2>
892 * The type of the second message argument.
893 * @param <T3>
894 * The type of the third message argument.
895 * @param <T4>
896 * The type of the fourth message argument.
897 * @param d
898 * The message descriptor.
899 * @param a1
900 * The first message argument.
901 * @param a2
902 * The second message argument.
903 * @param a3
904 * The third message argument.
905 * @param a4
906 * The fourth message argument.
907 * @see java.util.logging.Logger#finer(String)
908 */
909 public <T1, T2, T3, T4> void finer(final Arg4<T1, T2, T3, T4> d,
910 final T1 a1, final T2 a2, final T3 a3, final T4 a4) {
911 if (logger.isLoggable(Level.FINER)) {
912 logger.finer(d.get(a1, a2, a3, a4).toString(locale));
913 }
914 }
915
916 /**
917 * Logs a FINER message.
918 *
919 * @param <T1>
920 * The type of the first message argument.
921 * @param <T2>
922 * The type of the second message argument.
923 * @param <T3>
924 * The type of the third message argument.
925 * @param <T4>
926 * The type of the fourth message argument.
927 * @param <T5>
928 * The type of the fifth message argument.
929 * @param d
930 * The message descriptor.
931 * @param a1
932 * The first message argument.
933 * @param a2
934 * The second message argument.
935 * @param a3
936 * The third message argument.
937 * @param a4
938 * The fourth message argument.
939 * @param a5
940 * The fifth message argument.
941 * @see java.util.logging.Logger#finer(String)
942 */
943 public <T1, T2, T3, T4, T5> void finer(final Arg5<T1, T2, T3, T4, T5> d,
944 final T1 a1, final T2 a2, final T3 a3, final T4 a4, final T5 a5) {
945 if (logger.isLoggable(Level.FINER)) {
946 logger.finer(d.get(a1, a2, a3, a4, a5).toString(locale));
947 }
948 }
949
950 /**
951 * Logs a FINER message.
952 *
953 * @param <T1>
954 * The type of the first message argument.
955 * @param <T2>
956 * The type of the second message argument.
957 * @param <T3>
958 * The type of the third message argument.
959 * @param <T4>
960 * The type of the fourth message argument.
961 * @param <T5>
962 * The type of the fifth message argument.
963 * @param <T6>
964 * The type of the sixth message argument.
965 * @param d
966 * The message descriptor.
967 * @param a1
968 * The first message argument.
969 * @param a2
970 * The second message argument.
971 * @param a3
972 * The third message argument.
973 * @param a4
974 * The fourth message argument.
975 * @param a5
976 * The fifth message argument.
977 * @param a6
978 * The sixth message argument.
979 * @see java.util.logging.Logger#finer(String)
980 */
981 public <T1, T2, T3, T4, T5, T6> void finer(
982 final Arg6<T1, T2, T3, T4, T5, T6> d, final T1 a1, final T2 a2,
983 final T3 a3, final T4 a4, final T5 a5, final T6 a6) {
984 if (logger.isLoggable(Level.FINER)) {
985 logger.finer(d.get(a1, a2, a3, a4, a5, a6).toString(locale));
986 }
987 }
988
989 /**
990 * Logs a FINER message.
991 *
992 * @param <T1>
993 * The type of the first message argument.
994 * @param <T2>
995 * The type of the second message argument.
996 * @param <T3>
997 * The type of the third message argument.
998 * @param <T4>
999 * The type of the fourth message argument.
1000 * @param <T5>
1001 * The type of the fifth message argument.
1002 * @param <T6>
1003 * The type of the sixth message argument.
1004 * @param <T7>
1005 * The type of the seventh message argument.
1006 * @param d
1007 * The message descriptor.
1008 * @param a1
1009 * The first message argument.
1010 * @param a2
1011 * The second message argument.
1012 * @param a3
1013 * The third message argument.
1014 * @param a4
1015 * The fourth message argument.
1016 * @param a5
1017 * The fifth message argument.
1018 * @param a6
1019 * The sixth message argument.
1020 * @param a7
1021 * The seventh message argument.
1022 * @see java.util.logging.Logger#finer(String)
1023 */
1024 public <T1, T2, T3, T4, T5, T6, T7> void finer(
1025 final Arg7<T1, T2, T3, T4, T5, T6, T7> d, final T1 a1, final T2 a2,
1026 final T3 a3, final T4 a4, final T5 a5, final T6 a6, final T7 a7) {
1027 if (logger.isLoggable(Level.FINER)) {
1028 logger.finer(d.get(a1, a2, a3, a4, a5, a6, a7).toString(locale));
1029 }
1030 }
1031
1032 /**
1033 * Logs a FINER message.
1034 *
1035 * @param <T1>
1036 * The type of the first message argument.
1037 * @param <T2>
1038 * The type of the second message argument.
1039 * @param <T3>
1040 * The type of the third message argument.
1041 * @param <T4>
1042 * The type of the fourth message argument.
1043 * @param <T5>
1044 * The type of the fifth message argument.
1045 * @param <T6>
1046 * The type of the sixth message argument.
1047 * @param <T7>
1048 * The type of the seventh message argument.
1049 * @param <T8>
1050 * The type of the eighth message argument.
1051 * @param d
1052 * The message descriptor.
1053 * @param a1
1054 * The first message argument.
1055 * @param a2
1056 * The second message argument.
1057 * @param a3
1058 * The third message argument.
1059 * @param a4
1060 * The fourth message argument.
1061 * @param a5
1062 * The fifth message argument.
1063 * @param a6
1064 * The sixth message argument.
1065 * @param a7
1066 * The seventh message argument.
1067 * @param a8
1068 * The eighth message argument.
1069 * @see java.util.logging.Logger#finer(String)
1070 */
1071 public <T1, T2, T3, T4, T5, T6, T7, T8> void finer(
1072 final Arg8<T1, T2, T3, T4, T5, T6, T7, T8> d, final T1 a1,
1073 final T2 a2, final T3 a3, final T4 a4, final T5 a5, final T6 a6,
1074 final T7 a7, final T8 a8) {
1075 if (logger.isLoggable(Level.FINER)) {
1076 logger.finer(d.get(a1, a2, a3, a4, a5, a6, a7, a8).toString(locale));
1077 }
1078 }
1079
1080 /**
1081 * Logs a FINER message.
1082 *
1083 * @param <T1>
1084 * The type of the first message argument.
1085 * @param <T2>
1086 * The type of the second message argument.
1087 * @param <T3>
1088 * The type of the third message argument.
1089 * @param <T4>
1090 * The type of the fourth message argument.
1091 * @param <T5>
1092 * The type of the fifth message argument.
1093 * @param <T6>
1094 * The type of the sixth message argument.
1095 * @param <T7>
1096 * The type of the seventh message argument.
1097 * @param <T8>
1098 * The type of the eighth message argument.
1099 * @param <T9>
1100 * The type of the ninth message argument.
1101 * @param d
1102 * The message descriptor.
1103 * @param a1
1104 * The first message argument.
1105 * @param a2
1106 * The second message argument.
1107 * @param a3
1108 * The third message argument.
1109 * @param a4
1110 * The fourth message argument.
1111 * @param a5
1112 * The fifth message argument.
1113 * @param a6
1114 * The sixth message argument.
1115 * @param a7
1116 * The seventh message argument.
1117 * @param a8
1118 * The eighth message argument.
1119 * @param a9
1120 * The ninth message argument.
1121 * @see java.util.logging.Logger#finer(String)
1122 */
1123 public <T1, T2, T3, T4, T5, T6, T7, T8, T9> void finer(
1124 final Arg9<T1, T2, T3, T4, T5, T6, T7, T8, T9> d, final T1 a1,
1125 final T2 a2, final T3 a3, final T4 a4, final T5 a5, final T6 a6,
1126 final T7 a7, final T8 a8, final T9 a9) {
1127 if (logger.isLoggable(Level.FINER)) {
1128 logger.finer(d.get(a1, a2, a3, a4, a5, a6, a7, a8, a9).toString(
1129 locale));
1130 }
1131 }
1132
1133 /**
1134 * Logs a FINER message.
1135 *
1136 * @param d
1137 * The message descriptor.
1138 * @param args
1139 * The message arguments.
1140 * @see java.util.logging.Logger#finer(String)
1141 */
1142 public void finer(final ArgN d, final Object... args) {
1143 if (logger.isLoggable(Level.FINER)) {
1144 logger.finer(d.get(args).toString(locale));
1145 }
1146 }
1147
1148 /**
1149 * Logs a FINER message.
1150 *
1151 * @param m
1152 * The pre-formatted message.
1153 * @see java.util.logging.Logger#finer(String)
1154 */
1155 public void finer(final LocalizableMessage m) {
1156 if (logger.isLoggable(Level.FINER)) {
1157 logger.finer(m.toString(locale));
1158 }
1159 }
1160
1161 /**
1162 * Logs a FINEST message.
1163 *
1164 * @param d
1165 * The message descriptor.
1166 * @see java.util.logging.Logger#finest(String)
1167 */
1168 public void finest(final Arg0 d) {
1169 if (logger.isLoggable(Level.FINEST)) {
1170 logger.finest(d.get().toString(locale));
1171 }
1172 }
1173
1174 /**
1175 * Logs a FINEST message.
1176 *
1177 * @param <T1>
1178 * The type of the first message argument.
1179 * @param d
1180 * The message descriptor.
1181 * @param a1
1182 * The first message argument.
1183 * @see java.util.logging.Logger#finest(String)
1184 */
1185 public <T1> void finest(final Arg1<T1> d, final T1 a1) {
1186 if (logger.isLoggable(Level.FINEST)) {
1187 logger.finest(d.get(a1).toString(locale));
1188 }
1189 }
1190
1191 /**
1192 * Logs a FINEST message.
1193 *
1194 * @param <T1>
1195 * The type of the first message argument.
1196 * @param <T2>
1197 * The type of the second message argument.
1198 * @param d
1199 * The message descriptor.
1200 * @param a1
1201 * The first message argument.
1202 * @param a2
1203 * The second message argument.
1204 * @see java.util.logging.Logger#finest(String)
1205 */
1206 public <T1, T2> void finest(final Arg2<T1, T2> d, final T1 a1, final T2 a2) {
1207 if (logger.isLoggable(Level.FINEST)) {
1208 logger.finest(d.get(a1, a2).toString(locale));
1209 }
1210 }
1211
1212 /**
1213 * Logs a FINEST message.
1214 *
1215 * @param <T1>
1216 * The type of the first message argument.
1217 * @param <T2>
1218 * The type of the second message argument.
1219 * @param <T3>
1220 * The type of the third message argument.
1221 * @param d
1222 * The message descriptor.
1223 * @param a1
1224 * The first message argument.
1225 * @param a2
1226 * The second message argument.
1227 * @param a3
1228 * The third message argument.
1229 * @see java.util.logging.Logger#finest(String)
1230 */
1231 public <T1, T2, T3> void finest(final Arg3<T1, T2, T3> d, final T1 a1,
1232 final T2 a2, final T3 a3) {
1233 if (logger.isLoggable(Level.FINEST)) {
1234 logger.finest(d.get(a1, a2, a3).toString(locale));
1235 }
1236 }
1237
1238 /**
1239 * Logs a FINEST message.
1240 *
1241 * @param <T1>
1242 * The type of the first message argument.
1243 * @param <T2>
1244 * The type of the second message argument.
1245 * @param <T3>
1246 * The type of the third message argument.
1247 * @param <T4>
1248 * The type of the fourth message argument.
1249 * @param d
1250 * The message descriptor.
1251 * @param a1
1252 * The first message argument.
1253 * @param a2
1254 * The second message argument.
1255 * @param a3
1256 * The third message argument.
1257 * @param a4
1258 * The fourth message argument.
1259 * @see java.util.logging.Logger#finest(String)
1260 */
1261 public <T1, T2, T3, T4> void finest(final Arg4<T1, T2, T3, T4> d,
1262 final T1 a1, final T2 a2, final T3 a3, final T4 a4) {
1263 if (logger.isLoggable(Level.FINEST)) {
1264 logger.finest(d.get(a1, a2, a3, a4).toString(locale));
1265 }
1266 }
1267
1268 /**
1269 * Logs a FINEST message.
1270 *
1271 * @param <T1>
1272 * The type of the first message argument.
1273 * @param <T2>
1274 * The type of the second message argument.
1275 * @param <T3>
1276 * The type of the third message argument.
1277 * @param <T4>
1278 * The type of the fourth message argument.
1279 * @param <T5>
1280 * The type of the fifth message argument.
1281 * @param d
1282 * The message descriptor.
1283 * @param a1
1284 * The first message argument.
1285 * @param a2
1286 * The second message argument.
1287 * @param a3
1288 * The third message argument.
1289 * @param a4
1290 * The fourth message argument.
1291 * @param a5
1292 * The fifth message argument.
1293 * @see java.util.logging.Logger#finest(String)
1294 */
1295 public <T1, T2, T3, T4, T5> void finest(final Arg5<T1, T2, T3, T4, T5> d,
1296 final T1 a1, final T2 a2, final T3 a3, final T4 a4, final T5 a5) {
1297 if (logger.isLoggable(Level.FINEST)) {
1298 logger.finest(d.get(a1, a2, a3, a4, a5).toString(locale));
1299 }
1300 }
1301
1302 /**
1303 * Logs a FINEST message.
1304 *
1305 * @param <T1>
1306 * The type of the first message argument.
1307 * @param <T2>
1308 * The type of the second message argument.
1309 * @param <T3>
1310 * The type of the third message argument.
1311 * @param <T4>
1312 * The type of the fourth message argument.
1313 * @param <T5>
1314 * The type of the fifth message argument.
1315 * @param <T6>
1316 * The type of the sixth message argument.
1317 * @param d
1318 * The message descriptor.
1319 * @param a1
1320 * The first message argument.
1321 * @param a2
1322 * The second message argument.
1323 * @param a3
1324 * The third message argument.
1325 * @param a4
1326 * The fourth message argument.
1327 * @param a5
1328 * The fifth message argument.
1329 * @param a6
1330 * The sixth message argument.
1331 * @see java.util.logging.Logger#finest(String)
1332 */
1333 public <T1, T2, T3, T4, T5, T6> void finest(
1334 final Arg6<T1, T2, T3, T4, T5, T6> d, final T1 a1, final T2 a2,
1335 final T3 a3, final T4 a4, final T5 a5, final T6 a6) {
1336 if (logger.isLoggable(Level.FINEST)) {
1337 logger.finest(d.get(a1, a2, a3, a4, a5, a6).toString(locale));
1338 }
1339 }
1340
1341 /**
1342 * Logs a FINEST message.
1343 *
1344 * @param <T1>
1345 * The type of the first message argument.
1346 * @param <T2>
1347 * The type of the second message argument.
1348 * @param <T3>
1349 * The type of the third message argument.
1350 * @param <T4>
1351 * The type of the fourth message argument.
1352 * @param <T5>
1353 * The type of the fifth message argument.
1354 * @param <T6>
1355 * The type of the sixth message argument.
1356 * @param <T7>
1357 * The type of the seventh message argument.
1358 * @param d
1359 * The message descriptor.
1360 * @param a1
1361 * The first message argument.
1362 * @param a2
1363 * The second message argument.
1364 * @param a3
1365 * The third message argument.
1366 * @param a4
1367 * The fourth message argument.
1368 * @param a5
1369 * The fifth message argument.
1370 * @param a6
1371 * The sixth message argument.
1372 * @param a7
1373 * The seventh message argument.
1374 * @see java.util.logging.Logger#finest(String)
1375 */
1376 public <T1, T2, T3, T4, T5, T6, T7> void finest(
1377 final Arg7<T1, T2, T3, T4, T5, T6, T7> d, final T1 a1, final T2 a2,
1378 final T3 a3, final T4 a4, final T5 a5, final T6 a6, final T7 a7) {
1379 if (logger.isLoggable(Level.FINEST)) {
1380 logger.finest(d.get(a1, a2, a3, a4, a5, a6, a7).toString(locale));
1381 }
1382 }
1383
1384 /**
1385 * Logs a FINEST message.
1386 *
1387 * @param <T1>
1388 * The type of the first message argument.
1389 * @param <T2>
1390 * The type of the second message argument.
1391 * @param <T3>
1392 * The type of the third message argument.
1393 * @param <T4>
1394 * The type of the fourth message argument.
1395 * @param <T5>
1396 * The type of the fifth message argument.
1397 * @param <T6>
1398 * The type of the sixth message argument.
1399 * @param <T7>
1400 * The type of the seventh message argument.
1401 * @param <T8>
1402 * The type of the eighth message argument.
1403 * @param d
1404 * The message descriptor.
1405 * @param a1
1406 * The first message argument.
1407 * @param a2
1408 * The second message argument.
1409 * @param a3
1410 * The third message argument.
1411 * @param a4
1412 * The fourth message argument.
1413 * @param a5
1414 * The fifth message argument.
1415 * @param a6
1416 * The sixth message argument.
1417 * @param a7
1418 * The seventh message argument.
1419 * @param a8
1420 * The eighth message argument.
1421 * @see java.util.logging.Logger#finest(String)
1422 */
1423 public <T1, T2, T3, T4, T5, T6, T7, T8> void finest(
1424 final Arg8<T1, T2, T3, T4, T5, T6, T7, T8> d, final T1 a1,
1425 final T2 a2, final T3 a3, final T4 a4, final T5 a5, final T6 a6,
1426 final T7 a7, final T8 a8) {
1427 if (logger.isLoggable(Level.FINEST)) {
1428 logger.finest(d.get(a1, a2, a3, a4, a5, a6, a7, a8)
1429 .toString(locale));
1430 }
1431 }
1432
1433 /**
1434 * Logs a FINEST message.
1435 *
1436 * @param <T1>
1437 * The type of the first message argument.
1438 * @param <T2>
1439 * The type of the second message argument.
1440 * @param <T3>
1441 * The type of the third message argument.
1442 * @param <T4>
1443 * The type of the fourth message argument.
1444 * @param <T5>
1445 * The type of the fifth message argument.
1446 * @param <T6>
1447 * The type of the sixth message argument.
1448 * @param <T7>
1449 * The type of the seventh message argument.
1450 * @param <T8>
1451 * The type of the eighth message argument.
1452 * @param <T9>
1453 * The type of the ninth message argument.
1454 * @param d
1455 * The message descriptor.
1456 * @param a1
1457 * The first message argument.
1458 * @param a2
1459 * The second message argument.
1460 * @param a3
1461 * The third message argument.
1462 * @param a4
1463 * The fourth message argument.
1464 * @param a5
1465 * The fifth message argument.
1466 * @param a6
1467 * The sixth message argument.
1468 * @param a7
1469 * The seventh message argument.
1470 * @param a8
1471 * The eighth message argument.
1472 * @param a9
1473 * The ninth message argument.
1474 * @see java.util.logging.Logger#finest(String)
1475 */
1476 public <T1, T2, T3, T4, T5, T6, T7, T8, T9> void finest(
1477 final Arg9<T1, T2, T3, T4, T5, T6, T7, T8, T9> d, final T1 a1,
1478 final T2 a2, final T3 a3, final T4 a4, final T5 a5, final T6 a6,
1479 final T7 a7, final T8 a8, final T9 a9) {
1480 if (logger.isLoggable(Level.FINEST)) {
1481 logger.finest(d.get(a1, a2, a3, a4, a5, a6, a7, a8, a9).toString(
1482 locale));
1483 }
1484 }
1485
1486 /**
1487 * Logs a FINEST message.
1488 *
1489 * @param d
1490 * The message descriptor.
1491 * @param args
1492 * The message arguments.
1493 * @see java.util.logging.Logger#finest(String)
1494 */
1495 public void finest(final ArgN d, final Object... args) {
1496 if (logger.isLoggable(Level.FINEST)) {
1497 logger.finest(d.get(args).toString(locale));
1498 }
1499 }
1500
1501 /**
1502 * Logs a FINEST message.
1503 *
1504 * @param m
1505 * The pre-formatted message.
1506 * @see java.util.logging.Logger#finest(String)
1507 */
1508 public void finest(final LocalizableMessage m) {
1509 if (logger.isLoggable(Level.FINEST)) {
1510 logger.finest(m.toString(locale));
1511 }
1512 }
1513
1514 /**
1515 * Returns the locale to which this logger will localize all log messages.
1516 *
1517 * @return The locale to which this logger will localize all log messages.
1518 */
1519 public Locale getLocale() {
1520 return locale;
1521 }
1522
1523 /**
1524 * Returns the underlying Java {@code Logger} wrapped by this logger.
1525 *
1526 * @return The underlying Java {@code Logger} wrapped by this logger.
1527 */
1528 public Logger getLogger() {
1529 return logger;
1530 }
1531
1532 /**
1533 * Returns the name of this logger.
1534 *
1535 * @return The name of this logger.
1536 * @see java.util.logging.Logger#getName()
1537 */
1538 public String getName() {
1539 return logger.getName();
1540 }
1541
1542 /**
1543 * Logs an INFO message.
1544 *
1545 * @param d
1546 * The message descriptor.
1547 * @see java.util.logging.Logger#info(String)
1548 */
1549 public void info(final Arg0 d) {
1550 if (logger.isLoggable(Level.INFO)) {
1551 logger.info(d.get().toString(locale));
1552 }
1553 }
1554
1555 /**
1556 * Logs an INFO message.
1557 *
1558 * @param <T1>
1559 * The type of the first message argument.
1560 * @param d
1561 * The message descriptor.
1562 * @param a1
1563 * The first message argument.
1564 * @see java.util.logging.Logger#info(String)
1565 */
1566 public <T1> void info(final Arg1<T1> d, final T1 a1) {
1567 if (logger.isLoggable(Level.INFO)) {
1568 logger.info(d.get(a1).toString(locale));
1569 }
1570 }
1571
1572 /**
1573 * Logs an INFO message.
1574 *
1575 * @param <T1>
1576 * The type of the first message argument.
1577 * @param <T2>
1578 * The type of the second message argument.
1579 * @param d
1580 * The message descriptor.
1581 * @param a1
1582 * The first message argument.
1583 * @param a2
1584 * The second message argument.
1585 * @see java.util.logging.Logger#info(String)
1586 */
1587 public <T1, T2> void info(final Arg2<T1, T2> d, final T1 a1, final T2 a2) {
1588 if (logger.isLoggable(Level.INFO)) {
1589 logger.info(d.get(a1, a2).toString(locale));
1590 }
1591 }
1592
1593 /**
1594 * Logs an INFO message.
1595 *
1596 * @param <T1>
1597 * The type of the first message argument.
1598 * @param <T2>
1599 * The type of the second message argument.
1600 * @param <T3>
1601 * The type of the third message argument.
1602 * @param d
1603 * The message descriptor.
1604 * @param a1
1605 * The first message argument.
1606 * @param a2
1607 * The second message argument.
1608 * @param a3
1609 * The third message argument.
1610 * @see java.util.logging.Logger#info(String)
1611 */
1612 public <T1, T2, T3> void info(final Arg3<T1, T2, T3> d, final T1 a1,
1613 final T2 a2, final T3 a3) {
1614 if (logger.isLoggable(Level.INFO)) {
1615 logger.info(d.get(a1, a2, a3).toString(locale));
1616 }
1617 }
1618
1619 /**
1620 * Logs an INFO message.
1621 *
1622 * @param <T1>
1623 * The type of the first message argument.
1624 * @param <T2>
1625 * The type of the second message argument.
1626 * @param <T3>
1627 * The type of the third message argument.
1628 * @param <T4>
1629 * The type of the fourth message argument.
1630 * @param d
1631 * The message descriptor.
1632 * @param a1
1633 * The first message argument.
1634 * @param a2
1635 * The second message argument.
1636 * @param a3
1637 * The third message argument.
1638 * @param a4
1639 * The fourth message argument.
1640 * @see java.util.logging.Logger#info(String)
1641 */
1642 public <T1, T2, T3, T4> void info(final Arg4<T1, T2, T3, T4> d,
1643 final T1 a1, final T2 a2, final T3 a3, final T4 a4) {
1644 if (logger.isLoggable(Level.INFO)) {
1645 logger.info(d.get(a1, a2, a3, a4).toString(locale));
1646 }
1647 }
1648
1649 /**
1650 * Logs an INFO message.
1651 *
1652 * @param <T1>
1653 * The type of the first message argument.
1654 * @param <T2>
1655 * The type of the second message argument.
1656 * @param <T3>
1657 * The type of the third message argument.
1658 * @param <T4>
1659 * The type of the fourth message argument.
1660 * @param <T5>
1661 * The type of the fifth message argument.
1662 * @param d
1663 * The message descriptor.
1664 * @param a1
1665 * The first message argument.
1666 * @param a2
1667 * The second message argument.
1668 * @param a3
1669 * The third message argument.
1670 * @param a4
1671 * The fourth message argument.
1672 * @param a5
1673 * The fifth message argument.
1674 * @see java.util.logging.Logger#info(String)
1675 */
1676 public <T1, T2, T3, T4, T5> void info(final Arg5<T1, T2, T3, T4, T5> d,
1677 final T1 a1, final T2 a2, final T3 a3, final T4 a4, final T5 a5) {
1678 if (logger.isLoggable(Level.INFO)) {
1679 logger.info(d.get(a1, a2, a3, a4, a5).toString(locale));
1680 }
1681 }
1682
1683 /**
1684 * Logs an INFO message.
1685 *
1686 * @param <T1>
1687 * The type of the first message argument.
1688 * @param <T2>
1689 * The type of the second message argument.
1690 * @param <T3>
1691 * The type of the third message argument.
1692 * @param <T4>
1693 * The type of the fourth message argument.
1694 * @param <T5>
1695 * The type of the fifth message argument.
1696 * @param <T6>
1697 * The type of the sixth message argument.
1698 * @param d
1699 * The message descriptor.
1700 * @param a1
1701 * The first message argument.
1702 * @param a2
1703 * The second message argument.
1704 * @param a3
1705 * The third message argument.
1706 * @param a4
1707 * The fourth message argument.
1708 * @param a5
1709 * The fifth message argument.
1710 * @param a6
1711 * The sixth message argument.
1712 * @see java.util.logging.Logger#info(String)
1713 */
1714 public <T1, T2, T3, T4, T5, T6> void info(
1715 final Arg6<T1, T2, T3, T4, T5, T6> d, final T1 a1, final T2 a2,
1716 final T3 a3, final T4 a4, final T5 a5, final T6 a6) {
1717 if (logger.isLoggable(Level.INFO)) {
1718 logger.info(d.get(a1, a2, a3, a4, a5, a6).toString(locale));
1719 }
1720 }
1721
1722 /**
1723 * Logs an INFO message.
1724 *
1725 * @param <T1>
1726 * The type of the first message argument.
1727 * @param <T2>
1728 * The type of the second message argument.
1729 * @param <T3>
1730 * The type of the third message argument.
1731 * @param <T4>
1732 * The type of the fourth message argument.
1733 * @param <T5>
1734 * The type of the fifth message argument.
1735 * @param <T6>
1736 * The type of the sixth message argument.
1737 * @param <T7>
1738 * The type of the seventh message argument.
1739 * @param d
1740 * The message descriptor.
1741 * @param a1
1742 * The first message argument.
1743 * @param a2
1744 * The second message argument.
1745 * @param a3
1746 * The third message argument.
1747 * @param a4
1748 * The fourth message argument.
1749 * @param a5
1750 * The fifth message argument.
1751 * @param a6
1752 * The sixth message argument.
1753 * @param a7
1754 * The seventh message argument.
1755 * @see java.util.logging.Logger#info(String)
1756 */
1757 public <T1, T2, T3, T4, T5, T6, T7> void info(
1758 final Arg7<T1, T2, T3, T4, T5, T6, T7> d, final T1 a1, final T2 a2,
1759 final T3 a3, final T4 a4, final T5 a5, final T6 a6, final T7 a7) {
1760 if (logger.isLoggable(Level.INFO)) {
1761 logger.info(d.get(a1, a2, a3, a4, a5, a6, a7).toString(locale));
1762 }
1763 }
1764
1765 /**
1766 * Logs an INFO message.
1767 *
1768 * @param <T1>
1769 * The type of the first message argument.
1770 * @param <T2>
1771 * The type of the second message argument.
1772 * @param <T3>
1773 * The type of the third message argument.
1774 * @param <T4>
1775 * The type of the fourth message argument.
1776 * @param <T5>
1777 * The type of the fifth message argument.
1778 * @param <T6>
1779 * The type of the sixth message argument.
1780 * @param <T7>
1781 * The type of the seventh message argument.
1782 * @param <T8>
1783 * The type of the eighth message argument.
1784 * @param d
1785 * The message descriptor.
1786 * @param a1
1787 * The first message argument.
1788 * @param a2
1789 * The second message argument.
1790 * @param a3
1791 * The third message argument.
1792 * @param a4
1793 * The fourth message argument.
1794 * @param a5
1795 * The fifth message argument.
1796 * @param a6
1797 * The sixth message argument.
1798 * @param a7
1799 * The seventh message argument.
1800 * @param a8
1801 * The eighth message argument.
1802 * @see java.util.logging.Logger#info(String)
1803 */
1804 public <T1, T2, T3, T4, T5, T6, T7, T8> void info(
1805 final Arg8<T1, T2, T3, T4, T5, T6, T7, T8> d, final T1 a1,
1806 final T2 a2, final T3 a3, final T4 a4, final T5 a5, final T6 a6,
1807 final T7 a7, final T8 a8) {
1808 if (logger.isLoggable(Level.INFO)) {
1809 logger.info(d.get(a1, a2, a3, a4, a5, a6, a7, a8).toString(locale));
1810 }
1811 }
1812
1813 /**
1814 * Logs an INFO message.
1815 *
1816 * @param <T1>
1817 * The type of the first message argument.
1818 * @param <T2>
1819 * The type of the second message argument.
1820 * @param <T3>
1821 * The type of the third message argument.
1822 * @param <T4>
1823 * The type of the fourth message argument.
1824 * @param <T5>
1825 * The type of the fifth message argument.
1826 * @param <T6>
1827 * The type of the sixth message argument.
1828 * @param <T7>
1829 * The type of the seventh message argument.
1830 * @param <T8>
1831 * The type of the eighth message argument.
1832 * @param <T9>
1833 * The type of the ninth message argument.
1834 * @param d
1835 * The message descriptor.
1836 * @param a1
1837 * The first message argument.
1838 * @param a2
1839 * The second message argument.
1840 * @param a3
1841 * The third message argument.
1842 * @param a4
1843 * The fourth message argument.
1844 * @param a5
1845 * The fifth message argument.
1846 * @param a6
1847 * The sixth message argument.
1848 * @param a7
1849 * The seventh message argument.
1850 * @param a8
1851 * The eighth message argument.
1852 * @param a9
1853 * The ninth message argument.
1854 * @see java.util.logging.Logger#info(String)
1855 */
1856 public <T1, T2, T3, T4, T5, T6, T7, T8, T9> void info(
1857 final Arg9<T1, T2, T3, T4, T5, T6, T7, T8, T9> d, final T1 a1,
1858 final T2 a2, final T3 a3, final T4 a4, final T5 a5, final T6 a6,
1859 final T7 a7, final T8 a8, final T9 a9) {
1860 if (logger.isLoggable(Level.INFO)) {
1861 logger.info(d.get(a1, a2, a3, a4, a5, a6, a7, a8, a9).toString(
1862 locale));
1863 }
1864 }
1865
1866 /**
1867 * Logs an INFO message.
1868 *
1869 * @param d
1870 * The message descriptor.
1871 * @param args
1872 * The message arguments.
1873 * @see java.util.logging.Logger#info(String)
1874 */
1875 public void info(final ArgN d, final Object... args) {
1876 if (logger.isLoggable(Level.INFO)) {
1877 logger.info(d.get(args).toString(locale));
1878 }
1879 }
1880
1881 /**
1882 * Logs an INFO message.
1883 *
1884 * @param m
1885 * The pre-formatted message.
1886 * @see java.util.logging.Logger#info(String)
1887 */
1888 public void info(final LocalizableMessage m) {
1889 if (logger.isLoggable(Level.INFO)) {
1890 logger.info(m.toString(locale));
1891 }
1892 }
1893
1894 /**
1895 * Returns {@code true} if this logger will log messages at the specified
1896 * level.
1897 *
1898 * @param level
1899 * The log level.
1900 * @return {@code true} if this logger will log messages at the specified
1901 * level, otherwise {@code false}.
1902 * @see java.util.logging.Logger#isLoggable(Level)
1903 */
1904 public boolean isLoggable(final Level level) {
1905 return logger.isLoggable(level);
1906 }
1907
1908 /**
1909 * Logs a message at the specified log level.
1910 *
1911 * @param level
1912 * The log level.
1913 * @param d
1914 * The message descriptor.
1915 * @see java.util.logging.Logger#log(Level,String)
1916 */
1917 public void log(final Level level, final Arg0 d) {
1918 if (logger.isLoggable(level)) {
1919 logger.log(level, d.get().toString(locale));
1920 }
1921 }
1922
1923 /**
1924 * Logs a message at the specified log level.
1925 *
1926 * @param level
1927 * The log level.
1928 * @param d
1929 * The message descriptor.
1930 * @param thrown
1931 * The Throwable associated with log message.
1932 * @see java.util.logging.Logger#log(Level,String,Throwable)
1933 */
1934 public void log(final Level level, final Arg0 d, final Throwable thrown) {
1935 if (logger.isLoggable(level)) {
1936 logger.log(level, d.get().toString(locale), thrown);
1937 }
1938 }
1939
1940 /**
1941 * Logs a message at the specified log level.
1942 *
1943 * @param <T1>
1944 * The type of the first message argument.
1945 * @param level
1946 * The log level.
1947 * @param d
1948 * The message descriptor.
1949 * @param a1
1950 * The first message argument.
1951 * @see java.util.logging.Logger#log(Level,String)
1952 */
1953 public <T1> void log(final Level level, final Arg1<T1> d, final T1 a1) {
1954 if (logger.isLoggable(level)) {
1955 logger.log(level, d.get(a1).toString(locale));
1956 }
1957 }
1958
1959 /**
1960 * Logs a message at the specified log level.
1961 *
1962 * @param <T1>
1963 * The type of the first message argument.
1964 * @param level
1965 * The log level.
1966 * @param d
1967 * The message descriptor.
1968 * @param a1
1969 * The first message argument.
1970 * @param thrown
1971 * The Throwable associated with log message.
1972 * @see java.util.logging.Logger#log(Level,String,Throwable)
1973 */
1974 public <T1> void log(final Level level, final Arg1<T1> d, final T1 a1,
1975 final Throwable thrown) {
1976 if (logger.isLoggable(level)) {
1977 logger.log(level, d.get(a1).toString(locale), thrown);
1978 }
1979 }
1980
1981 /**
1982 * Logs a message at the specified log level.
1983 *
1984 * @param <T1>
1985 * The type of the first message argument.
1986 * @param <T2>
1987 * The type of the second message argument.
1988 * @param level
1989 * The log level.
1990 * @param d
1991 * The message descriptor.
1992 * @param a1
1993 * The first message argument.
1994 * @param a2
1995 * The second message argument.
1996 * @see java.util.logging.Logger#log(Level,String)
1997 */
1998 public <T1, T2> void log(final Level level, final Arg2<T1, T2> d,
1999 final T1 a1, final T2 a2) {
2000 if (logger.isLoggable(level)) {
2001 logger.log(level, d.get(a1, a2).toString(locale));
2002 }
2003 }
2004
2005 /**
2006 * Logs a message at the specified log level.
2007 *
2008 * @param <T1>
2009 * The type of the first message argument.
2010 * @param <T2>
2011 * The type of the second message argument.
2012 * @param level
2013 * The log level.
2014 * @param d
2015 * The message descriptor.
2016 * @param a1
2017 * The first message argument.
2018 * @param a2
2019 * The second message argument.
2020 * @param thrown
2021 * The Throwable associated with log message.
2022 * @see java.util.logging.Logger#log(Level,String,Throwable)
2023 */
2024 public <T1, T2> void log(final Level level, final Arg2<T1, T2> d,
2025 final T1 a1, final T2 a2, final Throwable thrown) {
2026 if (logger.isLoggable(level)) {
2027 logger.log(level, d.get(a1, a2).toString(locale), thrown);
2028 }
2029 }
2030
2031 /**
2032 * Logs a message at the specified log level.
2033 *
2034 * @param <T1>
2035 * The type of the first message argument.
2036 * @param <T2>
2037 * The type of the second message argument.
2038 * @param <T3>
2039 * The type of the third message argument.
2040 * @param level
2041 * The log level.
2042 * @param d
2043 * The message descriptor.
2044 * @param a1
2045 * The first message argument.
2046 * @param a2
2047 * The second message argument.
2048 * @param a3
2049 * The third message argument.
2050 * @see java.util.logging.Logger#log(Level,String)
2051 */
2052 public <T1, T2, T3> void log(final Level level, final Arg3<T1, T2, T3> d,
2053 final T1 a1, final T2 a2, final T3 a3) {
2054 if (logger.isLoggable(level)) {
2055 logger.log(level, d.get(a1, a2, a3).toString(locale));
2056 }
2057 }
2058
2059 /**
2060 * Logs a message at the specified log level.
2061 *
2062 * @param <T1>
2063 * The type of the first message argument.
2064 * @param <T2>
2065 * The type of the second message argument.
2066 * @param <T3>
2067 * The type of the third message argument.
2068 * @param level
2069 * The log level.
2070 * @param d
2071 * The message descriptor.
2072 * @param a1
2073 * The first message argument.
2074 * @param a2
2075 * The second message argument.
2076 * @param a3
2077 * The third message argument.
2078 * @param thrown
2079 * The Throwable associated with log message.
2080 * @see java.util.logging.Logger#log(Level,String,Throwable)
2081 */
2082 public <T1, T2, T3> void log(final Level level, final Arg3<T1, T2, T3> d,
2083 final T1 a1, final T2 a2, final T3 a3, final Throwable thrown) {
2084 if (logger.isLoggable(level)) {
2085 logger.log(level, d.get(a1, a2, a3).toString(locale), thrown);
2086 }
2087 }
2088
2089 /**
2090 * Logs a message at the specified log level.
2091 *
2092 * @param <T1>
2093 * The type of the first message argument.
2094 * @param <T2>
2095 * The type of the second message argument.
2096 * @param <T3>
2097 * The type of the third message argument.
2098 * @param <T4>
2099 * The type of the fourth message argument.
2100 * @param level
2101 * The log level.
2102 * @param d
2103 * The message descriptor.
2104 * @param a1
2105 * The first message argument.
2106 * @param a2
2107 * The second message argument.
2108 * @param a3
2109 * The third message argument.
2110 * @param a4
2111 * The fourth message argument.
2112 * @see java.util.logging.Logger#log(Level,String)
2113 */
2114 public <T1, T2, T3, T4> void log(final Level level,
2115 final Arg4<T1, T2, T3, T4> d, final T1 a1, final T2 a2,
2116 final T3 a3, final T4 a4) {
2117 if (logger.isLoggable(level)) {
2118 logger.log(level, d.get(a1, a2, a3, a4).toString(locale));
2119 }
2120 }
2121
2122 /**
2123 * Logs a message at the specified log level.
2124 *
2125 * @param <T1>
2126 * The type of the first message argument.
2127 * @param <T2>
2128 * The type of the second message argument.
2129 * @param <T3>
2130 * The type of the third message argument.
2131 * @param <T4>
2132 * The type of the fourth message argument.
2133 * @param level
2134 * The log level.
2135 * @param d
2136 * The message descriptor.
2137 * @param a1
2138 * The first message argument.
2139 * @param a2
2140 * The second message argument.
2141 * @param a3
2142 * The third message argument.
2143 * @param a4
2144 * The fourth message argument.
2145 * @param thrown
2146 * The Throwable associated with log message.
2147 * @see java.util.logging.Logger#log(Level,String,Throwable)
2148 */
2149 public <T1, T2, T3, T4> void log(final Level level,
2150 final Arg4<T1, T2, T3, T4> d, final T1 a1, final T2 a2,
2151 final T3 a3, final T4 a4, final Throwable thrown) {
2152 if (logger.isLoggable(level)) {
2153 logger.log(level, d.get(a1, a2, a3, a4).toString(locale), thrown);
2154 }
2155 }
2156
2157 /**
2158 * Logs a message at the specified log level.
2159 *
2160 * @param <T1>
2161 * The type of the first message argument.
2162 * @param <T2>
2163 * The type of the second message argument.
2164 * @param <T3>
2165 * The type of the third message argument.
2166 * @param <T4>
2167 * The type of the fourth message argument.
2168 * @param <T5>
2169 * The type of the fifth message argument.
2170 * @param level
2171 * The log level.
2172 * @param d
2173 * The message descriptor.
2174 * @param a1
2175 * The first message argument.
2176 * @param a2
2177 * The second message argument.
2178 * @param a3
2179 * The third message argument.
2180 * @param a4
2181 * The fourth message argument.
2182 * @param a5
2183 * The fifth message argument.
2184 * @see java.util.logging.Logger#log(Level,String)
2185 */
2186 public <T1, T2, T3, T4, T5> void log(final Level level,
2187 final Arg5<T1, T2, T3, T4, T5> d, final T1 a1, final T2 a2,
2188 final T3 a3, final T4 a4, final T5 a5) {
2189 if (logger.isLoggable(level)) {
2190 logger.log(level, d.get(a1, a2, a3, a4, a5).toString(locale));
2191 }
2192 }
2193
2194 /**
2195 * Logs a message at the specified log level.
2196 *
2197 * @param <T1>
2198 * The type of the first message argument.
2199 * @param <T2>
2200 * The type of the second message argument.
2201 * @param <T3>
2202 * The type of the third message argument.
2203 * @param <T4>
2204 * The type of the fourth message argument.
2205 * @param <T5>
2206 * The type of the fifth message argument.
2207 * @param level
2208 * The log level.
2209 * @param d
2210 * The message descriptor.
2211 * @param a1
2212 * The first message argument.
2213 * @param a2
2214 * The second message argument.
2215 * @param a3
2216 * The third message argument.
2217 * @param a4
2218 * The fourth message argument.
2219 * @param a5
2220 * The fifth message argument.
2221 * @param thrown
2222 * The Throwable associated with log message.
2223 * @see java.util.logging.Logger#log(Level,String,Throwable)
2224 */
2225 public <T1, T2, T3, T4, T5> void log(final Level level,
2226 final Arg5<T1, T2, T3, T4, T5> d, final T1 a1, final T2 a2,
2227 final T3 a3, final T4 a4, final T5 a5, final Throwable thrown) {
2228 if (logger.isLoggable(level)) {
2229 logger.log(level, d.get(a1, a2, a3, a4, a5).toString(locale),
2230 thrown);
2231 }
2232 }
2233
2234 /**
2235 * Logs a message at the specified log level.
2236 *
2237 * @param <T1>
2238 * The type of the first message argument.
2239 * @param <T2>
2240 * The type of the second message argument.
2241 * @param <T3>
2242 * The type of the third message argument.
2243 * @param <T4>
2244 * The type of the fourth message argument.
2245 * @param <T5>
2246 * The type of the fifth message argument.
2247 * @param <T6>
2248 * The type of the sixth message argument.
2249 * @param level
2250 * The log level.
2251 * @param d
2252 * The message descriptor.
2253 * @param a1
2254 * The first message argument.
2255 * @param a2
2256 * The second message argument.
2257 * @param a3
2258 * The third message argument.
2259 * @param a4
2260 * The fourth message argument.
2261 * @param a5
2262 * The fifth message argument.
2263 * @param a6
2264 * The sixth message argument.
2265 * @see java.util.logging.Logger#log(Level,String)
2266 */
2267 public <T1, T2, T3, T4, T5, T6> void log(final Level level,
2268 final Arg6<T1, T2, T3, T4, T5, T6> d, final T1 a1, final T2 a2,
2269 final T3 a3, final T4 a4, final T5 a5, final T6 a6) {
2270 if (logger.isLoggable(level)) {
2271 logger.log(level, d.get(a1, a2, a3, a4, a5, a6).toString(locale));
2272 }
2273 }
2274
2275 /**
2276 * Logs a message at the specified log level.
2277 *
2278 * @param <T1>
2279 * The type of the first message argument.
2280 * @param <T2>
2281 * The type of the second message argument.
2282 * @param <T3>
2283 * The type of the third message argument.
2284 * @param <T4>
2285 * The type of the fourth message argument.
2286 * @param <T5>
2287 * The type of the fifth message argument.
2288 * @param <T6>
2289 * The type of the sixth message argument.
2290 * @param level
2291 * The log level.
2292 * @param d
2293 * The message descriptor.
2294 * @param a1
2295 * The first message argument.
2296 * @param a2
2297 * The second message argument.
2298 * @param a3
2299 * The third message argument.
2300 * @param a4
2301 * The fourth message argument.
2302 * @param a5
2303 * The fifth message argument.
2304 * @param a6
2305 * The sixth message argument.
2306 * @param thrown
2307 * The Throwable associated with log message.
2308 * @see java.util.logging.Logger#log(Level,String,Throwable)
2309 */
2310 public <T1, T2, T3, T4, T5, T6> void log(final Level level,
2311 final Arg6<T1, T2, T3, T4, T5, T6> d, final T1 a1, final T2 a2,
2312 final T3 a3, final T4 a4, final T5 a5, final T6 a6,
2313 final Throwable thrown) {
2314 if (logger.isLoggable(level)) {
2315 logger.log(level, d.get(a1, a2, a3, a4, a5, a6).toString(locale),
2316 thrown);
2317 }
2318 }
2319
2320 /**
2321 * Logs a message at the specified log level.
2322 *
2323 * @param <T1>
2324 * The type of the first message argument.
2325 * @param <T2>
2326 * The type of the second message argument.
2327 * @param <T3>
2328 * The type of the third message argument.
2329 * @param <T4>
2330 * The type of the fourth message argument.
2331 * @param <T5>
2332 * The type of the fifth message argument.
2333 * @param <T6>
2334 * The type of the sixth message argument.
2335 * @param <T7>
2336 * The type of the seventh message argument.
2337 * @param level
2338 * The log level.
2339 * @param d
2340 * The message descriptor.
2341 * @param a1
2342 * The first message argument.
2343 * @param a2
2344 * The second message argument.
2345 * @param a3
2346 * The third message argument.
2347 * @param a4
2348 * The fourth message argument.
2349 * @param a5
2350 * The fifth message argument.
2351 * @param a6
2352 * The sixth message argument.
2353 * @param a7
2354 * The seventh message argument.
2355 * @see java.util.logging.Logger#log(Level,String)
2356 */
2357 public <T1, T2, T3, T4, T5, T6, T7> void log(final Level level,
2358 final Arg7<T1, T2, T3, T4, T5, T6, T7> d, final T1 a1, final T2 a2,
2359 final T3 a3, final T4 a4, final T5 a5, final T6 a6, final T7 a7) {
2360 if (logger.isLoggable(level)) {
2361 logger.log(level, d.get(a1, a2, a3, a4, a5, a6, a7)
2362 .toString(locale));
2363 }
2364 }
2365
2366 /**
2367 * Logs a message at the specified log level.
2368 *
2369 * @param <T1>
2370 * The type of the first message argument.
2371 * @param <T2>
2372 * The type of the second message argument.
2373 * @param <T3>
2374 * The type of the third message argument.
2375 * @param <T4>
2376 * The type of the fourth message argument.
2377 * @param <T5>
2378 * The type of the fifth message argument.
2379 * @param <T6>
2380 * The type of the sixth message argument.
2381 * @param <T7>
2382 * The type of the seventh message argument.
2383 * @param level
2384 * The log level.
2385 * @param d
2386 * The message descriptor.
2387 * @param a1
2388 * The first message argument.
2389 * @param a2
2390 * The second message argument.
2391 * @param a3
2392 * The third message argument.
2393 * @param a4
2394 * The fourth message argument.
2395 * @param a5
2396 * The fifth message argument.
2397 * @param a6
2398 * The sixth message argument.
2399 * @param a7
2400 * The seventh message argument.
2401 * @param thrown
2402 * The Throwable associated with log message.
2403 * @see java.util.logging.Logger#log(Level,String,Throwable)
2404 */
2405 public <T1, T2, T3, T4, T5, T6, T7> void log(final Level level,
2406 final Arg7<T1, T2, T3, T4, T5, T6, T7> d, final T1 a1, final T2 a2,
2407 final T3 a3, final T4 a4, final T5 a5, final T6 a6, final T7 a7,
2408 final Throwable thrown) {
2409 if (logger.isLoggable(level)) {
2410 logger.log(level, d.get(a1, a2, a3, a4, a5, a6, a7)
2411 .toString(locale), thrown);
2412 }
2413 }
2414
2415 /**
2416 * Logs a message at the specified log level.
2417 *
2418 * @param <T1>
2419 * The type of the first message argument.
2420 * @param <T2>
2421 * The type of the second message argument.
2422 * @param <T3>
2423 * The type of the third message argument.
2424 * @param <T4>
2425 * The type of the fourth message argument.
2426 * @param <T5>
2427 * The type of the fifth message argument.
2428 * @param <T6>
2429 * The type of the sixth message argument.
2430 * @param <T7>
2431 * The type of the seventh message argument.
2432 * @param <T8>
2433 * The type of the eighth message argument.
2434 * @param level
2435 * The log level.
2436 * @param d
2437 * The message descriptor.
2438 * @param a1
2439 * The first message argument.
2440 * @param a2
2441 * The second message argument.
2442 * @param a3
2443 * The third message argument.
2444 * @param a4
2445 * The fourth message argument.
2446 * @param a5
2447 * The fifth message argument.
2448 * @param a6
2449 * The sixth message argument.
2450 * @param a7
2451 * The seventh message argument.
2452 * @param a8
2453 * The eighth message argument.
2454 * @see java.util.logging.Logger#log(Level,String)
2455 */
2456 public <T1, T2, T3, T4, T5, T6, T7, T8> void log(final Level level,
2457 final Arg8<T1, T2, T3, T4, T5, T6, T7, T8> d, final T1 a1,
2458 final T2 a2, final T3 a3, final T4 a4, final T5 a5, final T6 a6,
2459 final T7 a7, final T8 a8) {
2460 if (logger.isLoggable(level)) {
2461 logger.log(level,
2462 d.get(a1, a2, a3, a4, a5, a6, a7, a8).toString(locale));
2463 }
2464 }
2465
2466 /**
2467 * Logs a message at the specified log level.
2468 *
2469 * @param <T1>
2470 * The type of the first message argument.
2471 * @param <T2>
2472 * The type of the second message argument.
2473 * @param <T3>
2474 * The type of the third message argument.
2475 * @param <T4>
2476 * The type of the fourth message argument.
2477 * @param <T5>
2478 * The type of the fifth message argument.
2479 * @param <T6>
2480 * The type of the sixth message argument.
2481 * @param <T7>
2482 * The type of the seventh message argument.
2483 * @param <T8>
2484 * The type of the eighth message argument.
2485 * @param level
2486 * The log level.
2487 * @param d
2488 * The message descriptor.
2489 * @param a1
2490 * The first message argument.
2491 * @param a2
2492 * The second message argument.
2493 * @param a3
2494 * The third message argument.
2495 * @param a4
2496 * The fourth message argument.
2497 * @param a5
2498 * The fifth message argument.
2499 * @param a6
2500 * The sixth message argument.
2501 * @param a7
2502 * The seventh message argument.
2503 * @param a8
2504 * The eighth message argument.
2505 * @param thrown
2506 * The Throwable associated with log message.
2507 * @see java.util.logging.Logger#log(Level,String,Throwable)
2508 */
2509 public <T1, T2, T3, T4, T5, T6, T7, T8> void log(final Level level,
2510 final Arg8<T1, T2, T3, T4, T5, T6, T7, T8> d, final T1 a1,
2511 final T2 a2, final T3 a3, final T4 a4, final T5 a5, final T6 a6,
2512 final T7 a7, final T8 a8, final Throwable thrown) {
2513 if (logger.isLoggable(level)) {
2514 logger.log(level,
2515 d.get(a1, a2, a3, a4, a5, a6, a7, a8).toString(locale),
2516 thrown);
2517 }
2518 }
2519
2520 /**
2521 * Logs a message at the specified log level.
2522 *
2523 * @param <T1>
2524 * The type of the first message argument.
2525 * @param <T2>
2526 * The type of the second message argument.
2527 * @param <T3>
2528 * The type of the third message argument.
2529 * @param <T4>
2530 * The type of the fourth message argument.
2531 * @param <T5>
2532 * The type of the fifth message argument.
2533 * @param <T6>
2534 * The type of the sixth message argument.
2535 * @param <T7>
2536 * The type of the seventh message argument.
2537 * @param <T8>
2538 * The type of the eighth message argument.
2539 * @param <T9>
2540 * The type of the ninth message argument.
2541 * @param level
2542 * The log level.
2543 * @param d
2544 * The message descriptor.
2545 * @param a1
2546 * The first message argument.
2547 * @param a2
2548 * The second message argument.
2549 * @param a3
2550 * The third message argument.
2551 * @param a4
2552 * The fourth message argument.
2553 * @param a5
2554 * The fifth message argument.
2555 * @param a6
2556 * The sixth message argument.
2557 * @param a7
2558 * The seventh message argument.
2559 * @param a8
2560 * The eighth message argument.
2561 * @param a9
2562 * The ninth message argument.
2563 * @see java.util.logging.Logger#log(Level,String)
2564 */
2565 public <T1, T2, T3, T4, T5, T6, T7, T8, T9> void log(final Level level,
2566 final Arg9<T1, T2, T3, T4, T5, T6, T7, T8, T9> d, final T1 a1,
2567 final T2 a2, final T3 a3, final T4 a4, final T5 a5, final T6 a6,
2568 final T7 a7, final T8 a8, final T9 a9) {
2569 if (logger.isLoggable(level)) {
2570 logger.log(level, d.get(a1, a2, a3, a4, a5, a6, a7, a8, a9)
2571 .toString(locale));
2572 }
2573 }
2574
2575 /**
2576 * Logs a message at the specified log level.
2577 *
2578 * @param <T1>
2579 * The type of the first message argument.
2580 * @param <T2>
2581 * The type of the second message argument.
2582 * @param <T3>
2583 * The type of the third message argument.
2584 * @param <T4>
2585 * The type of the fourth message argument.
2586 * @param <T5>
2587 * The type of the fifth message argument.
2588 * @param <T6>
2589 * The type of the sixth message argument.
2590 * @param <T7>
2591 * The type of the seventh message argument.
2592 * @param <T8>
2593 * The type of the eighth message argument.
2594 * @param <T9>
2595 * The type of the ninth message argument.
2596 * @param level
2597 * The log level.
2598 * @param d
2599 * The message descriptor.
2600 * @param a1
2601 * The first message argument.
2602 * @param a2
2603 * The second message argument.
2604 * @param a3
2605 * The third message argument.
2606 * @param a4
2607 * The fourth message argument.
2608 * @param a5
2609 * The fifth message argument.
2610 * @param a6
2611 * The sixth message argument.
2612 * @param a7
2613 * The seventh message argument.
2614 * @param a8
2615 * The eighth message argument.
2616 * @param a9
2617 * The ninth message argument.
2618 * @param thrown
2619 * The Throwable associated with log message.
2620 * @see java.util.logging.Logger#log(Level,String,Throwable)
2621 */
2622 public <T1, T2, T3, T4, T5, T6, T7, T8, T9> void log(final Level level,
2623 final Arg9<T1, T2, T3, T4, T5, T6, T7, T8, T9> d, final T1 a1,
2624 final T2 a2, final T3 a3, final T4 a4, final T5 a5, final T6 a6,
2625 final T7 a7, final T8 a8, final T9 a9, final Throwable thrown) {
2626 if (logger.isLoggable(level)) {
2627 logger.log(level, d.get(a1, a2, a3, a4, a5, a6, a7, a8, a9)
2628 .toString(locale), thrown);
2629 }
2630 }
2631
2632 /**
2633 * Logs a message at the specified log level.
2634 *
2635 * @param level
2636 * The log level.
2637 * @param d
2638 * The message descriptor.
2639 * @param args
2640 * The message arguments.
2641 * @see java.util.logging.Logger#log(Level,String)
2642 */
2643 public void log(final Level level, final ArgN d, final Object... args) {
2644 if (logger.isLoggable(level)) {
2645 logger.log(level, d.get(args).toString(locale));
2646 }
2647 }
2648
2649 /**
2650 * Logs a message at the specified log level.
2651 *
2652 * @param level
2653 * The log level.
2654 * @param d
2655 * The message descriptor.
2656 * @param thrown
2657 * The Throwable associated with log message.
2658 * @param args
2659 * The message arguments.
2660 * @see java.util.logging.Logger#log(Level,String,Throwable)
2661 */
2662 public void log(final Level level, final ArgN d, final Throwable thrown,
2663 final Object... args) {
2664 if (logger.isLoggable(level)) {
2665 logger.log(level, d.get(args).toString(locale), thrown);
2666 }
2667 }
2668
2669 /**
2670 * Logs a message at the specified log level.
2671 *
2672 * @param level
2673 * The log level.
2674 * @param m
2675 * The pre-formatted message.
2676 * @see java.util.logging.Logger#log(Level,String)
2677 */
2678 public void log(final Level level, final LocalizableMessage m) {
2679 if (logger.isLoggable(level)) {
2680 logger.log(level, m.toString(locale));
2681 }
2682 }
2683
2684 /**
2685 * Logs a message at the specified log level.
2686 *
2687 * @param level
2688 * The log level.
2689 * @param m
2690 * The pre-formatted message.
2691 * @param thrown
2692 * The Throwable associated with log message.
2693 * @see java.util.logging.Logger#log(Level,String,Throwable)
2694 */
2695 public void log(final Level level, final LocalizableMessage m,
2696 final Throwable thrown) {
2697 if (logger.isLoggable(level)) {
2698 logger.log(level, m.toString(locale), thrown);
2699 }
2700 }
2701
2702 /**
2703 * Logs a message at the specified log level.
2704 *
2705 * @param level
2706 * The log level.
2707 * @param sourceClass
2708 * The name of class that issued the logging request.
2709 * @param sourceMethod
2710 * The name of class that issued the logging request.
2711 * @param d
2712 * The message descriptor.
2713 * @see java.util.logging.Logger#logp(Level,String,String,String)
2714 */
2715 public void logp(final Level level, final String sourceClass,
2716 final String sourceMethod, final Arg0 d) {
2717 if (logger.isLoggable(level)) {
2718 logger.logp(level, sourceClass, sourceMethod,
2719 d.get().toString(locale));
2720 }
2721 }
2722
2723 /**
2724 * Logs a message at the specified log level.
2725 *
2726 * @param level
2727 * The log level.
2728 * @param sourceClass
2729 * The name of class that issued the logging request.
2730 * @param sourceMethod
2731 * The name of class that issued the logging request.
2732 * @param d
2733 * The message descriptor.
2734 * @param thrown
2735 * The Throwable associated with log message.
2736 * @see java.util.logging.Logger#logp(Level,String,String,String,Throwable)
2737 */
2738 public void logp(final Level level, final String sourceClass,
2739 final String sourceMethod, final Arg0 d, final Throwable thrown) {
2740 if (logger.isLoggable(level)) {
2741 logger.logp(level, sourceClass, sourceMethod,
2742 d.get().toString(locale), thrown);
2743 }
2744 }
2745
2746 /**
2747 * Logs a message at the specified log level.
2748 *
2749 * @param <T1>
2750 * The type of the first message argument.
2751 * @param level
2752 * The log level.
2753 * @param d
2754 * The message descriptor.
2755 * @param sourceClass
2756 * The name of class that issued the logging request.
2757 * @param sourceMethod
2758 * The name of class that issued the logging request.
2759 * @param a1
2760 * The first message argument.
2761 * @see java.util.logging.Logger#logp(Level,String,String,String)
2762 */
2763 public <T1> void logp(final Level level, final String sourceClass,
2764 final String sourceMethod, final Arg1<T1> d, final T1 a1) {
2765 if (logger.isLoggable(level)) {
2766 logger.logp(level, sourceClass, sourceMethod,
2767 d.get(a1).toString(locale));
2768 }
2769 }
2770
2771 /**
2772 * Logs a message at the specified log level.
2773 *
2774 * @param <T1>
2775 * The type of the first message argument.
2776 * @param level
2777 * The log level.
2778 * @param d
2779 * The message descriptor.
2780 * @param sourceClass
2781 * The name of class that issued the logging request.
2782 * @param sourceMethod
2783 * The name of class that issued the logging request.
2784 * @param a1
2785 * The first message argument.
2786 * @param thrown
2787 * The Throwable associated with log message.
2788 * @see java.util.logging.Logger#logp(Level,String,String,String,Throwable)
2789 */
2790 public <T1> void logp(final Level level, final String sourceClass,
2791 final String sourceMethod, final Arg1<T1> d, final T1 a1,
2792 final Throwable thrown) {
2793 if (logger.isLoggable(level)) {
2794 logger.logp(level, sourceClass, sourceMethod,
2795 d.get(a1).toString(locale), thrown);
2796 }
2797 }
2798
2799 /**
2800 * Logs a message at the specified log level.
2801 *
2802 * @param <T1>
2803 * The type of the first message argument.
2804 * @param <T2>
2805 * The type of the second message argument.
2806 * @param level
2807 * The log level.
2808 * @param d
2809 * The message descriptor.
2810 * @param sourceClass
2811 * The name of class that issued the logging request.
2812 * @param sourceMethod
2813 * The name of class that issued the logging request.
2814 * @param a1
2815 * The first message argument.
2816 * @param a2
2817 * The second message argument.
2818 * @see java.util.logging.Logger#logp(Level,String,String,String)
2819 */
2820 public <T1, T2> void logp(final Level level, final String sourceClass,
2821 final String sourceMethod, final Arg2<T1, T2> d, final T1 a1,
2822 final T2 a2) {
2823 if (logger.isLoggable(level)) {
2824 logger.logp(level, sourceClass, sourceMethod, d.get(a1, a2)
2825 .toString(locale));
2826 }
2827 }
2828
2829 /**
2830 * Logs a message at the specified log level.
2831 *
2832 * @param <T1>
2833 * The type of the first message argument.
2834 * @param <T2>
2835 * The type of the second message argument.
2836 * @param level
2837 * The log level.
2838 * @param d
2839 * The message descriptor.
2840 * @param sourceClass
2841 * The name of class that issued the logging request.
2842 * @param sourceMethod
2843 * The name of class that issued the logging request.
2844 * @param a1
2845 * The first message argument.
2846 * @param a2
2847 * The second message argument.
2848 * @param thrown
2849 * The Throwable associated with log message.
2850 * @see java.util.logging.Logger#logp(Level,String,String,String,Throwable)
2851 */
2852 public <T1, T2> void logp(final Level level, final String sourceClass,
2853 final String sourceMethod, final Arg2<T1, T2> d, final T1 a1,
2854 final T2 a2, final Throwable thrown) {
2855 if (logger.isLoggable(level)) {
2856 logger.logp(level, sourceClass, sourceMethod, d.get(a1, a2)
2857 .toString(locale), thrown);
2858 }
2859 }
2860
2861 /**
2862 * Logs a message at the specified log level.
2863 *
2864 * @param <T1>
2865 * The type of the first message argument.
2866 * @param <T2>
2867 * The type of the second message argument.
2868 * @param <T3>
2869 * The type of the third message argument.
2870 * @param level
2871 * The log level.
2872 * @param d
2873 * The message descriptor.
2874 * @param sourceClass
2875 * The name of class that issued the logging request.
2876 * @param sourceMethod
2877 * The name of class that issued the logging request.
2878 * @param a1
2879 * The first message argument.
2880 * @param a2
2881 * The second message argument.
2882 * @param a3
2883 * The third message argument.
2884 * @see java.util.logging.Logger#logp(Level,String,String,String)
2885 */
2886 public <T1, T2, T3> void logp(final Level level, final String sourceClass,
2887 final String sourceMethod, final Arg3<T1, T2, T3> d, final T1 a1,
2888 final T2 a2, final T3 a3) {
2889 if (logger.isLoggable(level)) {
2890 logger.logp(level, sourceClass, sourceMethod, d.get(a1, a2, a3)
2891 .toString(locale));
2892 }
2893 }
2894
2895 /**
2896 * Logs a message at the specified log level.
2897 *
2898 * @param <T1>
2899 * The type of the first message argument.
2900 * @param <T2>
2901 * The type of the second message argument.
2902 * @param <T3>
2903 * The type of the third message argument.
2904 * @param level
2905 * The log level.
2906 * @param d
2907 * The message descriptor.
2908 * @param sourceClass
2909 * The name of class that issued the logging request.
2910 * @param sourceMethod
2911 * The name of class that issued the logging request.
2912 * @param a1
2913 * The first message argument.
2914 * @param a2
2915 * The second message argument.
2916 * @param a3
2917 * The third message argument.
2918 * @param thrown
2919 * The Throwable associated with log message.
2920 * @see java.util.logging.Logger#logp(Level,String,String,String,Throwable)
2921 */
2922 public <T1, T2, T3> void logp(final Level level, final String sourceClass,
2923 final String sourceMethod, final Arg3<T1, T2, T3> d, final T1 a1,
2924 final T2 a2, final T3 a3, final Throwable thrown) {
2925 if (logger.isLoggable(level)) {
2926 logger.logp(level, sourceClass, sourceMethod, d.get(a1, a2, a3)
2927 .toString(locale), thrown);
2928 }
2929 }
2930
2931 /**
2932 * Logs a message at the specified log level.
2933 *
2934 * @param <T1>
2935 * The type of the first message argument.
2936 * @param <T2>
2937 * The type of the second message argument.
2938 * @param <T3>
2939 * The type of the third message argument.
2940 * @param <T4>
2941 * The type of the fourth message argument.
2942 * @param level
2943 * The log level.
2944 * @param d
2945 * The message descriptor.
2946 * @param sourceClass
2947 * The name of class that issued the logging request.
2948 * @param sourceMethod
2949 * The name of class that issued the logging request.
2950 * @param a1
2951 * The first message argument.
2952 * @param a2
2953 * The second message argument.
2954 * @param a3
2955 * The third message argument.
2956 * @param a4
2957 * The fourth message argument.
2958 * @see java.util.logging.Logger#logp(Level,String,String,String)
2959 */
2960 public <T1, T2, T3, T4> void logp(final Level level,
2961 final String sourceClass, final String sourceMethod,
2962 final Arg4<T1, T2, T3, T4> d, final T1 a1, final T2 a2,
2963 final T3 a3, final T4 a4) {
2964 if (logger.isLoggable(level)) {
2965 logger.logp(level, sourceClass, sourceMethod, d.get(a1, a2, a3, a4)
2966 .toString(locale));
2967 }
2968 }
2969
2970 /**
2971 * Logs a message at the specified log level.
2972 *
2973 * @param <T1>
2974 * The type of the first message argument.
2975 * @param <T2>
2976 * The type of the second message argument.
2977 * @param <T3>
2978 * The type of the third message argument.
2979 * @param <T4>
2980 * The type of the fourth message argument.
2981 * @param level
2982 * The log level.
2983 * @param d
2984 * The message descriptor.
2985 * @param sourceClass
2986 * The name of class that issued the logging request.
2987 * @param sourceMethod
2988 * The name of class that issued the logging request.
2989 * @param a1
2990 * The first message argument.
2991 * @param a2
2992 * The second message argument.
2993 * @param a3
2994 * The third message argument.
2995 * @param a4
2996 * The fourth message argument.
2997 * @param thrown
2998 * The Throwable associated with log message.
2999 * @see java.util.logging.Logger#logp(Level,String,String,String,Throwable)
3000 */
3001 public <T1, T2, T3, T4> void logp(final Level level,
3002 final String sourceClass, final String sourceMethod,
3003 final Arg4<T1, T2, T3, T4> d, final T1 a1, final T2 a2,
3004 final T3 a3, final T4 a4, final Throwable thrown) {
3005 if (logger.isLoggable(level)) {
3006 logger.logp(level, sourceClass, sourceMethod, d.get(a1, a2, a3, a4)
3007 .toString(locale), thrown);
3008 }
3009 }
3010
3011 /**
3012 * Logs a message at the specified log level.
3013 *
3014 * @param <T1>
3015 * The type of the first message argument.
3016 * @param <T2>
3017 * The type of the second message argument.
3018 * @param <T3>
3019 * The type of the third message argument.
3020 * @param <T4>
3021 * The type of the fourth message argument.
3022 * @param <T5>
3023 * The type of the fifth message argument.
3024 * @param level
3025 * The log level.
3026 * @param d
3027 * The message descriptor.
3028 * @param sourceClass
3029 * The name of class that issued the logging request.
3030 * @param sourceMethod
3031 * The name of class that issued the logging request.
3032 * @param a1
3033 * The first message argument.
3034 * @param a2
3035 * The second message argument.
3036 * @param a3
3037 * The third message argument.
3038 * @param a4
3039 * The fourth message argument.
3040 * @param a5
3041 * The fifth message argument.
3042 * @see java.util.logging.Logger#logp(Level,String,String,String)
3043 */
3044 public <T1, T2, T3, T4, T5> void logp(final Level level,
3045 final String sourceClass, final String sourceMethod,
3046 final Arg5<T1, T2, T3, T4, T5> d, final T1 a1, final T2 a2,
3047 final T3 a3, final T4 a4, final T5 a5) {
3048 if (logger.isLoggable(level)) {
3049 logger.logp(level, sourceClass, sourceMethod,
3050 d.get(a1, a2, a3, a4, a5).toString(locale));
3051 }
3052 }
3053
3054 /**
3055 * Logs a message at the specified log level.
3056 *
3057 * @param <T1>
3058 * The type of the first message argument.
3059 * @param <T2>
3060 * The type of the second message argument.
3061 * @param <T3>
3062 * The type of the third message argument.
3063 * @param <T4>
3064 * The type of the fourth message argument.
3065 * @param <T5>
3066 * The type of the fifth message argument.
3067 * @param level
3068 * The log level.
3069 * @param d
3070 * The message descriptor.
3071 * @param sourceClass
3072 * The name of class that issued the logging request.
3073 * @param sourceMethod
3074 * The name of class that issued the logging request.
3075 * @param a1
3076 * The first message argument.
3077 * @param a2
3078 * The second message argument.
3079 * @param a3
3080 * The third message argument.
3081 * @param a4
3082 * The fourth message argument.
3083 * @param a5
3084 * The fifth message argument.
3085 * @param thrown
3086 * The Throwable associated with log message.
3087 * @see java.util.logging.Logger#logp(Level,String,String,String,Throwable)
3088 */
3089 public <T1, T2, T3, T4, T5> void logp(final Level level,
3090 final String sourceClass, final String sourceMethod,
3091 final Arg5<T1, T2, T3, T4, T5> d, final T1 a1, final T2 a2,
3092 final T3 a3, final T4 a4, final T5 a5, final Throwable thrown) {
3093 if (logger.isLoggable(level)) {
3094 logger.logp(level, sourceClass, sourceMethod,
3095 d.get(a1, a2, a3, a4, a5).toString(locale), thrown);
3096 }
3097 }
3098
3099 /**
3100 * Logs a message at the specified log level.
3101 *
3102 * @param <T1>
3103 * The type of the first message argument.
3104 * @param <T2>
3105 * The type of the second message argument.
3106 * @param <T3>
3107 * The type of the third message argument.
3108 * @param <T4>
3109 * The type of the fourth message argument.
3110 * @param <T5>
3111 * The type of the fifth message argument.
3112 * @param <T6>
3113 * The type of the sixth message argument.
3114 * @param level
3115 * The log level.
3116 * @param d
3117 * The message descriptor.
3118 * @param sourceClass
3119 * The name of class that issued the logging request.
3120 * @param sourceMethod
3121 * The name of class that issued the logging request.
3122 * @param a1
3123 * The first message argument.
3124 * @param a2
3125 * The second message argument.
3126 * @param a3
3127 * The third message argument.
3128 * @param a4
3129 * The fourth message argument.
3130 * @param a5
3131 * The fifth message argument.
3132 * @param a6
3133 * The sixth message argument.
3134 * @see java.util.logging.Logger#logp(Level,String,String,String)
3135 */
3136 public <T1, T2, T3, T4, T5, T6> void logp(final Level level,
3137 final String sourceClass, final String sourceMethod,
3138 final Arg6<T1, T2, T3, T4, T5, T6> d, final T1 a1, final T2 a2,
3139 final T3 a3, final T4 a4, final T5 a5, final T6 a6) {
3140 if (logger.isLoggable(level)) {
3141 logger.logp(level, sourceClass, sourceMethod,
3142 d.get(a1, a2, a3, a4, a5, a6).toString(locale));
3143 }
3144 }
3145
3146 /**
3147 * Logs a message at the specified log level.
3148 *
3149 * @param <T1>
3150 * The type of the first message argument.
3151 * @param <T2>
3152 * The type of the second message argument.
3153 * @param <T3>
3154 * The type of the third message argument.
3155 * @param <T4>
3156 * The type of the fourth message argument.
3157 * @param <T5>
3158 * The type of the fifth message argument.
3159 * @param <T6>
3160 * The type of the sixth message argument.
3161 * @param level
3162 * The log level.
3163 * @param d
3164 * The message descriptor.
3165 * @param sourceClass
3166 * The name of class that issued the logging request.
3167 * @param sourceMethod
3168 * The name of class that issued the logging request.
3169 * @param a1
3170 * The first message argument.
3171 * @param a2
3172 * The second message argument.
3173 * @param a3
3174 * The third message argument.
3175 * @param a4
3176 * The fourth message argument.
3177 * @param a5
3178 * The fifth message argument.
3179 * @param a6
3180 * The sixth message argument.
3181 * @param thrown
3182 * The Throwable associated with log message.
3183 * @see java.util.logging.Logger#logp(Level,String,String,String,Throwable)
3184 */
3185 public <T1, T2, T3, T4, T5, T6> void logp(final Level level,
3186 final String sourceClass, final String sourceMethod,
3187 final Arg6<T1, T2, T3, T4, T5, T6> d, final T1 a1, final T2 a2,
3188 final T3 a3, final T4 a4, final T5 a5, final T6 a6,
3189 final Throwable thrown) {
3190 if (logger.isLoggable(level)) {
3191 logger.logp(level, sourceClass, sourceMethod,
3192 d.get(a1, a2, a3, a4, a5, a6).toString(locale), thrown);
3193 }
3194 }
3195
3196 /**
3197 * Logs a message at the specified log level.
3198 *
3199 * @param <T1>
3200 * The type of the first message argument.
3201 * @param <T2>
3202 * The type of the second message argument.
3203 * @param <T3>
3204 * The type of the third message argument.
3205 * @param <T4>
3206 * The type of the fourth message argument.
3207 * @param <T5>
3208 * The type of the fifth message argument.
3209 * @param <T6>
3210 * The type of the sixth message argument.
3211 * @param <T7>
3212 * The type of the seventh message argument.
3213 * @param level
3214 * The log level.
3215 * @param d
3216 * The message descriptor.
3217 * @param sourceClass
3218 * The name of class that issued the logging request.
3219 * @param sourceMethod
3220 * The name of class that issued the logging request.
3221 * @param a1
3222 * The first message argument.
3223 * @param a2
3224 * The second message argument.
3225 * @param a3
3226 * The third message argument.
3227 * @param a4
3228 * The fourth message argument.
3229 * @param a5
3230 * The fifth message argument.
3231 * @param a6
3232 * The sixth message argument.
3233 * @param a7
3234 * The seventh message argument.
3235 * @see java.util.logging.Logger#logp(Level,String,String,String)
3236 */
3237 public <T1, T2, T3, T4, T5, T6, T7> void logp(final Level level,
3238 final String sourceClass, final String sourceMethod,
3239 final Arg7<T1, T2, T3, T4, T5, T6, T7> d, final T1 a1, final T2 a2,
3240 final T3 a3, final T4 a4, final T5 a5, final T6 a6, final T7 a7) {
3241 if (logger.isLoggable(level)) {
3242 logger.logp(level, sourceClass, sourceMethod,
3243 d.get(a1, a2, a3, a4, a5, a6, a7).toString(locale));
3244 }
3245 }
3246
3247 /**
3248 * Logs a message at the specified log level.
3249 *
3250 * @param <T1>
3251 * The type of the first message argument.
3252 * @param <T2>
3253 * The type of the second message argument.
3254 * @param <T3>
3255 * The type of the third message argument.
3256 * @param <T4>
3257 * The type of the fourth message argument.
3258 * @param <T5>
3259 * The type of the fifth message argument.
3260 * @param <T6>
3261 * The type of the sixth message argument.
3262 * @param <T7>
3263 * The type of the seventh message argument.
3264 * @param level
3265 * The log level.
3266 * @param d
3267 * The message descriptor.
3268 * @param sourceClass
3269 * The name of class that issued the logging request.
3270 * @param sourceMethod
3271 * The name of class that issued the logging request.
3272 * @param a1
3273 * The first message argument.
3274 * @param a2
3275 * The second message argument.
3276 * @param a3
3277 * The third message argument.
3278 * @param a4
3279 * The fourth message argument.
3280 * @param a5
3281 * The fifth message argument.
3282 * @param a6
3283 * The sixth message argument.
3284 * @param a7
3285 * The seventh message argument.
3286 * @param thrown
3287 * The Throwable associated with log message.
3288 * @see java.util.logging.Logger#logp(Level,String,String,String,Throwable)
3289 */
3290 public <T1, T2, T3, T4, T5, T6, T7> void logp(final Level level,
3291 final String sourceClass, final String sourceMethod,
3292 final Arg7<T1, T2, T3, T4, T5, T6, T7> d, final T1 a1, final T2 a2,
3293 final T3 a3, final T4 a4, final T5 a5, final T6 a6, final T7 a7,
3294 final Throwable thrown) {
3295 if (logger.isLoggable(level)) {
3296 logger.logp(level, sourceClass, sourceMethod,
3297 d.get(a1, a2, a3, a4, a5, a6, a7).toString(locale), thrown);
3298 }
3299 }
3300
3301 /**
3302 * Logs a message at the specified log level.
3303 *
3304 * @param <T1>
3305 * The type of the first message argument.
3306 * @param <T2>
3307 * The type of the second message argument.
3308 * @param <T3>
3309 * The type of the third message argument.
3310 * @param <T4>
3311 * The type of the fourth message argument.
3312 * @param <T5>
3313 * The type of the fifth message argument.
3314 * @param <T6>
3315 * The type of the sixth message argument.
3316 * @param <T7>
3317 * The type of the seventh message argument.
3318 * @param <T8>
3319 * The type of the eighth message argument.
3320 * @param level
3321 * The log level.
3322 * @param d
3323 * The message descriptor.
3324 * @param sourceClass
3325 * The name of class that issued the logging request.
3326 * @param sourceMethod
3327 * The name of class that issued the logging request.
3328 * @param a1
3329 * The first message argument.
3330 * @param a2
3331 * The second message argument.
3332 * @param a3
3333 * The third message argument.
3334 * @param a4
3335 * The fourth message argument.
3336 * @param a5
3337 * The fifth message argument.
3338 * @param a6
3339 * The sixth message argument.
3340 * @param a7
3341 * The seventh message argument.
3342 * @param a8
3343 * The eighth message argument.
3344 * @see java.util.logging.Logger#logp(Level,String,String,String)
3345 */
3346 public <T1, T2, T3, T4, T5, T6, T7, T8> void logp(final Level level,
3347 final String sourceClass, final String sourceMethod,
3348 final Arg8<T1, T2, T3, T4, T5, T6, T7, T8> d, final T1 a1,
3349 final T2 a2, final T3 a3, final T4 a4, final T5 a5, final T6 a6,
3350 final T7 a7, final T8 a8) {
3351 if (logger.isLoggable(level)) {
3352 logger.logp(level, sourceClass, sourceMethod,
3353 d.get(a1, a2, a3, a4, a5, a6, a7, a8).toString(locale));
3354 }
3355 }
3356
3357 /**
3358 * Logs a message at the specified log level.
3359 *
3360 * @param <T1>
3361 * The type of the first message argument.
3362 * @param <T2>
3363 * The type of the second message argument.
3364 * @param <T3>
3365 * The type of the third message argument.
3366 * @param <T4>
3367 * The type of the fourth message argument.
3368 * @param <T5>
3369 * The type of the fifth message argument.
3370 * @param <T6>
3371 * The type of the sixth message argument.
3372 * @param <T7>
3373 * The type of the seventh message argument.
3374 * @param <T8>
3375 * The type of the eighth message argument.
3376 * @param level
3377 * The log level.
3378 * @param d
3379 * The message descriptor.
3380 * @param sourceClass
3381 * The name of class that issued the logging request.
3382 * @param sourceMethod
3383 * The name of class that issued the logging request.
3384 * @param a1
3385 * The first message argument.
3386 * @param a2
3387 * The second message argument.
3388 * @param a3
3389 * The third message argument.
3390 * @param a4
3391 * The fourth message argument.
3392 * @param a5
3393 * The fifth message argument.
3394 * @param a6
3395 * The sixth message argument.
3396 * @param a7
3397 * The seventh message argument.
3398 * @param a8
3399 * The eighth message argument.
3400 * @param thrown
3401 * The Throwable associated with log message.
3402 * @see java.util.logging.Logger#logp(Level,String,String,String,Throwable)
3403 */
3404 public <T1, T2, T3, T4, T5, T6, T7, T8> void logp(final Level level,
3405 final String sourceClass, final String sourceMethod,
3406 final Arg8<T1, T2, T3, T4, T5, T6, T7, T8> d, final T1 a1,
3407 final T2 a2, final T3 a3, final T4 a4, final T5 a5, final T6 a6,
3408 final T7 a7, final T8 a8, final Throwable thrown) {
3409 if (logger.isLoggable(level)) {
3410 logger.logp(level, sourceClass, sourceMethod,
3411 d.get(a1, a2, a3, a4, a5, a6, a7, a8).toString(locale),
3412 thrown);
3413 }
3414 }
3415
3416 /**
3417 * Logs a message at the specified log level.
3418 *
3419 * @param <T1>
3420 * The type of the first message argument.
3421 * @param <T2>
3422 * The type of the second message argument.
3423 * @param <T3>
3424 * The type of the third message argument.
3425 * @param <T4>
3426 * The type of the fourth message argument.
3427 * @param <T5>
3428 * The type of the fifth message argument.
3429 * @param <T6>
3430 * The type of the sixth message argument.
3431 * @param <T7>
3432 * The type of the seventh message argument.
3433 * @param <T8>
3434 * The type of the eighth message argument.
3435 * @param <T9>
3436 * The type of the ninth message argument.
3437 * @param level
3438 * The log level.
3439 * @param sourceClass
3440 * The name of class that issued the logging request.
3441 * @param sourceMethod
3442 * The name of class that issued the logging request.
3443 * @param d
3444 * The message descriptor.
3445 * @param a1
3446 * The first message argument.
3447 * @param a2
3448 * The second message argument.
3449 * @param a3
3450 * The third message argument.
3451 * @param a4
3452 * The fourth message argument.
3453 * @param a5
3454 * The fifth message argument.
3455 * @param a6
3456 * The sixth message argument.
3457 * @param a7
3458 * The seventh message argument.
3459 * @param a8
3460 * The eighth message argument.
3461 * @param a9
3462 * The ninth message argument.
3463 * @see java.util.logging.Logger#logp(Level,String,String,String)
3464 */
3465 public <T1, T2, T3, T4, T5, T6, T7, T8, T9> void logp(final Level level,
3466 final String sourceClass, final String sourceMethod,
3467 final Arg9<T1, T2, T3, T4, T5, T6, T7, T8, T9> d, final T1 a1,
3468 final T2 a2, final T3 a3, final T4 a4, final T5 a5, final T6 a6,
3469 final T7 a7, final T8 a8, final T9 a9) {
3470 if (logger.isLoggable(level)) {
3471 logger.logp(level, sourceClass, sourceMethod,
3472 d.get(a1, a2, a3, a4, a5, a6, a7, a8, a9).toString(locale));
3473 }
3474 }
3475
3476 /**
3477 * Logs a message at the specified log level.
3478 *
3479 * @param <T1>
3480 * The type of the first message argument.
3481 * @param <T2>
3482 * The type of the second message argument.
3483 * @param <T3>
3484 * The type of the third message argument.
3485 * @param <T4>
3486 * The type of the fourth message argument.
3487 * @param <T5>
3488 * The type of the fifth message argument.
3489 * @param <T6>
3490 * The type of the sixth message argument.
3491 * @param <T7>
3492 * The type of the seventh message argument.
3493 * @param <T8>
3494 * The type of the eighth message argument.
3495 * @param <T9>
3496 * The type of the ninth message argument.
3497 * @param level
3498 * The log level.
3499 * @param sourceClass
3500 * The name of class that issued the logging request.
3501 * @param sourceMethod
3502 * The name of class that issued the logging request.
3503 * @param d
3504 * The message descriptor.
3505 * @param a1
3506 * The first message argument.
3507 * @param a2
3508 * The second message argument.
3509 * @param a3
3510 * The third message argument.
3511 * @param a4
3512 * The fourth message argument.
3513 * @param a5
3514 * The fifth message argument.
3515 * @param a6
3516 * The sixth message argument.
3517 * @param a7
3518 * The seventh message argument.
3519 * @param a8
3520 * The eighth message argument.
3521 * @param a9
3522 * The ninth message argument.
3523 * @param thrown
3524 * The Throwable associated with log message.
3525 * @see java.util.logging.Logger#logp(Level,String,String,String,Throwable)
3526 */
3527 public <T1, T2, T3, T4, T5, T6, T7, T8, T9> void logp(final Level level,
3528 final String sourceClass, final String sourceMethod,
3529 final Arg9<T1, T2, T3, T4, T5, T6, T7, T8, T9> d, final T1 a1,
3530 final T2 a2, final T3 a3, final T4 a4, final T5 a5, final T6 a6,
3531 final T7 a7, final T8 a8, final T9 a9, final Throwable thrown) {
3532 if (logger.isLoggable(level)) {
3533 logger.logp(level, sourceClass, sourceMethod,
3534 d.get(a1, a2, a3, a4, a5, a6, a7, a8, a9).toString(locale),
3535 thrown);
3536 }
3537 }
3538
3539 /**
3540 * Logs a message at the specified log level.
3541 *
3542 * @param level
3543 * The log level.
3544 * @param sourceClass
3545 * The name of class that issued the logging request.
3546 * @param sourceMethod
3547 * The name of class that issued the logging request.
3548 * @param d
3549 * The message descriptor.
3550 * @param args
3551 * The message arguments.
3552 * @see java.util.logging.Logger#logp(Level,String,String,String)
3553 */
3554 public void logp(final Level level, final String sourceClass,
3555 final String sourceMethod, final ArgN d, final Object... args) {
3556 if (logger.isLoggable(level)) {
3557 logger.logp(level, sourceClass, sourceMethod,
3558 d.get(args).toString(locale));
3559 }
3560 }
3561
3562 /**
3563 * Logs a message at the specified log level.
3564 *
3565 * @param level
3566 * The log level.
3567 * @param sourceClass
3568 * The name of class that issued the logging request.
3569 * @param sourceMethod
3570 * The name of class that issued the logging request.
3571 * @param d
3572 * The message descriptor.
3573 * @param thrown
3574 * The Throwable associated with log message.
3575 * @param args
3576 * The message arguments.
3577 * @see java.util.logging.Logger#logp(Level,String,String,String,Throwable)
3578 */
3579 public void logp(final Level level, final String sourceClass,
3580 final String sourceMethod, final ArgN d, final Throwable thrown,
3581 final Object... args) {
3582 if (logger.isLoggable(level)) {
3583 logger.logp(level, sourceClass, sourceMethod,
3584 d.get(args).toString(locale), thrown);
3585 }
3586 }
3587
3588 /**
3589 * Logs a message at the specified log level.
3590 *
3591 * @param level
3592 * The log level.
3593 * @param sourceClass
3594 * The name of class that issued the logging request.
3595 * @param sourceMethod
3596 * The name of class that issued the logging request.
3597 * @param m
3598 * The pre-formatted message.
3599 * @see java.util.logging.Logger#logp(Level,String,String,String)
3600 */
3601 public void logp(final Level level, final String sourceClass,
3602 final String sourceMethod, final LocalizableMessage m) {
3603 if (logger.isLoggable(level)) {
3604 logger.logp(level, sourceClass, sourceMethod, m.toString(locale));
3605 }
3606 }
3607
3608 /**
3609 * Logs a message at the specified log level.
3610 *
3611 * @param level
3612 * The log level.
3613 * @param sourceClass
3614 * The name of class that issued the logging request.
3615 * @param sourceMethod
3616 * The name of class that issued the logging request.
3617 * @param m
3618 * The pre-formatted message.
3619 * @param thrown
3620 * The Throwable associated with log message.
3621 * @see java.util.logging.Logger#logp(Level,String,String,String,Throwable)
3622 */
3623 public void logp(final Level level, final String sourceClass,
3624 final String sourceMethod, final LocalizableMessage m,
3625 final Throwable thrown) {
3626 if (logger.isLoggable(level)) {
3627 logger.logp(level, sourceClass, sourceMethod, m.toString(locale),
3628 thrown);
3629 }
3630 }
3631
3632 /**
3633 * Logs a SEVERE message.
3634 *
3635 * @param d
3636 * The message descriptor.
3637 * @see java.util.logging.Logger#severe(String)
3638 */
3639 public void severe(final Arg0 d) {
3640 if (logger.isLoggable(Level.SEVERE)) {
3641 logger.severe(d.get().toString(locale));
3642 }
3643 }
3644
3645 /**
3646 * Logs a SEVERE message.
3647 *
3648 * @param <T1>
3649 * The type of the first message argument.
3650 * @param d
3651 * The message descriptor.
3652 * @param a1
3653 * The first message argument.
3654 * @see java.util.logging.Logger#severe(String)
3655 */
3656 public <T1> void severe(final Arg1<T1> d, final T1 a1) {
3657 if (logger.isLoggable(Level.SEVERE)) {
3658 logger.severe(d.get(a1).toString(locale));
3659 }
3660 }
3661
3662 /**
3663 * Logs a SEVERE message.
3664 *
3665 * @param <T1>
3666 * The type of the first message argument.
3667 * @param <T2>
3668 * The type of the second message argument.
3669 * @param d
3670 * The message descriptor.
3671 * @param a1
3672 * The first message argument.
3673 * @param a2
3674 * The second message argument.
3675 * @see java.util.logging.Logger#severe(String)
3676 */
3677 public <T1, T2> void severe(final Arg2<T1, T2> d, final T1 a1, final T2 a2) {
3678 if (logger.isLoggable(Level.SEVERE)) {
3679 logger.severe(d.get(a1, a2).toString(locale));
3680 }
3681 }
3682
3683 /**
3684 * Logs a SEVERE message.
3685 *
3686 * @param <T1>
3687 * The type of the first message argument.
3688 * @param <T2>
3689 * The type of the second message argument.
3690 * @param <T3>
3691 * The type of the third message argument.
3692 * @param d
3693 * The message descriptor.
3694 * @param a1
3695 * The first message argument.
3696 * @param a2
3697 * The second message argument.
3698 * @param a3
3699 * The third message argument.
3700 * @see java.util.logging.Logger#severe(String)
3701 */
3702 public <T1, T2, T3> void severe(final Arg3<T1, T2, T3> d, final T1 a1,
3703 final T2 a2, final T3 a3) {
3704 if (logger.isLoggable(Level.SEVERE)) {
3705 logger.severe(d.get(a1, a2, a3).toString(locale));
3706 }
3707 }
3708
3709 /**
3710 * Logs a SEVERE message.
3711 *
3712 * @param <T1>
3713 * The type of the first message argument.
3714 * @param <T2>
3715 * The type of the second message argument.
3716 * @param <T3>
3717 * The type of the third message argument.
3718 * @param <T4>
3719 * The type of the fourth message argument.
3720 * @param d
3721 * The message descriptor.
3722 * @param a1
3723 * The first message argument.
3724 * @param a2
3725 * The second message argument.
3726 * @param a3
3727 * The third message argument.
3728 * @param a4
3729 * The fourth message argument.
3730 * @see java.util.logging.Logger#severe(String)
3731 */
3732 public <T1, T2, T3, T4> void severe(final Arg4<T1, T2, T3, T4> d,
3733 final T1 a1, final T2 a2, final T3 a3, final T4 a4) {
3734 if (logger.isLoggable(Level.SEVERE)) {
3735 logger.severe(d.get(a1, a2, a3, a4).toString(locale));
3736 }
3737 }
3738
3739 /**
3740 * Logs a SEVERE message.
3741 *
3742 * @param <T1>
3743 * The type of the first message argument.
3744 * @param <T2>
3745 * The type of the second message argument.
3746 * @param <T3>
3747 * The type of the third message argument.
3748 * @param <T4>
3749 * The type of the fourth message argument.
3750 * @param <T5>
3751 * The type of the fifth message argument.
3752 * @param d
3753 * The message descriptor.
3754 * @param a1
3755 * The first message argument.
3756 * @param a2
3757 * The second message argument.
3758 * @param a3
3759 * The third message argument.
3760 * @param a4
3761 * The fourth message argument.
3762 * @param a5
3763 * The fifth message argument.
3764 * @see java.util.logging.Logger#severe(String)
3765 */
3766 public <T1, T2, T3, T4, T5> void severe(final Arg5<T1, T2, T3, T4, T5> d,
3767 final T1 a1, final T2 a2, final T3 a3, final T4 a4, final T5 a5) {
3768 if (logger.isLoggable(Level.SEVERE)) {
3769 logger.severe(d.get(a1, a2, a3, a4, a5).toString(locale));
3770 }
3771 }
3772
3773 /**
3774 * Logs a SEVERE message.
3775 *
3776 * @param <T1>
3777 * The type of the first message argument.
3778 * @param <T2>
3779 * The type of the second message argument.
3780 * @param <T3>
3781 * The type of the third message argument.
3782 * @param <T4>
3783 * The type of the fourth message argument.
3784 * @param <T5>
3785 * The type of the fifth message argument.
3786 * @param <T6>
3787 * The type of the sixth message argument.
3788 * @param d
3789 * The message descriptor.
3790 * @param a1
3791 * The first message argument.
3792 * @param a2
3793 * The second message argument.
3794 * @param a3
3795 * The third message argument.
3796 * @param a4
3797 * The fourth message argument.
3798 * @param a5
3799 * The fifth message argument.
3800 * @param a6
3801 * The sixth message argument.
3802 * @see java.util.logging.Logger#severe(String)
3803 */
3804 public <T1, T2, T3, T4, T5, T6> void severe(
3805 final Arg6<T1, T2, T3, T4, T5, T6> d, final T1 a1, final T2 a2,
3806 final T3 a3, final T4 a4, final T5 a5, final T6 a6) {
3807 if (logger.isLoggable(Level.SEVERE)) {
3808 logger.severe(d.get(a1, a2, a3, a4, a5, a6).toString(locale));
3809 }
3810 }
3811
3812 /**
3813 * Logs a SEVERE message.
3814 *
3815 * @param <T1>
3816 * The type of the first message argument.
3817 * @param <T2>
3818 * The type of the second message argument.
3819 * @param <T3>
3820 * The type of the third message argument.
3821 * @param <T4>
3822 * The type of the fourth message argument.
3823 * @param <T5>
3824 * The type of the fifth message argument.
3825 * @param <T6>
3826 * The type of the sixth message argument.
3827 * @param <T7>
3828 * The type of the seventh message argument.
3829 * @param d
3830 * The message descriptor.
3831 * @param a1
3832 * The first message argument.
3833 * @param a2
3834 * The second message argument.
3835 * @param a3
3836 * The third message argument.
3837 * @param a4
3838 * The fourth message argument.
3839 * @param a5
3840 * The fifth message argument.
3841 * @param a6
3842 * The sixth message argument.
3843 * @param a7
3844 * The seventh message argument.
3845 * @see java.util.logging.Logger#severe(String)
3846 */
3847 public <T1, T2, T3, T4, T5, T6, T7> void severe(
3848 final Arg7<T1, T2, T3, T4, T5, T6, T7> d, final T1 a1, final T2 a2,
3849 final T3 a3, final T4 a4, final T5 a5, final T6 a6, final T7 a7) {
3850 if (logger.isLoggable(Level.SEVERE)) {
3851 logger.severe(d.get(a1, a2, a3, a4, a5, a6, a7).toString(locale));
3852 }
3853 }
3854
3855 /**
3856 * Logs a SEVERE message.
3857 *
3858 * @param <T1>
3859 * The type of the first message argument.
3860 * @param <T2>
3861 * The type of the second message argument.
3862 * @param <T3>
3863 * The type of the third message argument.
3864 * @param <T4>
3865 * The type of the fourth message argument.
3866 * @param <T5>
3867 * The type of the fifth message argument.
3868 * @param <T6>
3869 * The type of the sixth message argument.
3870 * @param <T7>
3871 * The type of the seventh message argument.
3872 * @param <T8>
3873 * The type of the eighth message argument.
3874 * @param d
3875 * The message descriptor.
3876 * @param a1
3877 * The first message argument.
3878 * @param a2
3879 * The second message argument.
3880 * @param a3
3881 * The third message argument.
3882 * @param a4
3883 * The fourth message argument.
3884 * @param a5
3885 * The fifth message argument.
3886 * @param a6
3887 * The sixth message argument.
3888 * @param a7
3889 * The seventh message argument.
3890 * @param a8
3891 * The eighth message argument.
3892 * @see java.util.logging.Logger#severe(String)
3893 */
3894 public <T1, T2, T3, T4, T5, T6, T7, T8> void severe(
3895 final Arg8<T1, T2, T3, T4, T5, T6, T7, T8> d, final T1 a1,
3896 final T2 a2, final T3 a3, final T4 a4, final T5 a5, final T6 a6,
3897 final T7 a7, final T8 a8) {
3898 if (logger.isLoggable(Level.SEVERE)) {
3899 logger.severe(d.get(a1, a2, a3, a4, a5, a6, a7, a8)
3900 .toString(locale));
3901 }
3902 }
3903
3904 /**
3905 * Logs a SEVERE message.
3906 *
3907 * @param <T1>
3908 * The type of the first message argument.
3909 * @param <T2>
3910 * The type of the second message argument.
3911 * @param <T3>
3912 * The type of the third message argument.
3913 * @param <T4>
3914 * The type of the fourth message argument.
3915 * @param <T5>
3916 * The type of the fifth message argument.
3917 * @param <T6>
3918 * The type of the sixth message argument.
3919 * @param <T7>
3920 * The type of the seventh message argument.
3921 * @param <T8>
3922 * The type of the eighth message argument.
3923 * @param <T9>
3924 * The type of the ninth message argument.
3925 * @param d
3926 * The message descriptor.
3927 * @param a1
3928 * The first message argument.
3929 * @param a2
3930 * The second message argument.
3931 * @param a3
3932 * The third message argument.
3933 * @param a4
3934 * The fourth message argument.
3935 * @param a5
3936 * The fifth message argument.
3937 * @param a6
3938 * The sixth message argument.
3939 * @param a7
3940 * The seventh message argument.
3941 * @param a8
3942 * The eighth message argument.
3943 * @param a9
3944 * The ninth message argument.
3945 * @see java.util.logging.Logger#severe(String)
3946 */
3947 public <T1, T2, T3, T4, T5, T6, T7, T8, T9> void severe(
3948 final Arg9<T1, T2, T3, T4, T5, T6, T7, T8, T9> d, final T1 a1,
3949 final T2 a2, final T3 a3, final T4 a4, final T5 a5, final T6 a6,
3950 final T7 a7, final T8 a8, final T9 a9) {
3951 if (logger.isLoggable(Level.SEVERE)) {
3952 logger.severe(d.get(a1, a2, a3, a4, a5, a6, a7, a8, a9).toString(
3953 locale));
3954 }
3955 }
3956
3957 /**
3958 * Logs a SEVERE message.
3959 *
3960 * @param d
3961 * The message descriptor.
3962 * @param args
3963 * The message arguments.
3964 * @see java.util.logging.Logger#severe(String)
3965 */
3966 public void severe(final ArgN d, final Object... args) {
3967 if (logger.isLoggable(Level.SEVERE)) {
3968 logger.severe(d.get(args).toString(locale));
3969 }
3970 }
3971
3972 /**
3973 * Logs a SEVERE message.
3974 *
3975 * @param m
3976 * The pre-formatted message.
3977 * @see java.util.logging.Logger#severe(String)
3978 */
3979 public void severe(final LocalizableMessage m) {
3980 if (logger.isLoggable(Level.SEVERE)) {
3981 logger.severe(m.toString(locale));
3982 }
3983 }
3984
3985 /**
3986 * Logs a WARNING message.
3987 *
3988 * @param d
3989 * The message descriptor.
3990 * @see java.util.logging.Logger#warning(String)
3991 */
3992 public void warning(final Arg0 d) {
3993 if (logger.isLoggable(Level.WARNING)) {
3994 logger.warning(d.get().toString(locale));
3995 }
3996 }
3997
3998 /**
3999 * Logs a WARNING message.
4000 *
4001 * @param <T1>
4002 * The type of the first message argument.
4003 * @param d
4004 * The message descriptor.
4005 * @param a1
4006 * The first message argument.
4007 * @see java.util.logging.Logger#warning(String)
4008 */
4009 public <T1> void warning(final Arg1<T1> d, final T1 a1) {
4010 if (logger.isLoggable(Level.WARNING)) {
4011 logger.warning(d.get(a1).toString(locale));
4012 }
4013 }
4014
4015 /**
4016 * Logs a WARNING message.
4017 *
4018 * @param <T1>
4019 * The type of the first message argument.
4020 * @param <T2>
4021 * The type of the second message argument.
4022 * @param d
4023 * The message descriptor.
4024 * @param a1
4025 * The first message argument.
4026 * @param a2
4027 * The second message argument.
4028 * @see java.util.logging.Logger#warning(String)
4029 */
4030 public <T1, T2> void warning(final Arg2<T1, T2> d, final T1 a1, final T2 a2) {
4031 if (logger.isLoggable(Level.WARNING)) {
4032 logger.warning(d.get(a1, a2).toString(locale));
4033 }
4034 }
4035
4036 /**
4037 * Logs a WARNING message.
4038 *
4039 * @param <T1>
4040 * The type of the first message argument.
4041 * @param <T2>
4042 * The type of the second message argument.
4043 * @param <T3>
4044 * The type of the third message argument.
4045 * @param d
4046 * The message descriptor.
4047 * @param a1
4048 * The first message argument.
4049 * @param a2
4050 * The second message argument.
4051 * @param a3
4052 * The third message argument.
4053 * @see java.util.logging.Logger#warning(String)
4054 */
4055 public <T1, T2, T3> void warning(final Arg3<T1, T2, T3> d, final T1 a1,
4056 final T2 a2, final T3 a3) {
4057 if (logger.isLoggable(Level.WARNING)) {
4058 logger.warning(d.get(a1, a2, a3).toString(locale));
4059 }
4060 }
4061
4062 /**
4063 * Logs a WARNING message.
4064 *
4065 * @param <T1>
4066 * The type of the first message argument.
4067 * @param <T2>
4068 * The type of the second message argument.
4069 * @param <T3>
4070 * The type of the third message argument.
4071 * @param <T4>
4072 * The type of the fourth message argument.
4073 * @param d
4074 * The message descriptor.
4075 * @param a1
4076 * The first message argument.
4077 * @param a2
4078 * The second message argument.
4079 * @param a3
4080 * The third message argument.
4081 * @param a4
4082 * The fourth message argument.
4083 * @see java.util.logging.Logger#warning(String)
4084 */
4085 public <T1, T2, T3, T4> void warning(final Arg4<T1, T2, T3, T4> d,
4086 final T1 a1, final T2 a2, final T3 a3, final T4 a4) {
4087 if (logger.isLoggable(Level.WARNING)) {
4088 logger.warning(d.get(a1, a2, a3, a4).toString(locale));
4089 }
4090 }
4091
4092 /**
4093 * Logs a WARNING message.
4094 *
4095 * @param <T1>
4096 * The type of the first message argument.
4097 * @param <T2>
4098 * The type of the second message argument.
4099 * @param <T3>
4100 * The type of the third message argument.
4101 * @param <T4>
4102 * The type of the fourth message argument.
4103 * @param <T5>
4104 * The type of the fifth message argument.
4105 * @param d
4106 * The message descriptor.
4107 * @param a1
4108 * The first message argument.
4109 * @param a2
4110 * The second message argument.
4111 * @param a3
4112 * The third message argument.
4113 * @param a4
4114 * The fourth message argument.
4115 * @param a5
4116 * The fifth message argument.
4117 * @see java.util.logging.Logger#warning(String)
4118 */
4119 public <T1, T2, T3, T4, T5> void warning(final Arg5<T1, T2, T3, T4, T5> d,
4120 final T1 a1, final T2 a2, final T3 a3, final T4 a4, final T5 a5) {
4121 if (logger.isLoggable(Level.WARNING)) {
4122 logger.warning(d.get(a1, a2, a3, a4, a5).toString(locale));
4123 }
4124 }
4125
4126 /**
4127 * Logs a WARNING message.
4128 *
4129 * @param <T1>
4130 * The type of the first message argument.
4131 * @param <T2>
4132 * The type of the second message argument.
4133 * @param <T3>
4134 * The type of the third message argument.
4135 * @param <T4>
4136 * The type of the fourth message argument.
4137 * @param <T5>
4138 * The type of the fifth message argument.
4139 * @param <T6>
4140 * The type of the sixth message argument.
4141 * @param d
4142 * The message descriptor.
4143 * @param a1
4144 * The first message argument.
4145 * @param a2
4146 * The second message argument.
4147 * @param a3
4148 * The third message argument.
4149 * @param a4
4150 * The fourth message argument.
4151 * @param a5
4152 * The fifth message argument.
4153 * @param a6
4154 * The sixth message argument.
4155 * @see java.util.logging.Logger#warning(String)
4156 */
4157 public <T1, T2, T3, T4, T5, T6> void warning(
4158 final Arg6<T1, T2, T3, T4, T5, T6> d, final T1 a1, final T2 a2,
4159 final T3 a3, final T4 a4, final T5 a5, final T6 a6) {
4160 if (logger.isLoggable(Level.WARNING)) {
4161 logger.warning(d.get(a1, a2, a3, a4, a5, a6).toString(locale));
4162 }
4163 }
4164
4165 /**
4166 * Logs a WARNING message.
4167 *
4168 * @param <T1>
4169 * The type of the first message argument.
4170 * @param <T2>
4171 * The type of the second message argument.
4172 * @param <T3>
4173 * The type of the third message argument.
4174 * @param <T4>
4175 * The type of the fourth message argument.
4176 * @param <T5>
4177 * The type of the fifth message argument.
4178 * @param <T6>
4179 * The type of the sixth message argument.
4180 * @param <T7>
4181 * The type of the seventh message argument.
4182 * @param d
4183 * The message descriptor.
4184 * @param a1
4185 * The first message argument.
4186 * @param a2
4187 * The second message argument.
4188 * @param a3
4189 * The third message argument.
4190 * @param a4
4191 * The fourth message argument.
4192 * @param a5
4193 * The fifth message argument.
4194 * @param a6
4195 * The sixth message argument.
4196 * @param a7
4197 * The seventh message argument.
4198 * @see java.util.logging.Logger#warning(String)
4199 */
4200 public <T1, T2, T3, T4, T5, T6, T7> void warning(
4201 final Arg7<T1, T2, T3, T4, T5, T6, T7> d, final T1 a1, final T2 a2,
4202 final T3 a3, final T4 a4, final T5 a5, final T6 a6, final T7 a7) {
4203 if (logger.isLoggable(Level.WARNING)) {
4204 logger.warning(d.get(a1, a2, a3, a4, a5, a6, a7).toString(locale));
4205 }
4206 }
4207
4208 /**
4209 * Logs a WARNING message.
4210 *
4211 * @param <T1>
4212 * The type of the first message argument.
4213 * @param <T2>
4214 * The type of the second message argument.
4215 * @param <T3>
4216 * The type of the third message argument.
4217 * @param <T4>
4218 * The type of the fourth message argument.
4219 * @param <T5>
4220 * The type of the fifth message argument.
4221 * @param <T6>
4222 * The type of the sixth message argument.
4223 * @param <T7>
4224 * The type of the seventh message argument.
4225 * @param <T8>
4226 * The type of the eighth message argument.
4227 * @param d
4228 * The message descriptor.
4229 * @param a1
4230 * The first message argument.
4231 * @param a2
4232 * The second message argument.
4233 * @param a3
4234 * The third message argument.
4235 * @param a4
4236 * The fourth message argument.
4237 * @param a5
4238 * The fifth message argument.
4239 * @param a6
4240 * The sixth message argument.
4241 * @param a7
4242 * The seventh message argument.
4243 * @param a8
4244 * The eighth message argument.
4245 * @see java.util.logging.Logger#warning(String)
4246 */
4247 public <T1, T2, T3, T4, T5, T6, T7, T8> void warning(
4248 final Arg8<T1, T2, T3, T4, T5, T6, T7, T8> d, final T1 a1,
4249 final T2 a2, final T3 a3, final T4 a4, final T5 a5, final T6 a6,
4250 final T7 a7, final T8 a8) {
4251 if (logger.isLoggable(Level.WARNING)) {
4252 logger.warning(d.get(a1, a2, a3, a4, a5, a6, a7, a8).toString(
4253 locale));
4254 }
4255 }
4256
4257 /**
4258 * Logs a WARNING message.
4259 *
4260 * @param <T1>
4261 * The type of the first message argument.
4262 * @param <T2>
4263 * The type of the second message argument.
4264 * @param <T3>
4265 * The type of the third message argument.
4266 * @param <T4>
4267 * The type of the fourth message argument.
4268 * @param <T5>
4269 * The type of the fifth message argument.
4270 * @param <T6>
4271 * The type of the sixth message argument.
4272 * @param <T7>
4273 * The type of the seventh message argument.
4274 * @param <T8>
4275 * The type of the eighth message argument.
4276 * @param <T9>
4277 * The type of the ninth message argument.
4278 * @param d
4279 * The message descriptor.
4280 * @param a1
4281 * The first message argument.
4282 * @param a2
4283 * The second message argument.
4284 * @param a3
4285 * The third message argument.
4286 * @param a4
4287 * The fourth message argument.
4288 * @param a5
4289 * The fifth message argument.
4290 * @param a6
4291 * The sixth message argument.
4292 * @param a7
4293 * The seventh message argument.
4294 * @param a8
4295 * The eighth message argument.
4296 * @param a9
4297 * The ninth message argument.
4298 * @see java.util.logging.Logger#warning(String)
4299 */
4300 public <T1, T2, T3, T4, T5, T6, T7, T8, T9> void warning(
4301 final Arg9<T1, T2, T3, T4, T5, T6, T7, T8, T9> d, final T1 a1,
4302 final T2 a2, final T3 a3, final T4 a4, final T5 a5, final T6 a6,
4303 final T7 a7, final T8 a8, final T9 a9) {
4304 if (logger.isLoggable(Level.WARNING)) {
4305 logger.warning(d.get(a1, a2, a3, a4, a5, a6, a7, a8, a9).toString(
4306 locale));
4307 }
4308 }
4309
4310 /**
4311 * Logs a WARNING message.
4312 *
4313 * @param d
4314 * The message descriptor.
4315 * @param args
4316 * The message arguments.
4317 * @see java.util.logging.Logger#warning(String)
4318 */
4319 public void warning(final ArgN d, final Object... args) {
4320 if (logger.isLoggable(Level.WARNING)) {
4321 logger.warning(d.get(args).toString(locale));
4322 }
4323 }
4324
4325 /**
4326 * Logs a WARNING message.
4327 *
4328 * @param m
4329 * The pre-formatted message.
4330 * @see java.util.logging.Logger#warning(String)
4331 */
4332 public void warning(final LocalizableMessage m) {
4333 if (logger.isLoggable(Level.WARNING)) {
4334 logger.warning(m.toString(locale));
4335 }
4336 }
4337
4338 }