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-2014 ForgeRock AS
15 */
16
17 package org.forgerock.i18n.slf4j;
18
19 import java.util.Locale;
20
21 import org.forgerock.i18n.LocalizableMessage;
22 import org.forgerock.i18n.LocalizableMessageDescriptor.Arg0;
23 import org.forgerock.i18n.LocalizableMessageDescriptor.Arg1;
24 import org.forgerock.i18n.LocalizableMessageDescriptor.Arg2;
25 import org.forgerock.i18n.LocalizableMessageDescriptor.Arg3;
26 import org.forgerock.i18n.LocalizableMessageDescriptor.Arg4;
27 import org.forgerock.i18n.LocalizableMessageDescriptor.Arg5;
28 import org.forgerock.i18n.LocalizableMessageDescriptor.Arg6;
29 import org.forgerock.i18n.LocalizableMessageDescriptor.Arg7;
30 import org.forgerock.i18n.LocalizableMessageDescriptor.Arg8;
31 import org.forgerock.i18n.LocalizableMessageDescriptor.Arg9;
32 import org.forgerock.i18n.LocalizableMessageDescriptor.ArgN;
33 import org.slf4j.Logger;
34 import org.slf4j.LoggerFactory;
35 import org.slf4j.Marker;
36
37 /**
38 * A logger implementation which formats and localizes messages before
39 * forwarding them to an underlying SLF4J {@link Logger}. For performance
40 * reasons this implementation will only localize and format messages if logging
41 * has been enabled for the associated log level and marker (if present).
42 * <p>
43 * If no marker is provided, a {@code LocalizedMarker} is automatically constructed
44 * with the corresponding {@code LocalizedMessage} to be logged and passed to the
45 * underlying SLF4J {@link Logger}. This allow a custom implementation of SLF4J
46 * logger adapter to retrieve the complete localizable message when logging.
47 */
48 public final class LocalizedLogger {
49
50 private static final String LOCALIZED_LOGGER_CLASSNAME = LocalizedLogger.class.getName();
51
52 private static final String THREAD_CLASS_NAME = Thread.class.getName();
53
54 /**
55 * Returns a localized logger which will forward log messages to an SLF4J
56 * {@code Logger} obtained by calling {@link LoggerFactory#getLogger(Class)}
57 * . The messages will be localized using the default locale.
58 *
59 * @param clazz
60 * The name of the wrapped SLF4J {@code Logger}.
61 * @return The localized logger.
62 * @see LoggerFactory#getLogger(Class)
63 */
64 public static LocalizedLogger getLocalizedLogger(final Class<?> clazz) {
65 final Logger logger = LoggerFactory.getLogger(clazz);
66 return new LocalizedLogger(logger, Locale.getDefault());
67 }
68
69 /**
70 * Returns a localized logger which will forward log messages to the
71 * provided SLF4J {@code Logger}. The messages will be localized using the
72 * default locale.
73 *
74 * @param logger
75 * The wrapped SLF4J {@code Logger}.
76 * @return The localized logger.
77 * @see LoggerFactory#getLogger(String)
78 */
79 public static LocalizedLogger getLocalizedLogger(final Logger logger) {
80 return new LocalizedLogger(logger, Locale.getDefault());
81 }
82
83 /**
84 * Returns a localized logger which will forward log messages to an SLF4J
85 * {@code Logger} obtained by calling
86 * {@link LoggerFactory#getLogger(String)}. The messages will be localized
87 * using the default locale.
88 *
89 * @param name
90 * The name of the wrapped SLF4J {@code Logger}.
91 * @return The localized logger.
92 * @see LoggerFactory#getLogger(String)
93 */
94 public static LocalizedLogger getLocalizedLogger(final String name) {
95 final Logger logger = LoggerFactory.getLogger(name);
96 return new LocalizedLogger(logger, Locale.getDefault());
97 }
98
99 /**
100 * Returns a localized logger with a name corresponding to calling class
101 * name. The logger will forward log messages to an SLF4J {@code Logger}
102 * obtained by calling {@link LoggerFactory#getLogger(String)}. The messages
103 * will be localized using the default locale.
104 *
105 * @return The localized logger using calling class name as its name
106 * @see LoggerFactory#getLogger(String)
107 */
108 public static LocalizedLogger getLoggerForThisClass() {
109 String name = getClassNameOfCaller();
110 if (name == null) {
111 name = Logger.ROOT_LOGGER_NAME;
112 }
113 return getLocalizedLogger(name);
114 }
115
116 /**
117 * Return the name of class that asked for a Logger.
118 *
119 * @return the class name, or {@code null} if it can't be found
120 */
121 static String getClassNameOfCaller() {
122 final StackTraceElement[] stackTrace = Thread.currentThread().getStackTrace();
123 if (stackTrace != null && stackTrace.length > 0) {
124 // Skip leading frames debug logging classes
125 // and getStackTrace method call frame if any.
126 for (StackTraceElement aStackTrace : stackTrace) {
127 final String name = aStackTrace.getClassName();
128 if (!name.equals(THREAD_CLASS_NAME)
129 && !name.equals(LOCALIZED_LOGGER_CLASSNAME)) {
130 return aStackTrace.getClassName();
131 }
132 }
133 }
134 return null;
135 }
136
137 private final Locale locale;
138
139 private final Logger logger;
140
141 /**
142 * Creates a new localized logger which will log localizable messages to the
143 * provided SLF4J {@code Logger} in the specified locale.
144 *
145 * @param logger
146 * The underlying SLF4J {@code Logger} wrapped by this logger.
147 * @param locale
148 * The locale to which this logger will localize all log
149 * messages.
150 */
151 LocalizedLogger(final Logger logger, final Locale locale) {
152 this.locale = locale;
153 this.logger = logger;
154 }
155
156 /**
157 * Logs a debug message.
158 *
159 * @param d
160 * The message descriptor.
161 * @see org.slf4j.Logger#debug(String)
162 */
163 public void debug(final Arg0 d) {
164 if (logger.isDebugEnabled()) {
165 final LocalizableMessage message = d.get();
166 logger.debug(new LocalizedMarker(message), message.toString(locale));
167 }
168 }
169
170 /**
171 * Logs a debug message with an accompanying exception.
172 *
173 * @param d
174 * The message descriptor.
175 * @param t
176 * The throwable to log.
177 * @see org.slf4j.Logger#debug(String, Throwable)
178 */
179 public void debug(final Arg0 d, final Throwable t) {
180 if (logger.isDebugEnabled()) {
181 final LocalizableMessage message = d.get();
182 logger.debug(new LocalizedMarker(message), message.toString(locale), t);
183 }
184 }
185
186 /**
187 * Logs a debug message.
188 *
189 * @param <T1>
190 * The type of the first message argument.
191 * @param d
192 * The message descriptor.
193 * @param a1
194 * The first message argument.
195 * @see org.slf4j.Logger#debug(String)
196 */
197 public <T1> void debug(final Arg1<T1> d, final T1 a1) {
198 if (logger.isDebugEnabled()) {
199 final LocalizableMessage message = d.get(a1);
200 logger.debug(new LocalizedMarker(message), message.toString(locale));
201 }
202 }
203
204 /**
205 * Logs a debug message with an accompanying exception.
206 *
207 * @param <T1>
208 * The type of the first message argument.
209 * @param d
210 * The message descriptor.
211 * @param a1
212 * The first message argument.
213 * @param t
214 * The throwable to log.
215 * @see org.slf4j.Logger#debug(String, Throwable)
216 */
217 public <T1> void debug(final Arg1<T1> d, final T1 a1, final Throwable t) {
218 if (logger.isDebugEnabled()) {
219 final LocalizableMessage message = d.get(a1);
220 logger.debug(new LocalizedMarker(message), message.toString(locale), t);
221 }
222 }
223
224 /**
225 * Logs a debug message.
226 *
227 * @param <T1>
228 * The type of the first message argument.
229 * @param <T2>
230 * The type of the second message argument.
231 * @param d
232 * The message descriptor.
233 * @param a1
234 * The first message argument.
235 * @param a2
236 * The second message argument.
237 * @see org.slf4j.Logger#debug(String)
238 */
239 public <T1, T2> void debug(final Arg2<T1, T2> d, final T1 a1, final T2 a2) {
240 if (logger.isDebugEnabled()) {
241 final LocalizableMessage message = d.get(a1, a2);
242 logger.debug(new LocalizedMarker(message), message.toString(locale));
243 }
244 }
245
246 /**
247 * Logs a debug message with an accompanying exception.
248 *
249 * @param <T1>
250 * The type of the first message argument.
251 * @param <T2>
252 * The type of the second message argument.
253 * @param d
254 * The message descriptor.
255 * @param a1
256 * The first message argument.
257 * @param a2
258 * The second message argument.
259 * @param t
260 * The throwable to log.
261 * @see org.slf4j.Logger#debug(String, Throwable)
262 */
263 public <T1, T2> void debug(final Arg2<T1, T2> d, final T1 a1, final T2 a2, final Throwable t) {
264 if (logger.isDebugEnabled()) {
265 final LocalizableMessage message = d.get(a1, a2);
266 logger.debug(new LocalizedMarker(message), message.toString(locale), t);
267 }
268 }
269
270 /**
271 * Logs a debug message.
272 *
273 * @param <T1>
274 * The type of the first message argument.
275 * @param <T2>
276 * The type of the second message argument.
277 * @param <T3>
278 * The type of the third message argument.
279 * @param d
280 * The message descriptor.
281 * @param a1
282 * The first message argument.
283 * @param a2
284 * The second message argument.
285 * @param a3
286 * The third message argument.
287 * @see org.slf4j.Logger#debug(String)
288 */
289 public <T1, T2, T3> void debug(final Arg3<T1, T2, T3> d, final T1 a1, final T2 a2, final T3 a3) {
290 if (logger.isDebugEnabled()) {
291 final LocalizableMessage message = d.get(a1, a2, a3);
292 logger.debug(new LocalizedMarker(message), message.toString(locale));
293 }
294 }
295
296 /**
297 * Logs a debug message with an accompanying exception.
298 *
299 * @param <T1>
300 * The type of the first message argument.
301 * @param <T2>
302 * The type of the second message argument.
303 * @param <T3>
304 * The type of the third message argument.
305 * @param d
306 * The message descriptor.
307 * @param a1
308 * The first message argument.
309 * @param a2
310 * The second message argument.
311 * @param a3
312 * The third message argument.
313 * @param t
314 * The throwable to log.
315 * @see org.slf4j.Logger#debug(String, Throwable)
316 */
317 public <T1, T2, T3> void debug(final Arg3<T1, T2, T3> d, final T1 a1, final T2 a2, final T3 a3,
318 final Throwable t) {
319 if (logger.isDebugEnabled()) {
320 final LocalizableMessage message = d.get(a1, a2, a3);
321 logger.debug(new LocalizedMarker(message), message.toString(locale), t);
322 }
323 }
324
325 /**
326 * Logs a debug message.
327 *
328 * @param <T1>
329 * The type of the first message argument.
330 * @param <T2>
331 * The type of the second message argument.
332 * @param <T3>
333 * The type of the third message argument.
334 * @param <T4>
335 * The type of the fourth message argument.
336 * @param d
337 * The message descriptor.
338 * @param a1
339 * The first message argument.
340 * @param a2
341 * The second message argument.
342 * @param a3
343 * The third message argument.
344 * @param a4
345 * The fourth message argument.
346 * @see org.slf4j.Logger#debug(String)
347 */
348 public <T1, T2, T3, T4> void debug(final Arg4<T1, T2, T3, T4> d, final T1 a1, final T2 a2,
349 final T3 a3, final T4 a4) {
350 if (logger.isDebugEnabled()) {
351 final LocalizableMessage message = d.get(a1, a2, a3, a4);
352 logger.debug(new LocalizedMarker(message), message.toString(locale));
353 }
354 }
355
356 /**
357 * Logs a debug message with an accompanying exception.
358 *
359 * @param <T1>
360 * The type of the first message argument.
361 * @param <T2>
362 * The type of the second message argument.
363 * @param <T3>
364 * The type of the third message argument.
365 * @param <T4>
366 * The type of the fourth message argument.
367 * @param d
368 * The message descriptor.
369 * @param a1
370 * The first message argument.
371 * @param a2
372 * The second message argument.
373 * @param a3
374 * The third message argument.
375 * @param a4
376 * The fourth message argument.
377 * @param t
378 * The throwable to log.
379 * @see org.slf4j.Logger#debug(String, Throwable)
380 */
381 public <T1, T2, T3, T4> void debug(final Arg4<T1, T2, T3, T4> d, final T1 a1, final T2 a2,
382 final T3 a3, final T4 a4, final Throwable t) {
383 if (logger.isDebugEnabled()) {
384 final LocalizableMessage message = d.get(a1, a2, a3, a4);
385 logger.debug(new LocalizedMarker(message), message.toString(locale), t);
386 }
387 }
388
389 /**
390 * Logs a debug message.
391 *
392 * @param <T1>
393 * The type of the first message argument.
394 * @param <T2>
395 * The type of the second message argument.
396 * @param <T3>
397 * The type of the third message argument.
398 * @param <T4>
399 * The type of the fourth message argument.
400 * @param <T5>
401 * The type of the fifth message argument.
402 * @param d
403 * The message descriptor.
404 * @param a1
405 * The first message argument.
406 * @param a2
407 * The second message argument.
408 * @param a3
409 * The third message argument.
410 * @param a4
411 * The fourth message argument.
412 * @param a5
413 * The fifth message argument.
414 * @see org.slf4j.Logger#debug(String)
415 */
416 public <T1, T2, T3, T4, T5> void debug(final Arg5<T1, T2, T3, T4, T5> d, final T1 a1,
417 final T2 a2, final T3 a3, final T4 a4, final T5 a5) {
418 if (logger.isDebugEnabled()) {
419 final LocalizableMessage message = d.get(a1, a2, a3, a4, a5);
420 logger.debug(new LocalizedMarker(message), message.toString(locale));
421 }
422 }
423
424 /**
425 * Logs a debug message with an accompanying exception.
426 *
427 * @param <T1>
428 * The type of the first message argument.
429 * @param <T2>
430 * The type of the second message argument.
431 * @param <T3>
432 * The type of the third message argument.
433 * @param <T4>
434 * The type of the fourth message argument.
435 * @param <T5>
436 * The type of the fifth message argument.
437 * @param d
438 * The message descriptor.
439 * @param a1
440 * The first message argument.
441 * @param a2
442 * The second message argument.
443 * @param a3
444 * The third message argument.
445 * @param a4
446 * The fourth message argument.
447 * @param a5
448 * The fifth message argument.
449 * @param t
450 * The throwable to log.
451 * @see org.slf4j.Logger#debug(String, Throwable)
452 */
453 public <T1, T2, T3, T4, T5> void debug(final Arg5<T1, T2, T3, T4, T5> d, final T1 a1,
454 final T2 a2, final T3 a3, final T4 a4, final T5 a5, final Throwable t) {
455 if (logger.isDebugEnabled()) {
456 final LocalizableMessage message = d.get(a1, a2, a3, a4, a5);
457 logger.debug(new LocalizedMarker(message), message.toString(locale), t);
458 }
459 }
460
461 /**
462 * Logs a debug message.
463 *
464 * @param <T1>
465 * The type of the first message argument.
466 * @param <T2>
467 * The type of the second message argument.
468 * @param <T3>
469 * The type of the third message argument.
470 * @param <T4>
471 * The type of the fourth message argument.
472 * @param <T5>
473 * The type of the fifth message argument.
474 * @param <T6>
475 * The type of the sixth message argument.
476 * @param d
477 * The message descriptor.
478 * @param a1
479 * The first message argument.
480 * @param a2
481 * The second message argument.
482 * @param a3
483 * The third message argument.
484 * @param a4
485 * The fourth message argument.
486 * @param a5
487 * The fifth message argument.
488 * @param a6
489 * The sixth message argument.
490 * @see org.slf4j.Logger#debug(String)
491 */
492 public <T1, T2, T3, T4, T5, T6> void debug(final Arg6<T1, T2, T3, T4, T5, T6> d, final T1 a1,
493 final T2 a2, final T3 a3, final T4 a4, final T5 a5, final T6 a6) {
494 if (logger.isDebugEnabled()) {
495 final LocalizableMessage message = d.get(a1, a2, a3, a4, a5, a6);
496 logger.debug(new LocalizedMarker(message), message.toString(locale));
497 }
498 }
499
500 /**
501 * Logs a debug message with an accompanying exception.
502 *
503 * @param <T1>
504 * The type of the first message argument.
505 * @param <T2>
506 * The type of the second message argument.
507 * @param <T3>
508 * The type of the third message argument.
509 * @param <T4>
510 * The type of the fourth message argument.
511 * @param <T5>
512 * The type of the fifth message argument.
513 * @param <T6>
514 * The type of the sixth message argument.
515 * @param d
516 * The message descriptor.
517 * @param a1
518 * The first message argument.
519 * @param a2
520 * The second message argument.
521 * @param a3
522 * The third message argument.
523 * @param a4
524 * The fourth message argument.
525 * @param a5
526 * The fifth message argument.
527 * @param a6
528 * The sixth message argument.
529 * @param t
530 * The throwable to log.
531 * @see org.slf4j.Logger#debug(String, Throwable)
532 */
533 public <T1, T2, T3, T4, T5, T6> void debug(final Arg6<T1, T2, T3, T4, T5, T6> d, final T1 a1,
534 final T2 a2, final T3 a3, final T4 a4, final T5 a5, final T6 a6, final Throwable t) {
535 if (logger.isDebugEnabled()) {
536 final LocalizableMessage message = d.get(a1, a2, a3, a4, a5, a6);
537 logger.debug(new LocalizedMarker(message), message.toString(locale), t);
538 }
539 }
540
541 /**
542 * Logs a debug message.
543 *
544 * @param <T1>
545 * The type of the first message argument.
546 * @param <T2>
547 * The type of the second message argument.
548 * @param <T3>
549 * The type of the third message argument.
550 * @param <T4>
551 * The type of the fourth message argument.
552 * @param <T5>
553 * The type of the fifth message argument.
554 * @param <T6>
555 * The type of the sixth message argument.
556 * @param <T7>
557 * The type of the seventh message argument.
558 * @param d
559 * The message descriptor.
560 * @param a1
561 * The first message argument.
562 * @param a2
563 * The second message argument.
564 * @param a3
565 * The third message argument.
566 * @param a4
567 * The fourth message argument.
568 * @param a5
569 * The fifth message argument.
570 * @param a6
571 * The sixth message argument.
572 * @param a7
573 * The seventh message argument.
574 * @see org.slf4j.Logger#debug(String)
575 */
576 public <T1, T2, T3, T4, T5, T6, T7> void debug(final Arg7<T1, T2, T3, T4, T5, T6, T7> d,
577 final T1 a1, final T2 a2, final T3 a3, final T4 a4, final T5 a5, final T6 a6,
578 final T7 a7) {
579 if (logger.isDebugEnabled()) {
580 final LocalizableMessage message = d.get(a1, a2, a3, a4, a5, a6, a7);
581 logger.debug(new LocalizedMarker(message), message.toString(locale));
582 }
583 }
584
585 /**
586 * Logs a debug message with an accompanying exception.
587 *
588 * @param <T1>
589 * The type of the first message argument.
590 * @param <T2>
591 * The type of the second message argument.
592 * @param <T3>
593 * The type of the third message argument.
594 * @param <T4>
595 * The type of the fourth message argument.
596 * @param <T5>
597 * The type of the fifth message argument.
598 * @param <T6>
599 * The type of the sixth message argument.
600 * @param <T7>
601 * The type of the seventh message argument.
602 * @param d
603 * The message descriptor.
604 * @param a1
605 * The first message argument.
606 * @param a2
607 * The second message argument.
608 * @param a3
609 * The third message argument.
610 * @param a4
611 * The fourth message argument.
612 * @param a5
613 * The fifth message argument.
614 * @param a6
615 * The sixth message argument.
616 * @param a7
617 * The seventh message argument.
618 * @param t
619 * The throwable to log.
620 * @see org.slf4j.Logger#debug(String, Throwable)
621 */
622 public <T1, T2, T3, T4, T5, T6, T7> void debug(final Arg7<T1, T2, T3, T4, T5, T6, T7> d,
623 final T1 a1, final T2 a2, final T3 a3, final T4 a4, final T5 a5, final T6 a6,
624 final T7 a7, final Throwable t) {
625 if (logger.isDebugEnabled()) {
626 final LocalizableMessage message = d.get(a1, a2, a3, a4, a5, a6, a7);
627 logger.debug(new LocalizedMarker(message), message.toString(locale), t);
628 }
629 }
630
631 /**
632 * Logs a debug message.
633 *
634 * @param <T1>
635 * The type of the first message argument.
636 * @param <T2>
637 * The type of the second message argument.
638 * @param <T3>
639 * The type of the third message argument.
640 * @param <T4>
641 * The type of the fourth message argument.
642 * @param <T5>
643 * The type of the fifth message argument.
644 * @param <T6>
645 * The type of the sixth message argument.
646 * @param <T7>
647 * The type of the seventh message argument.
648 * @param <T8>
649 * The type of the eighth message argument.
650 * @param d
651 * The message descriptor.
652 * @param a1
653 * The first message argument.
654 * @param a2
655 * The second message argument.
656 * @param a3
657 * The third message argument.
658 * @param a4
659 * The fourth message argument.
660 * @param a5
661 * The fifth message argument.
662 * @param a6
663 * The sixth message argument.
664 * @param a7
665 * The seventh message argument.
666 * @param a8
667 * The eighth message argument.
668 * @see org.slf4j.Logger#debug(String)
669 */
670 public <T1, T2, T3, T4, T5, T6, T7, T8> void debug(
671 final Arg8<T1, T2, T3, T4, T5, T6, T7, T8> d, final T1 a1, final T2 a2, final T3 a3,
672 final T4 a4, final T5 a5, final T6 a6, final T7 a7, final T8 a8) {
673 if (logger.isDebugEnabled()) {
674 final LocalizableMessage message = d.get(a1, a2, a3, a4, a5, a6, a7, a8);
675 logger.debug(new LocalizedMarker(message), message.toString(locale));
676 }
677 }
678
679 /**
680 * Logs a debug message with an accompanying exception.
681 *
682 * @param <T1>
683 * The type of the first message argument.
684 * @param <T2>
685 * The type of the second message argument.
686 * @param <T3>
687 * The type of the third message argument.
688 * @param <T4>
689 * The type of the fourth message argument.
690 * @param <T5>
691 * The type of the fifth message argument.
692 * @param <T6>
693 * The type of the sixth message argument.
694 * @param <T7>
695 * The type of the seventh message argument.
696 * @param <T8>
697 * The type of the eighth message argument.
698 * @param d
699 * The message descriptor.
700 * @param a1
701 * The first message argument.
702 * @param a2
703 * The second message argument.
704 * @param a3
705 * The third message argument.
706 * @param a4
707 * The fourth message argument.
708 * @param a5
709 * The fifth message argument.
710 * @param a6
711 * The sixth message argument.
712 * @param a7
713 * The seventh message argument.
714 * @param a8
715 * The eighth message argument.
716 * @param t
717 * The throwable to log.
718 * @see org.slf4j.Logger#debug(String, Throwable)
719 */
720 public <T1, T2, T3, T4, T5, T6, T7, T8> void debug(
721 final Arg8<T1, T2, T3, T4, T5, T6, T7, T8> d, final T1 a1, final T2 a2, final T3 a3,
722 final T4 a4, final T5 a5, final T6 a6, final T7 a7, final T8 a8, final Throwable t) {
723 if (logger.isDebugEnabled()) {
724 final LocalizableMessage message = d.get(a1, a2, a3, a4, a5, a6, a7, a8);
725 logger.debug(new LocalizedMarker(message), message.toString(locale), t);
726 }
727 }
728
729 /**
730 * Logs a debug message.
731 *
732 * @param <T1>
733 * The type of the first message argument.
734 * @param <T2>
735 * The type of the second message argument.
736 * @param <T3>
737 * The type of the third message argument.
738 * @param <T4>
739 * The type of the fourth message argument.
740 * @param <T5>
741 * The type of the fifth message argument.
742 * @param <T6>
743 * The type of the sixth message argument.
744 * @param <T7>
745 * The type of the seventh message argument.
746 * @param <T8>
747 * The type of the eighth message argument.
748 * @param <T9>
749 * The type of the ninth message argument.
750 * @param d
751 * The message descriptor.
752 * @param a1
753 * The first message argument.
754 * @param a2
755 * The second message argument.
756 * @param a3
757 * The third message argument.
758 * @param a4
759 * The fourth message argument.
760 * @param a5
761 * The fifth message argument.
762 * @param a6
763 * The sixth message argument.
764 * @param a7
765 * The seventh message argument.
766 * @param a8
767 * The eighth message argument.
768 * @param a9
769 * The ninth message argument.
770 * @see org.slf4j.Logger#debug(String)
771 */
772 public <T1, T2, T3, T4, T5, T6, T7, T8, T9> void debug(
773 final Arg9<T1, T2, T3, T4, T5, T6, T7, T8, T9> d, final T1 a1, final T2 a2,
774 final T3 a3, final T4 a4, final T5 a5, final T6 a6, final T7 a7, final T8 a8,
775 final T9 a9) {
776 if (logger.isDebugEnabled()) {
777 final LocalizableMessage message = d.get(a1, a2, a3, a4, a5, a6, a7, a8, a9);
778 logger.debug(new LocalizedMarker(message), message.toString(locale));
779 }
780 }
781
782 /**
783 * Logs a debug message with an accompanying exception.
784 *
785 * @param <T1>
786 * The type of the first message argument.
787 * @param <T2>
788 * The type of the second message argument.
789 * @param <T3>
790 * The type of the third message argument.
791 * @param <T4>
792 * The type of the fourth message argument.
793 * @param <T5>
794 * The type of the fifth message argument.
795 * @param <T6>
796 * The type of the sixth message argument.
797 * @param <T7>
798 * The type of the seventh message argument.
799 * @param <T8>
800 * The type of the eighth message argument.
801 * @param <T9>
802 * The type of the ninth message argument.
803 * @param d
804 * The message descriptor.
805 * @param a1
806 * The first message argument.
807 * @param a2
808 * The second message argument.
809 * @param a3
810 * The third message argument.
811 * @param a4
812 * The fourth message argument.
813 * @param a5
814 * The fifth message argument.
815 * @param a6
816 * The sixth message argument.
817 * @param a7
818 * The seventh message argument.
819 * @param a8
820 * The eighth message argument.
821 * @param a9
822 * The ninth message argument.
823 * @param t
824 * The throwable to log.
825 * @see org.slf4j.Logger#debug(String, Throwable)
826 */
827 public <T1, T2, T3, T4, T5, T6, T7, T8, T9> void debug(
828 final Arg9<T1, T2, T3, T4, T5, T6, T7, T8, T9> d, final T1 a1, final T2 a2,
829 final T3 a3, final T4 a4, final T5 a5, final T6 a6, final T7 a7, final T8 a8,
830 final T9 a9, final Throwable t) {
831 if (logger.isDebugEnabled()) {
832 final LocalizableMessage message = d.get(a1, a2, a3, a4, a5, a6, a7, a8, a9);
833 logger.debug(new LocalizedMarker(message), message.toString(locale), t);
834 }
835 }
836
837 /**
838 * Logs a debug message.
839 *
840 * @param d
841 * The message descriptor.
842 * @param args
843 * The message arguments.
844 * @see org.slf4j.Logger#debug(String)
845 */
846 public void debug(final ArgN d, final Object... args) {
847 if (logger.isDebugEnabled()) {
848 final LocalizableMessage message = d.get(args);
849 logger.debug(new LocalizedMarker(message), message.toString(locale));
850 }
851 }
852
853 /**
854 * Logs a debug message with an accompanying exception.
855 *
856 * @param d
857 * The message descriptor.
858 * @param t
859 * The throwable to log.
860 * @param args
861 * The message arguments.
862 * @see org.slf4j.Logger#debug(String, Throwable)
863 */
864 public void debug(final ArgN d, final Throwable t, final Object... args) {
865 if (logger.isDebugEnabled()) {
866 final LocalizableMessage message = d.get(args);
867 logger.debug(new LocalizedMarker(message), message.toString(locale), t);
868 }
869 }
870
871 /**
872 * Logs a debug message.
873 *
874 * @param m
875 * The pre-formatted message.
876 * @see org.slf4j.Logger#debug(String)
877 */
878 public void debug(final LocalizableMessage m) {
879 if (logger.isDebugEnabled()) {
880 logger.debug(new LocalizedMarker(m), m.toString(locale));
881 }
882 }
883
884 /**
885 * Logs a debug message with an accompanying exception.
886 *
887 * @param m
888 * The pre-formatted message.
889 * @param t
890 * The throwable to log.
891 * @see org.slf4j.Logger#debug(String, Throwable)
892 */
893 public void debug(final LocalizableMessage m, final Throwable t) {
894 if (logger.isDebugEnabled()) {
895 logger.debug(new LocalizedMarker(m), m.toString(locale), t);
896 }
897 }
898
899 /**
900 * Logs a debug message using the provided {@code Marker}.
901 *
902 * @param m
903 * The marker information associated with this log message.
904 * @param d
905 * The message descriptor.
906 * @see org.slf4j.Logger#debug(org.slf4j.Marker, String)
907 */
908 public void debug(final Marker m, final Arg0 d) {
909 if (logger.isDebugEnabled(m)) {
910 logger.debug(m, d.get().toString(locale));
911 }
912 }
913
914 /**
915 * Logs a debug message using the provided {@code Marker}.
916 *
917 * @param m
918 * The marker information associated with this log message.
919 * @param d
920 * The message descriptor.
921 * @param t
922 * The throwable to log.
923 * @see org.slf4j.Logger#debug(org.slf4j.Marker, String)
924 */
925 public void debug(final Marker m, final Arg0 d, final Throwable t) {
926 if (logger.isDebugEnabled(m)) {
927 logger.debug(m, d.get().toString(locale), t);
928 }
929 }
930
931 /**
932 * Logs a debug message.
933 *
934 * @param <T1>
935 * The type of the first message argument.
936 * @param m
937 * The marker information associated with this log message.
938 * @param d
939 * The message descriptor.
940 * @param a1
941 * The first message argument.
942 * @see org.slf4j.Logger#debug(String)
943 */
944 public <T1> void debug(final Marker m, final Arg1<T1> d, final T1 a1) {
945 if (logger.isDebugEnabled(m)) {
946 logger.debug(m, d.get(a1).toString(locale));
947 }
948 }
949
950 /**
951 * Logs a debug message with an accompanying exception.
952 *
953 * @param <T1>
954 * The type of the first message argument.
955 * @param m
956 * The marker information associated with this log message.
957 * @param d
958 * The message descriptor.
959 * @param a1
960 * The first message argument.
961 * @param t
962 * The throwable to log.
963 * @see org.slf4j.Logger#debug(String, Throwable)
964 */
965 public <T1> void debug(final Marker m, final Arg1<T1> d, final T1 a1, final Throwable t) {
966 if (logger.isDebugEnabled(m)) {
967 logger.debug(m, d.get(a1).toString(locale), t);
968 }
969 }
970
971 /**
972 * Logs a debug message.
973 *
974 * @param <T1>
975 * The type of the first message argument.
976 * @param <T2>
977 * The type of the second message argument.
978 * @param m
979 * The marker information associated with this log message.
980 * @param d
981 * The message descriptor.
982 * @param a1
983 * The first message argument.
984 * @param a2
985 * The second message argument.
986 * @see org.slf4j.Logger#debug(String)
987 */
988 public <T1, T2> void debug(final Marker m, final Arg2<T1, T2> d, final T1 a1, final T2 a2) {
989 if (logger.isDebugEnabled(m)) {
990 logger.debug(m, d.get(a1, a2).toString(locale));
991 }
992 }
993
994 /**
995 * Logs a debug message with an accompanying exception.
996 *
997 * @param <T1>
998 * The type of the first message argument.
999 * @param <T2>
1000 * The type of the second message argument.
1001 * @param m
1002 * The marker information associated with this log message.
1003 * @param d
1004 * The message descriptor.
1005 * @param a1
1006 * The first message argument.
1007 * @param a2
1008 * The second message argument.
1009 * @param t
1010 * The throwable to log.
1011 * @see org.slf4j.Logger#debug(String, Throwable)
1012 */
1013 public <T1, T2> void debug(final Marker m, final Arg2<T1, T2> d, final T1 a1, final T2 a2,
1014 final Throwable t) {
1015 if (logger.isDebugEnabled(m)) {
1016 logger.debug(m, d.get(a1, a2).toString(locale), t);
1017 }
1018 }
1019
1020 /**
1021 * Logs a debug message.
1022 *
1023 * @param <T1>
1024 * The type of the first message argument.
1025 * @param <T2>
1026 * The type of the second message argument.
1027 * @param <T3>
1028 * The type of the third message argument.
1029 * @param m
1030 * The marker information associated with this log message.
1031 * @param d
1032 * The message descriptor.
1033 * @param a1
1034 * The first message argument.
1035 * @param a2
1036 * The second message argument.
1037 * @param a3
1038 * The third message argument.
1039 * @see org.slf4j.Logger#debug(String)
1040 */
1041 public <T1, T2, T3> void debug(final Marker m, final Arg3<T1, T2, T3> d, final T1 a1,
1042 final T2 a2, final T3 a3) {
1043 if (logger.isDebugEnabled(m)) {
1044 logger.debug(m, d.get(a1, a2, a3).toString(locale));
1045 }
1046 }
1047
1048 /**
1049 * Logs a debug message with an accompanying exception.
1050 *
1051 * @param <T1>
1052 * The type of the first message argument.
1053 * @param <T2>
1054 * The type of the second message argument.
1055 * @param <T3>
1056 * The type of the third message argument.
1057 * @param m
1058 * The marker information associated with this log message.
1059 * @param d
1060 * The message descriptor.
1061 * @param a1
1062 * The first message argument.
1063 * @param a2
1064 * The second message argument.
1065 * @param a3
1066 * The third message argument.
1067 * @param t
1068 * The throwable to log.
1069 * @see org.slf4j.Logger#debug(String, Throwable)
1070 */
1071 public <T1, T2, T3> void debug(final Marker m, final Arg3<T1, T2, T3> d, final T1 a1,
1072 final T2 a2, final T3 a3, final Throwable t) {
1073 if (logger.isDebugEnabled(m)) {
1074 logger.debug(m, d.get(a1, a2, a3).toString(locale), t);
1075 }
1076 }
1077
1078 /**
1079 * Logs a debug message.
1080 *
1081 * @param <T1>
1082 * The type of the first message argument.
1083 * @param <T2>
1084 * The type of the second message argument.
1085 * @param <T3>
1086 * The type of the third message argument.
1087 * @param <T4>
1088 * The type of the fourth message argument.
1089 * @param m
1090 * The marker information associated with this log message.
1091 * @param d
1092 * The message descriptor.
1093 * @param a1
1094 * The first message argument.
1095 * @param a2
1096 * The second message argument.
1097 * @param a3
1098 * The third message argument.
1099 * @param a4
1100 * The fourth message argument.
1101 * @see org.slf4j.Logger#debug(String)
1102 */
1103 public <T1, T2, T3, T4> void debug(final Marker m, final Arg4<T1, T2, T3, T4> d, final T1 a1,
1104 final T2 a2, final T3 a3, final T4 a4) {
1105 if (logger.isDebugEnabled(m)) {
1106 logger.debug(m, d.get(a1, a2, a3, a4).toString(locale));
1107 }
1108 }
1109
1110 /**
1111 * Logs a debug message with an accompanying exception.
1112 *
1113 * @param <T1>
1114 * The type of the first message argument.
1115 * @param <T2>
1116 * The type of the second message argument.
1117 * @param <T3>
1118 * The type of the third message argument.
1119 * @param <T4>
1120 * The type of the fourth message argument.
1121 * @param m
1122 * The marker information associated with this log message.
1123 * @param d
1124 * The message descriptor.
1125 * @param a1
1126 * The first message argument.
1127 * @param a2
1128 * The second message argument.
1129 * @param a3
1130 * The third message argument.
1131 * @param a4
1132 * The fourth message argument.
1133 * @param t
1134 * The throwable to log.
1135 * @see org.slf4j.Logger#debug(String, Throwable)
1136 */
1137 public <T1, T2, T3, T4> void debug(final Marker m, final Arg4<T1, T2, T3, T4> d, final T1 a1,
1138 final T2 a2, final T3 a3, final T4 a4, final Throwable t) {
1139 if (logger.isDebugEnabled(m)) {
1140 logger.debug(m, d.get(a1, a2, a3, a4).toString(locale), t);
1141 }
1142 }
1143
1144 /**
1145 * Logs a debug message.
1146 *
1147 * @param <T1>
1148 * The type of the first message argument.
1149 * @param <T2>
1150 * The type of the second message argument.
1151 * @param <T3>
1152 * The type of the third message argument.
1153 * @param <T4>
1154 * The type of the fourth message argument.
1155 * @param <T5>
1156 * The type of the fifth message argument.
1157 * @param m
1158 * The marker information associated with this log message.
1159 * @param d
1160 * The message descriptor.
1161 * @param a1
1162 * The first message argument.
1163 * @param a2
1164 * The second message argument.
1165 * @param a3
1166 * The third message argument.
1167 * @param a4
1168 * The fourth message argument.
1169 * @param a5
1170 * The fifth message argument.
1171 * @see org.slf4j.Logger#debug(String)
1172 */
1173 public <T1, T2, T3, T4, T5> void debug(final Marker m, final Arg5<T1, T2, T3, T4, T5> d,
1174 final T1 a1, final T2 a2, final T3 a3, final T4 a4, final T5 a5) {
1175 if (logger.isDebugEnabled(m)) {
1176 logger.debug(m, d.get(a1, a2, a3, a4, a5).toString(locale));
1177 }
1178 }
1179
1180 /**
1181 * Logs a debug message with an accompanying exception.
1182 *
1183 * @param <T1>
1184 * The type of the first message argument.
1185 * @param <T2>
1186 * The type of the second message argument.
1187 * @param <T3>
1188 * The type of the third message argument.
1189 * @param <T4>
1190 * The type of the fourth message argument.
1191 * @param <T5>
1192 * The type of the fifth message argument.
1193 * @param m
1194 * The marker information associated with this log message.
1195 * @param d
1196 * The message descriptor.
1197 * @param a1
1198 * The first message argument.
1199 * @param a2
1200 * The second message argument.
1201 * @param a3
1202 * The third message argument.
1203 * @param a4
1204 * The fourth message argument.
1205 * @param a5
1206 * The fifth message argument.
1207 * @param t
1208 * The throwable to log.
1209 * @see org.slf4j.Logger#debug(String, Throwable)
1210 */
1211 public <T1, T2, T3, T4, T5> void debug(final Marker m, final Arg5<T1, T2, T3, T4, T5> d,
1212 final T1 a1, final T2 a2, final T3 a3, final T4 a4, final T5 a5, final Throwable t) {
1213 if (logger.isDebugEnabled(m)) {
1214 logger.debug(m, d.get(a1, a2, a3, a4, a5).toString(locale), t);
1215 }
1216 }
1217
1218 /**
1219 * Logs a debug message.
1220 *
1221 * @param <T1>
1222 * The type of the first message argument.
1223 * @param <T2>
1224 * The type of the second message argument.
1225 * @param <T3>
1226 * The type of the third message argument.
1227 * @param <T4>
1228 * The type of the fourth message argument.
1229 * @param <T5>
1230 * The type of the fifth message argument.
1231 * @param <T6>
1232 * The type of the sixth message argument.
1233 * @param m
1234 * The marker information associated with this log message.
1235 * @param d
1236 * The message descriptor.
1237 * @param a1
1238 * The first message argument.
1239 * @param a2
1240 * The second message argument.
1241 * @param a3
1242 * The third message argument.
1243 * @param a4
1244 * The fourth message argument.
1245 * @param a5
1246 * The fifth message argument.
1247 * @param a6
1248 * The sixth message argument.
1249 * @see org.slf4j.Logger#debug(String)
1250 */
1251 public <T1, T2, T3, T4, T5, T6> void debug(final Marker m,
1252 final Arg6<T1, T2, T3, T4, T5, T6> d, final T1 a1, final T2 a2, final T3 a3,
1253 final T4 a4, final T5 a5, final T6 a6) {
1254 if (logger.isDebugEnabled(m)) {
1255 logger.debug(m, d.get(a1, a2, a3, a4, a5, a6).toString(locale));
1256 }
1257 }
1258
1259 /**
1260 * Logs a debug message with an accompanying exception.
1261 *
1262 * @param <T1>
1263 * The type of the first message argument.
1264 * @param <T2>
1265 * The type of the second message argument.
1266 * @param <T3>
1267 * The type of the third message argument.
1268 * @param <T4>
1269 * The type of the fourth message argument.
1270 * @param <T5>
1271 * The type of the fifth message argument.
1272 * @param <T6>
1273 * The type of the sixth message argument.
1274 * @param m
1275 * The marker information associated with this log message.
1276 * @param d
1277 * The message descriptor.
1278 * @param a1
1279 * The first message argument.
1280 * @param a2
1281 * The second message argument.
1282 * @param a3
1283 * The third message argument.
1284 * @param a4
1285 * The fourth message argument.
1286 * @param a5
1287 * The fifth message argument.
1288 * @param a6
1289 * The sixth message argument.
1290 * @param t
1291 * The throwable to log.
1292 * @see org.slf4j.Logger#debug(String, Throwable)
1293 */
1294 public <T1, T2, T3, T4, T5, T6> void debug(final Marker m,
1295 final Arg6<T1, T2, T3, T4, T5, T6> d, final T1 a1, final T2 a2, final T3 a3,
1296 final T4 a4, final T5 a5, final T6 a6, final Throwable t) {
1297 if (logger.isDebugEnabled(m)) {
1298 logger.debug(m, d.get(a1, a2, a3, a4, a5, a6).toString(locale), t);
1299 }
1300 }
1301
1302 /**
1303 * Logs a debug 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 <T7>
1318 * The type of the seventh message argument.
1319 * @param m
1320 * The marker information associated with this log message.
1321 * @param d
1322 * The message descriptor.
1323 * @param a1
1324 * The first message argument.
1325 * @param a2
1326 * The second message argument.
1327 * @param a3
1328 * The third message argument.
1329 * @param a4
1330 * The fourth message argument.
1331 * @param a5
1332 * The fifth message argument.
1333 * @param a6
1334 * The sixth message argument.
1335 * @param a7
1336 * The seventh message argument.
1337 * @see org.slf4j.Logger#debug(String)
1338 */
1339 public <T1, T2, T3, T4, T5, T6, T7> void debug(final Marker m,
1340 final Arg7<T1, T2, T3, T4, T5, T6, T7> d, final T1 a1, final T2 a2, final T3 a3,
1341 final T4 a4, final T5 a5, final T6 a6, final T7 a7) {
1342 if (logger.isDebugEnabled(m)) {
1343 logger.debug(m, d.get(a1, a2, a3, a4, a5, a6, a7).toString(locale));
1344 }
1345 }
1346
1347 /**
1348 * Logs a debug message with an accompanying exception.
1349 *
1350 * @param <T1>
1351 * The type of the first message argument.
1352 * @param <T2>
1353 * The type of the second message argument.
1354 * @param <T3>
1355 * The type of the third message argument.
1356 * @param <T4>
1357 * The type of the fourth message argument.
1358 * @param <T5>
1359 * The type of the fifth message argument.
1360 * @param <T6>
1361 * The type of the sixth message argument.
1362 * @param <T7>
1363 * The type of the seventh message argument.
1364 * @param m
1365 * The marker information associated with this log message.
1366 * @param d
1367 * The message descriptor.
1368 * @param a1
1369 * The first message argument.
1370 * @param a2
1371 * The second message argument.
1372 * @param a3
1373 * The third message argument.
1374 * @param a4
1375 * The fourth message argument.
1376 * @param a5
1377 * The fifth message argument.
1378 * @param a6
1379 * The sixth message argument.
1380 * @param a7
1381 * The seventh message argument.
1382 * @param t
1383 * The throwable to log.
1384 * @see org.slf4j.Logger#debug(String, Throwable)
1385 */
1386 public <T1, T2, T3, T4, T5, T6, T7> void debug(final Marker m,
1387 final Arg7<T1, T2, T3, T4, T5, T6, T7> d, final T1 a1, final T2 a2, final T3 a3,
1388 final T4 a4, final T5 a5, final T6 a6, final T7 a7, final Throwable t) {
1389 if (logger.isDebugEnabled(m)) {
1390 logger.debug(m, d.get(a1, a2, a3, a4, a5, a6, a7).toString(locale), t);
1391 }
1392 }
1393
1394 /**
1395 * Logs a debug message.
1396 *
1397 * @param <T1>
1398 * The type of the first message argument.
1399 * @param <T2>
1400 * The type of the second message argument.
1401 * @param <T3>
1402 * The type of the third message argument.
1403 * @param <T4>
1404 * The type of the fourth message argument.
1405 * @param <T5>
1406 * The type of the fifth message argument.
1407 * @param <T6>
1408 * The type of the sixth message argument.
1409 * @param <T7>
1410 * The type of the seventh message argument.
1411 * @param <T8>
1412 * The type of the eighth message argument.
1413 * @param m
1414 * The marker information associated with this log message.
1415 * @param d
1416 * The message descriptor.
1417 * @param a1
1418 * The first message argument.
1419 * @param a2
1420 * The second message argument.
1421 * @param a3
1422 * The third message argument.
1423 * @param a4
1424 * The fourth message argument.
1425 * @param a5
1426 * The fifth message argument.
1427 * @param a6
1428 * The sixth message argument.
1429 * @param a7
1430 * The seventh message argument.
1431 * @param a8
1432 * The eighth message argument.
1433 * @see org.slf4j.Logger#debug(String)
1434 */
1435 public <T1, T2, T3, T4, T5, T6, T7, T8> void debug(final Marker m,
1436 final Arg8<T1, T2, T3, T4, T5, T6, T7, T8> d, final T1 a1, final T2 a2, final T3 a3,
1437 final T4 a4, final T5 a5, final T6 a6, final T7 a7, final T8 a8) {
1438 if (logger.isDebugEnabled(m)) {
1439 logger.debug(m, d.get(a1, a2, a3, a4, a5, a6, a7, a8).toString(locale));
1440 }
1441 }
1442
1443 /**
1444 * Logs a debug message with an accompanying exception.
1445 *
1446 * @param <T1>
1447 * The type of the first message argument.
1448 * @param <T2>
1449 * The type of the second message argument.
1450 * @param <T3>
1451 * The type of the third message argument.
1452 * @param <T4>
1453 * The type of the fourth message argument.
1454 * @param <T5>
1455 * The type of the fifth message argument.
1456 * @param <T6>
1457 * The type of the sixth message argument.
1458 * @param <T7>
1459 * The type of the seventh message argument.
1460 * @param <T8>
1461 * The type of the eighth message argument.
1462 * @param m
1463 * The marker information associated with this log message.
1464 * @param d
1465 * The message descriptor.
1466 * @param a1
1467 * The first message argument.
1468 * @param a2
1469 * The second message argument.
1470 * @param a3
1471 * The third message argument.
1472 * @param a4
1473 * The fourth message argument.
1474 * @param a5
1475 * The fifth message argument.
1476 * @param a6
1477 * The sixth message argument.
1478 * @param a7
1479 * The seventh message argument.
1480 * @param a8
1481 * The eighth message argument.
1482 * @param t
1483 * The throwable to log.
1484 * @see org.slf4j.Logger#debug(String, Throwable)
1485 */
1486 public <T1, T2, T3, T4, T5, T6, T7, T8> void debug(final Marker m,
1487 final Arg8<T1, T2, T3, T4, T5, T6, T7, T8> d, final T1 a1, final T2 a2, final T3 a3,
1488 final T4 a4, final T5 a5, final T6 a6, final T7 a7, final T8 a8, final Throwable t) {
1489 if (logger.isDebugEnabled(m)) {
1490 logger.debug(m, d.get(a1, a2, a3, a4, a5, a6, a7, a8).toString(locale), t);
1491 }
1492 }
1493
1494 /**
1495 * Logs a debug message.
1496 *
1497 * @param <T1>
1498 * The type of the first message argument.
1499 * @param <T2>
1500 * The type of the second message argument.
1501 * @param <T3>
1502 * The type of the third message argument.
1503 * @param <T4>
1504 * The type of the fourth message argument.
1505 * @param <T5>
1506 * The type of the fifth message argument.
1507 * @param <T6>
1508 * The type of the sixth message argument.
1509 * @param <T7>
1510 * The type of the seventh message argument.
1511 * @param <T8>
1512 * The type of the eighth message argument.
1513 * @param <T9>
1514 * The type of the ninth message argument.
1515 * @param m
1516 * The marker information associated with this log message.
1517 * @param d
1518 * The message descriptor.
1519 * @param a1
1520 * The first message argument.
1521 * @param a2
1522 * The second message argument.
1523 * @param a3
1524 * The third message argument.
1525 * @param a4
1526 * The fourth message argument.
1527 * @param a5
1528 * The fifth message argument.
1529 * @param a6
1530 * The sixth message argument.
1531 * @param a7
1532 * The seventh message argument.
1533 * @param a8
1534 * The eighth message argument.
1535 * @param a9
1536 * The ninth message argument.
1537 * @see org.slf4j.Logger#debug(String)
1538 */
1539 public <T1, T2, T3, T4, T5, T6, T7, T8, T9> void debug(final Marker m,
1540 final Arg9<T1, T2, T3, T4, T5, T6, T7, T8, T9> d, final T1 a1, final T2 a2,
1541 final T3 a3, final T4 a4, final T5 a5, final T6 a6, final T7 a7, final T8 a8,
1542 final T9 a9) {
1543 if (logger.isDebugEnabled(m)) {
1544 logger.debug(m, d.get(a1, a2, a3, a4, a5, a6, a7, a8, a9).toString(locale));
1545 }
1546 }
1547
1548 /**
1549 * Logs a debug message with an accompanying exception.
1550 *
1551 * @param <T1>
1552 * The type of the first message argument.
1553 * @param <T2>
1554 * The type of the second message argument.
1555 * @param <T3>
1556 * The type of the third message argument.
1557 * @param <T4>
1558 * The type of the fourth message argument.
1559 * @param <T5>
1560 * The type of the fifth message argument.
1561 * @param <T6>
1562 * The type of the sixth message argument.
1563 * @param <T7>
1564 * The type of the seventh message argument.
1565 * @param <T8>
1566 * The type of the eighth message argument.
1567 * @param <T9>
1568 * The type of the ninth message argument.
1569 * @param m
1570 * The marker information associated with this log message.
1571 * @param d
1572 * The message descriptor.
1573 * @param a1
1574 * The first message argument.
1575 * @param a2
1576 * The second message argument.
1577 * @param a3
1578 * The third message argument.
1579 * @param a4
1580 * The fourth message argument.
1581 * @param a5
1582 * The fifth message argument.
1583 * @param a6
1584 * The sixth message argument.
1585 * @param a7
1586 * The seventh message argument.
1587 * @param a8
1588 * The eighth message argument.
1589 * @param a9
1590 * The ninth message argument.
1591 * @param t
1592 * The throwable to log.
1593 * @see org.slf4j.Logger#debug(String, Throwable)
1594 */
1595 public <T1, T2, T3, T4, T5, T6, T7, T8, T9> void debug(final Marker m,
1596 final Arg9<T1, T2, T3, T4, T5, T6, T7, T8, T9> d, final T1 a1, final T2 a2,
1597 final T3 a3, final T4 a4, final T5 a5, final T6 a6, final T7 a7, final T8 a8,
1598 final T9 a9, final Throwable t) {
1599 if (logger.isDebugEnabled(m)) {
1600 logger.debug(m, d.get(a1, a2, a3, a4, a5, a6, a7, a8, a9).toString(locale), t);
1601 }
1602 }
1603
1604 /**
1605 * Logs a debug message.
1606 *
1607 * @param m
1608 * The marker information associated with this log message.
1609 * @param d
1610 * The message descriptor.
1611 * @param args
1612 * The message arguments.
1613 * @see org.slf4j.Logger#debug(String)
1614 */
1615 public void debug(final Marker m, final ArgN d, final Object... args) {
1616 if (logger.isDebugEnabled(m)) {
1617 logger.debug(m, d.get(args).toString(locale));
1618 }
1619 }
1620
1621 /**
1622 * Logs a debug message with an accompanying exception.
1623 *
1624 * @param m
1625 * The marker information associated with this log message.
1626 * @param d
1627 * The message descriptor.
1628 * @param t
1629 * The throwable to log.
1630 * @param args
1631 * The message arguments.
1632 * @see org.slf4j.Logger#debug(String, Throwable)
1633 */
1634 public void debug(final Marker m, final ArgN d, final Throwable t, final Object... args) {
1635 if (logger.isDebugEnabled(m)) {
1636 logger.debug(m, d.get(args).toString(locale), t);
1637 }
1638 }
1639
1640 /**
1641 * Logs an error message.
1642 *
1643 * @param d
1644 * The message descriptor.
1645 * @see org.slf4j.Logger#error(String)
1646 */
1647 public void error(final Arg0 d) {
1648 if (logger.isErrorEnabled()) {
1649 final LocalizableMessage message = d.get();
1650 logger.error(new LocalizedMarker(message), message.toString(locale));
1651 }
1652 }
1653
1654 /**
1655 * Logs an error message with an accompanying exception.
1656 *
1657 * @param d
1658 * The message descriptor.
1659 * @param t
1660 * The throwable to log.
1661 * @see org.slf4j.Logger#error(String, Throwable)
1662 */
1663 public void error(final Arg0 d, final Throwable t) {
1664 if (logger.isErrorEnabled()) {
1665 final LocalizableMessage message = d.get();
1666 logger.error(new LocalizedMarker(message), message.toString(locale), t);
1667 }
1668 }
1669
1670 /**
1671 * Logs an error message.
1672 *
1673 * @param <T1>
1674 * The type of the first message argument.
1675 * @param d
1676 * The message descriptor.
1677 * @param a1
1678 * The first message argument.
1679 * @see org.slf4j.Logger#error(String)
1680 */
1681 public <T1> void error(final Arg1<T1> d, final T1 a1) {
1682 if (logger.isErrorEnabled()) {
1683 final LocalizableMessage message = d.get(a1);
1684 logger.error(new LocalizedMarker(message), message.toString(locale));
1685 }
1686 }
1687
1688 /**
1689 * Logs an error message with an accompanying exception.
1690 *
1691 * @param <T1>
1692 * The type of the first message argument.
1693 * @param d
1694 * The message descriptor.
1695 * @param a1
1696 * The first message argument.
1697 * @param t
1698 * The throwable to log.
1699 * @see org.slf4j.Logger#error(String, Throwable)
1700 */
1701 public <T1> void error(final Arg1<T1> d, final T1 a1, final Throwable t) {
1702 if (logger.isErrorEnabled()) {
1703 final LocalizableMessage message = d.get(a1);
1704 logger.error(new LocalizedMarker(message), message.toString(locale), t);
1705 }
1706 }
1707
1708 /**
1709 * Logs an error message.
1710 *
1711 * @param <T1>
1712 * The type of the first message argument.
1713 * @param <T2>
1714 * The type of the second message argument.
1715 * @param d
1716 * The message descriptor.
1717 * @param a1
1718 * The first message argument.
1719 * @param a2
1720 * The second message argument.
1721 * @see org.slf4j.Logger#error(String)
1722 */
1723 public <T1, T2> void error(final Arg2<T1, T2> d, final T1 a1, final T2 a2) {
1724 if (logger.isErrorEnabled()) {
1725 final LocalizableMessage message = d.get(a1, a2);
1726 logger.error(new LocalizedMarker(message), message.toString(locale));
1727 }
1728 }
1729
1730 /**
1731 * Logs an error message with an accompanying exception.
1732 *
1733 * @param <T1>
1734 * The type of the first message argument.
1735 * @param <T2>
1736 * The type of the second message argument.
1737 * @param d
1738 * The message descriptor.
1739 * @param a1
1740 * The first message argument.
1741 * @param a2
1742 * The second message argument.
1743 * @param t
1744 * The throwable to log.
1745 * @see org.slf4j.Logger#error(String, Throwable)
1746 */
1747 public <T1, T2> void error(final Arg2<T1, T2> d, final T1 a1, final T2 a2, final Throwable t) {
1748 if (logger.isErrorEnabled()) {
1749 final LocalizableMessage message = d.get(a1, a2);
1750 logger.error(new LocalizedMarker(message), message.toString(locale), t);
1751 }
1752 }
1753
1754 /**
1755 * Logs an error message.
1756 *
1757 * @param <T1>
1758 * The type of the first message argument.
1759 * @param <T2>
1760 * The type of the second message argument.
1761 * @param <T3>
1762 * The type of the third message argument.
1763 * @param d
1764 * The message descriptor.
1765 * @param a1
1766 * The first message argument.
1767 * @param a2
1768 * The second message argument.
1769 * @param a3
1770 * The third message argument.
1771 * @see org.slf4j.Logger#error(String)
1772 */
1773 public <T1, T2, T3> void error(final Arg3<T1, T2, T3> d, final T1 a1, final T2 a2, final T3 a3) {
1774 if (logger.isErrorEnabled()) {
1775 final LocalizableMessage message = d.get(a1, a2, a3);
1776 logger.error(new LocalizedMarker(message), message.toString(locale));
1777 }
1778 }
1779
1780 /**
1781 * Logs an error message with an accompanying exception.
1782 *
1783 * @param <T1>
1784 * The type of the first message argument.
1785 * @param <T2>
1786 * The type of the second message argument.
1787 * @param <T3>
1788 * The type of the third message argument.
1789 * @param d
1790 * The message descriptor.
1791 * @param a1
1792 * The first message argument.
1793 * @param a2
1794 * The second message argument.
1795 * @param a3
1796 * The third message argument.
1797 * @param t
1798 * The throwable to log.
1799 * @see org.slf4j.Logger#error(String, Throwable)
1800 */
1801 public <T1, T2, T3> void error(final Arg3<T1, T2, T3> d, final T1 a1, final T2 a2, final T3 a3,
1802 final Throwable t) {
1803 if (logger.isErrorEnabled()) {
1804 final LocalizableMessage message = d.get(a1, a2, a3);
1805 logger.error(new LocalizedMarker(message), message.toString(locale), t);
1806 }
1807 }
1808
1809 /**
1810 * Logs an error message.
1811 *
1812 * @param <T1>
1813 * The type of the first message argument.
1814 * @param <T2>
1815 * The type of the second message argument.
1816 * @param <T3>
1817 * The type of the third message argument.
1818 * @param <T4>
1819 * The type of the fourth message argument.
1820 * @param d
1821 * The message descriptor.
1822 * @param a1
1823 * The first message argument.
1824 * @param a2
1825 * The second message argument.
1826 * @param a3
1827 * The third message argument.
1828 * @param a4
1829 * The fourth message argument.
1830 * @see org.slf4j.Logger#error(String)
1831 */
1832 public <T1, T2, T3, T4> void error(final Arg4<T1, T2, T3, T4> d, final T1 a1, final T2 a2,
1833 final T3 a3, final T4 a4) {
1834 if (logger.isErrorEnabled()) {
1835 final LocalizableMessage message = d.get(a1, a2, a3, a4);
1836 logger.error(new LocalizedMarker(message), message.toString(locale));
1837 }
1838 }
1839
1840 /**
1841 * Logs an error message with an accompanying exception.
1842 *
1843 * @param <T1>
1844 * The type of the first message argument.
1845 * @param <T2>
1846 * The type of the second message argument.
1847 * @param <T3>
1848 * The type of the third message argument.
1849 * @param <T4>
1850 * The type of the fourth message argument.
1851 * @param d
1852 * The message descriptor.
1853 * @param a1
1854 * The first message argument.
1855 * @param a2
1856 * The second message argument.
1857 * @param a3
1858 * The third message argument.
1859 * @param a4
1860 * The fourth message argument.
1861 * @param t
1862 * The throwable to log.
1863 * @see org.slf4j.Logger#error(String, Throwable)
1864 */
1865 public <T1, T2, T3, T4> void error(final Arg4<T1, T2, T3, T4> d, final T1 a1, final T2 a2,
1866 final T3 a3, final T4 a4, final Throwable t) {
1867 if (logger.isErrorEnabled()) {
1868 final LocalizableMessage message = d.get(a1, a2, a3, a4);
1869 logger.error(new LocalizedMarker(message), message.toString(locale), t);
1870 }
1871 }
1872
1873 /**
1874 * Logs an error message.
1875 *
1876 * @param <T1>
1877 * The type of the first message argument.
1878 * @param <T2>
1879 * The type of the second message argument.
1880 * @param <T3>
1881 * The type of the third message argument.
1882 * @param <T4>
1883 * The type of the fourth message argument.
1884 * @param <T5>
1885 * The type of the fifth message argument.
1886 * @param d
1887 * The message descriptor.
1888 * @param a1
1889 * The first message argument.
1890 * @param a2
1891 * The second message argument.
1892 * @param a3
1893 * The third message argument.
1894 * @param a4
1895 * The fourth message argument.
1896 * @param a5
1897 * The fifth message argument.
1898 * @see org.slf4j.Logger#error(String)
1899 */
1900 public <T1, T2, T3, T4, T5> void error(final Arg5<T1, T2, T3, T4, T5> d, final T1 a1,
1901 final T2 a2, final T3 a3, final T4 a4, final T5 a5) {
1902 if (logger.isErrorEnabled()) {
1903 final LocalizableMessage message = d.get(a1, a2, a3, a4, a5);
1904 logger.error(new LocalizedMarker(message), message.toString(locale));
1905 }
1906 }
1907
1908 /**
1909 * Logs an error message with an accompanying exception.
1910 *
1911 * @param <T1>
1912 * The type of the first message argument.
1913 * @param <T2>
1914 * The type of the second message argument.
1915 * @param <T3>
1916 * The type of the third message argument.
1917 * @param <T4>
1918 * The type of the fourth message argument.
1919 * @param <T5>
1920 * The type of the fifth message argument.
1921 * @param d
1922 * The message descriptor.
1923 * @param a1
1924 * The first message argument.
1925 * @param a2
1926 * The second message argument.
1927 * @param a3
1928 * The third message argument.
1929 * @param a4
1930 * The fourth message argument.
1931 * @param a5
1932 * The fifth message argument.
1933 * @param t
1934 * The throwable to log.
1935 * @see org.slf4j.Logger#error(String, Throwable)
1936 */
1937 public <T1, T2, T3, T4, T5> void error(final Arg5<T1, T2, T3, T4, T5> d, final T1 a1,
1938 final T2 a2, final T3 a3, final T4 a4, final T5 a5, final Throwable t) {
1939 if (logger.isErrorEnabled()) {
1940 final LocalizableMessage message = d.get(a1, a2, a3, a4, a5);
1941 logger.error(new LocalizedMarker(message), message.toString(locale), t);
1942 }
1943 }
1944
1945 /**
1946 * Logs an error message.
1947 *
1948 * @param <T1>
1949 * The type of the first message argument.
1950 * @param <T2>
1951 * The type of the second message argument.
1952 * @param <T3>
1953 * The type of the third message argument.
1954 * @param <T4>
1955 * The type of the fourth message argument.
1956 * @param <T5>
1957 * The type of the fifth message argument.
1958 * @param <T6>
1959 * The type of the sixth message argument.
1960 * @param d
1961 * The message descriptor.
1962 * @param a1
1963 * The first message argument.
1964 * @param a2
1965 * The second message argument.
1966 * @param a3
1967 * The third message argument.
1968 * @param a4
1969 * The fourth message argument.
1970 * @param a5
1971 * The fifth message argument.
1972 * @param a6
1973 * The sixth message argument.
1974 * @see org.slf4j.Logger#error(String)
1975 */
1976 public <T1, T2, T3, T4, T5, T6> void error(final Arg6<T1, T2, T3, T4, T5, T6> d, final T1 a1,
1977 final T2 a2, final T3 a3, final T4 a4, final T5 a5, final T6 a6) {
1978 if (logger.isErrorEnabled()) {
1979 final LocalizableMessage message = d.get(a1, a2, a3, a4, a5, a6);
1980 logger.error(new LocalizedMarker(message), message.toString(locale));
1981 }
1982 }
1983
1984 /**
1985 * Logs an error message with an accompanying exception.
1986 *
1987 * @param <T1>
1988 * The type of the first message argument.
1989 * @param <T2>
1990 * The type of the second message argument.
1991 * @param <T3>
1992 * The type of the third message argument.
1993 * @param <T4>
1994 * The type of the fourth message argument.
1995 * @param <T5>
1996 * The type of the fifth message argument.
1997 * @param <T6>
1998 * The type of the sixth message argument.
1999 * @param d
2000 * The message descriptor.
2001 * @param a1
2002 * The first message argument.
2003 * @param a2
2004 * The second message argument.
2005 * @param a3
2006 * The third message argument.
2007 * @param a4
2008 * The fourth message argument.
2009 * @param a5
2010 * The fifth message argument.
2011 * @param a6
2012 * The sixth message argument.
2013 * @param t
2014 * The throwable to log.
2015 * @see org.slf4j.Logger#error(String, Throwable)
2016 */
2017 public <T1, T2, T3, T4, T5, T6> void error(final Arg6<T1, T2, T3, T4, T5, T6> d, final T1 a1,
2018 final T2 a2, final T3 a3, final T4 a4, final T5 a5, final T6 a6, final Throwable t) {
2019 if (logger.isErrorEnabled()) {
2020 final LocalizableMessage message = d.get(a1, a2, a3, a4, a5, a6);
2021 logger.error(new LocalizedMarker(message), message.toString(locale), t);
2022 }
2023 }
2024
2025 /**
2026 * Logs an error message.
2027 *
2028 * @param <T1>
2029 * The type of the first message argument.
2030 * @param <T2>
2031 * The type of the second message argument.
2032 * @param <T3>
2033 * The type of the third message argument.
2034 * @param <T4>
2035 * The type of the fourth message argument.
2036 * @param <T5>
2037 * The type of the fifth message argument.
2038 * @param <T6>
2039 * The type of the sixth message argument.
2040 * @param <T7>
2041 * The type of the seventh message argument.
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 * @param a4
2051 * The fourth message argument.
2052 * @param a5
2053 * The fifth message argument.
2054 * @param a6
2055 * The sixth message argument.
2056 * @param a7
2057 * The seventh message argument.
2058 * @see org.slf4j.Logger#error(String)
2059 */
2060 public <T1, T2, T3, T4, T5, T6, T7> void error(final Arg7<T1, T2, T3, T4, T5, T6, T7> d,
2061 final T1 a1, final T2 a2, final T3 a3, final T4 a4, final T5 a5, final T6 a6,
2062 final T7 a7) {
2063 if (logger.isErrorEnabled()) {
2064 final LocalizableMessage message = d.get(a1, a2, a3, a4, a5, a6, a7);
2065 logger.error(new LocalizedMarker(message), message.toString(locale));
2066 }
2067 }
2068
2069 /**
2070 * Logs an error message with an accompanying exception.
2071 *
2072 * @param <T1>
2073 * The type of the first message argument.
2074 * @param <T2>
2075 * The type of the second message argument.
2076 * @param <T3>
2077 * The type of the third message argument.
2078 * @param <T4>
2079 * The type of the fourth message argument.
2080 * @param <T5>
2081 * The type of the fifth message argument.
2082 * @param <T6>
2083 * The type of the sixth message argument.
2084 * @param <T7>
2085 * The type of the seventh message argument.
2086 * @param d
2087 * The message descriptor.
2088 * @param a1
2089 * The first message argument.
2090 * @param a2
2091 * The second message argument.
2092 * @param a3
2093 * The third message argument.
2094 * @param a4
2095 * The fourth message argument.
2096 * @param a5
2097 * The fifth message argument.
2098 * @param a6
2099 * The sixth message argument.
2100 * @param a7
2101 * The seventh message argument.
2102 * @param t
2103 * The throwable to log.
2104 * @see org.slf4j.Logger#error(String, Throwable)
2105 */
2106 public <T1, T2, T3, T4, T5, T6, T7> void error(final Arg7<T1, T2, T3, T4, T5, T6, T7> d,
2107 final T1 a1, final T2 a2, final T3 a3, final T4 a4, final T5 a5, final T6 a6,
2108 final T7 a7, final Throwable t) {
2109 if (logger.isErrorEnabled()) {
2110 final LocalizableMessage message = d.get(a1, a2, a3, a4, a5, a6, a7);
2111 logger.error(new LocalizedMarker(message), message.toString(locale), t);
2112 }
2113 }
2114
2115 /**
2116 * Logs an error message.
2117 *
2118 * @param <T1>
2119 * The type of the first message argument.
2120 * @param <T2>
2121 * The type of the second message argument.
2122 * @param <T3>
2123 * The type of the third message argument.
2124 * @param <T4>
2125 * The type of the fourth message argument.
2126 * @param <T5>
2127 * The type of the fifth message argument.
2128 * @param <T6>
2129 * The type of the sixth message argument.
2130 * @param <T7>
2131 * The type of the seventh message argument.
2132 * @param <T8>
2133 * The type of the eighth message argument.
2134 * @param d
2135 * The message descriptor.
2136 * @param a1
2137 * The first message argument.
2138 * @param a2
2139 * The second message argument.
2140 * @param a3
2141 * The third message argument.
2142 * @param a4
2143 * The fourth message argument.
2144 * @param a5
2145 * The fifth message argument.
2146 * @param a6
2147 * The sixth message argument.
2148 * @param a7
2149 * The seventh message argument.
2150 * @param a8
2151 * The eighth message argument.
2152 * @see org.slf4j.Logger#error(String)
2153 */
2154 public <T1, T2, T3, T4, T5, T6, T7, T8> void error(
2155 final Arg8<T1, T2, T3, T4, T5, T6, T7, T8> d, final T1 a1, final T2 a2, final T3 a3,
2156 final T4 a4, final T5 a5, final T6 a6, final T7 a7, final T8 a8) {
2157 if (logger.isErrorEnabled()) {
2158 final LocalizableMessage message = d.get(a1, a2, a3, a4, a5, a6, a7, a8);
2159 logger.error(new LocalizedMarker(message), message.toString(locale));
2160 }
2161 }
2162
2163 /**
2164 * Logs an error message with an accompanying exception.
2165 *
2166 * @param <T1>
2167 * The type of the first message argument.
2168 * @param <T2>
2169 * The type of the second message argument.
2170 * @param <T3>
2171 * The type of the third message argument.
2172 * @param <T4>
2173 * The type of the fourth message argument.
2174 * @param <T5>
2175 * The type of the fifth message argument.
2176 * @param <T6>
2177 * The type of the sixth message argument.
2178 * @param <T7>
2179 * The type of the seventh message argument.
2180 * @param <T8>
2181 * The type of the eighth message argument.
2182 * @param d
2183 * The message descriptor.
2184 * @param a1
2185 * The first message argument.
2186 * @param a2
2187 * The second message argument.
2188 * @param a3
2189 * The third message argument.
2190 * @param a4
2191 * The fourth message argument.
2192 * @param a5
2193 * The fifth message argument.
2194 * @param a6
2195 * The sixth message argument.
2196 * @param a7
2197 * The seventh message argument.
2198 * @param a8
2199 * The eighth message argument.
2200 * @param t
2201 * The throwable to log.
2202 * @see org.slf4j.Logger#error(String, Throwable)
2203 */
2204 public <T1, T2, T3, T4, T5, T6, T7, T8> void error(
2205 final Arg8<T1, T2, T3, T4, T5, T6, T7, T8> d, final T1 a1, final T2 a2, final T3 a3,
2206 final T4 a4, final T5 a5, final T6 a6, final T7 a7, final T8 a8, final Throwable t) {
2207 if (logger.isErrorEnabled()) {
2208 final LocalizableMessage message = d.get(a1, a2, a3, a4, a5, a6, a7, a8);
2209 logger.error(new LocalizedMarker(message), message.toString(locale), t);
2210 }
2211 }
2212
2213 /**
2214 * Logs an error message.
2215 *
2216 * @param <T1>
2217 * The type of the first message argument.
2218 * @param <T2>
2219 * The type of the second message argument.
2220 * @param <T3>
2221 * The type of the third message argument.
2222 * @param <T4>
2223 * The type of the fourth message argument.
2224 * @param <T5>
2225 * The type of the fifth message argument.
2226 * @param <T6>
2227 * The type of the sixth message argument.
2228 * @param <T7>
2229 * The type of the seventh message argument.
2230 * @param <T8>
2231 * The type of the eighth message argument.
2232 * @param <T9>
2233 * The type of the ninth message argument.
2234 * @param d
2235 * The message descriptor.
2236 * @param a1
2237 * The first message argument.
2238 * @param a2
2239 * The second message argument.
2240 * @param a3
2241 * The third message argument.
2242 * @param a4
2243 * The fourth message argument.
2244 * @param a5
2245 * The fifth message argument.
2246 * @param a6
2247 * The sixth message argument.
2248 * @param a7
2249 * The seventh message argument.
2250 * @param a8
2251 * The eighth message argument.
2252 * @param a9
2253 * The ninth message argument.
2254 * @see org.slf4j.Logger#error(String)
2255 */
2256 public <T1, T2, T3, T4, T5, T6, T7, T8, T9> void error(
2257 final Arg9<T1, T2, T3, T4, T5, T6, T7, T8, T9> d, final T1 a1, final T2 a2,
2258 final T3 a3, final T4 a4, final T5 a5, final T6 a6, final T7 a7, final T8 a8,
2259 final T9 a9) {
2260 if (logger.isErrorEnabled()) {
2261 final LocalizableMessage message = d.get(a1, a2, a3, a4, a5, a6, a7, a8, a9);
2262 logger.error(new LocalizedMarker(message), message.toString(locale));
2263 }
2264 }
2265
2266 /**
2267 * Logs an error message with an accompanying exception.
2268 *
2269 * @param <T1>
2270 * The type of the first message argument.
2271 * @param <T2>
2272 * The type of the second message argument.
2273 * @param <T3>
2274 * The type of the third message argument.
2275 * @param <T4>
2276 * The type of the fourth message argument.
2277 * @param <T5>
2278 * The type of the fifth message argument.
2279 * @param <T6>
2280 * The type of the sixth message argument.
2281 * @param <T7>
2282 * The type of the seventh message argument.
2283 * @param <T8>
2284 * The type of the eighth message argument.
2285 * @param <T9>
2286 * The type of the ninth message argument.
2287 * @param d
2288 * The message descriptor.
2289 * @param a1
2290 * The first message argument.
2291 * @param a2
2292 * The second message argument.
2293 * @param a3
2294 * The third message argument.
2295 * @param a4
2296 * The fourth message argument.
2297 * @param a5
2298 * The fifth message argument.
2299 * @param a6
2300 * The sixth message argument.
2301 * @param a7
2302 * The seventh message argument.
2303 * @param a8
2304 * The eighth message argument.
2305 * @param a9
2306 * The ninth message argument.
2307 * @param t
2308 * The throwable to log.
2309 * @see org.slf4j.Logger#error(String, Throwable)
2310 */
2311 public <T1, T2, T3, T4, T5, T6, T7, T8, T9> void error(
2312 final Arg9<T1, T2, T3, T4, T5, T6, T7, T8, T9> d, final T1 a1, final T2 a2,
2313 final T3 a3, final T4 a4, final T5 a5, final T6 a6, final T7 a7, final T8 a8,
2314 final T9 a9, final Throwable t) {
2315 if (logger.isErrorEnabled()) {
2316 final LocalizableMessage message = d.get(a1, a2, a3, a4, a5, a6, a7, a8, a9);
2317 logger.error(new LocalizedMarker(message), message.toString(locale), t);
2318 }
2319 }
2320
2321 /**
2322 * Logs an error message.
2323 *
2324 * @param d
2325 * The message descriptor.
2326 * @param args
2327 * The message arguments.
2328 * @see org.slf4j.Logger#error(String)
2329 */
2330 public void error(final ArgN d, final Object... args) {
2331 if (logger.isErrorEnabled()) {
2332 final LocalizableMessage message = d.get(args);
2333 logger.error(new LocalizedMarker(message), message.toString(locale));
2334 }
2335 }
2336
2337 /**
2338 * Logs an error message with an accompanying exception.
2339 *
2340 * @param d
2341 * The message descriptor.
2342 * @param t
2343 * The throwable to log.
2344 * @param args
2345 * The message arguments.
2346 * @see org.slf4j.Logger#error(String, Throwable)
2347 */
2348 public void error(final ArgN d, final Throwable t, final Object... args) {
2349 if (logger.isErrorEnabled()) {
2350 final LocalizableMessage message = d.get(args);
2351 logger.error(new LocalizedMarker(message), message.toString(locale), t);
2352 }
2353 }
2354
2355 /**
2356 * Logs an error message.
2357 *
2358 * @param m
2359 * The pre-formatted message.
2360 * @see org.slf4j.Logger#error(String)
2361 */
2362 public void error(final LocalizableMessage m) {
2363 if (logger.isErrorEnabled()) {
2364 logger.error(new LocalizedMarker(m), m.toString(locale));
2365 }
2366 }
2367
2368 /**
2369 * Logs an error message with an accompanying exception.
2370 *
2371 * @param m
2372 * The pre-formatted message.
2373 * @param t
2374 * The throwable to log.
2375 * @see org.slf4j.Logger#error(String, Throwable)
2376 */
2377 public void error(final LocalizableMessage m, final Throwable t) {
2378 if (logger.isErrorEnabled()) {
2379 logger.error(new LocalizedMarker(m), m.toString(locale), t);
2380 }
2381 }
2382
2383 /**
2384 * Logs an error message using the provided {@code Marker}.
2385 *
2386 * @param m
2387 * The marker information associated with this log message.
2388 * @param d
2389 * The message descriptor.
2390 * @see org.slf4j.Logger#error(org.slf4j.Marker, String)
2391 */
2392 public void error(final Marker m, final Arg0 d) {
2393 if (logger.isErrorEnabled(m)) {
2394 logger.error(m, d.get().toString(locale));
2395 }
2396 }
2397
2398 /**
2399 * Logs an error message using the provided {@code Marker}.
2400 *
2401 * @param m
2402 * The marker information associated with this log message.
2403 * @param d
2404 * The message descriptor.
2405 * @param t
2406 * The throwable to log.
2407 * @see org.slf4j.Logger#error(org.slf4j.Marker, String)
2408 */
2409 public void error(final Marker m, final Arg0 d, final Throwable t) {
2410 if (logger.isErrorEnabled(m)) {
2411 logger.error(m, d.get().toString(locale), t);
2412 }
2413 }
2414
2415 /**
2416 * Logs an error message.
2417 *
2418 * @param <T1>
2419 * The type of the first message argument.
2420 * @param m
2421 * The marker information associated with this log message.
2422 * @param d
2423 * The message descriptor.
2424 * @param a1
2425 * The first message argument.
2426 * @see org.slf4j.Logger#error(String)
2427 */
2428 public <T1> void error(final Marker m, final Arg1<T1> d, final T1 a1) {
2429 if (logger.isErrorEnabled(m)) {
2430 logger.error(m, d.get(a1).toString(locale));
2431 }
2432 }
2433
2434 /**
2435 * Logs an error message with an accompanying exception.
2436 *
2437 * @param <T1>
2438 * The type of the first message argument.
2439 * @param m
2440 * The marker information associated with this log message.
2441 * @param d
2442 * The message descriptor.
2443 * @param a1
2444 * The first message argument.
2445 * @param t
2446 * The throwable to log.
2447 * @see org.slf4j.Logger#error(String, Throwable)
2448 */
2449 public <T1> void error(final Marker m, final Arg1<T1> d, final T1 a1, final Throwable t) {
2450 if (logger.isErrorEnabled(m)) {
2451 logger.error(m, d.get(a1).toString(locale), t);
2452 }
2453 }
2454
2455 /**
2456 * Logs an error message.
2457 *
2458 * @param <T1>
2459 * The type of the first message argument.
2460 * @param <T2>
2461 * The type of the second message argument.
2462 * @param m
2463 * The marker information associated with this log message.
2464 * @param d
2465 * The message descriptor.
2466 * @param a1
2467 * The first message argument.
2468 * @param a2
2469 * The second message argument.
2470 * @see org.slf4j.Logger#error(String)
2471 */
2472 public <T1, T2> void error(final Marker m, final Arg2<T1, T2> d, final T1 a1, final T2 a2) {
2473 if (logger.isErrorEnabled(m)) {
2474 logger.error(m, d.get(a1, a2).toString(locale));
2475 }
2476 }
2477
2478 /**
2479 * Logs an error message with an accompanying exception.
2480 *
2481 * @param <T1>
2482 * The type of the first message argument.
2483 * @param <T2>
2484 * The type of the second message argument.
2485 * @param m
2486 * The marker information associated with this log message.
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 t
2494 * The throwable to log.
2495 * @see org.slf4j.Logger#error(String, Throwable)
2496 */
2497 public <T1, T2> void error(final Marker m, final Arg2<T1, T2> d, final T1 a1, final T2 a2,
2498 final Throwable t) {
2499 if (logger.isErrorEnabled(m)) {
2500 logger.error(m, d.get(a1, a2).toString(locale), t);
2501 }
2502 }
2503
2504 /**
2505 * Logs an error message.
2506 *
2507 * @param <T1>
2508 * The type of the first message argument.
2509 * @param <T2>
2510 * The type of the second message argument.
2511 * @param <T3>
2512 * The type of the third message argument.
2513 * @param m
2514 * The marker information associated with this log message.
2515 * @param d
2516 * The message descriptor.
2517 * @param a1
2518 * The first message argument.
2519 * @param a2
2520 * The second message argument.
2521 * @param a3
2522 * The third message argument.
2523 * @see org.slf4j.Logger#error(String)
2524 */
2525 public <T1, T2, T3> void error(final Marker m, final Arg3<T1, T2, T3> d, final T1 a1,
2526 final T2 a2, final T3 a3) {
2527 if (logger.isErrorEnabled(m)) {
2528 logger.error(m, d.get(a1, a2, a3).toString(locale));
2529 }
2530 }
2531
2532 /**
2533 * Logs an error message with an accompanying exception.
2534 *
2535 * @param <T1>
2536 * The type of the first message argument.
2537 * @param <T2>
2538 * The type of the second message argument.
2539 * @param <T3>
2540 * The type of the third message argument.
2541 * @param m
2542 * The marker information associated with this log message.
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 t
2552 * The throwable to log.
2553 * @see org.slf4j.Logger#error(String, Throwable)
2554 */
2555 public <T1, T2, T3> void error(final Marker m, final Arg3<T1, T2, T3> d, final T1 a1,
2556 final T2 a2, final T3 a3, final Throwable t) {
2557 if (logger.isErrorEnabled(m)) {
2558 logger.error(m, d.get(a1, a2, a3).toString(locale), t);
2559 }
2560 }
2561
2562 /**
2563 * Logs an error message.
2564 *
2565 * @param <T1>
2566 * The type of the first message argument.
2567 * @param <T2>
2568 * The type of the second message argument.
2569 * @param <T3>
2570 * The type of the third message argument.
2571 * @param <T4>
2572 * The type of the fourth message argument.
2573 * @param m
2574 * The marker information associated with this log message.
2575 * @param d
2576 * The message descriptor.
2577 * @param a1
2578 * The first message argument.
2579 * @param a2
2580 * The second message argument.
2581 * @param a3
2582 * The third message argument.
2583 * @param a4
2584 * The fourth message argument.
2585 * @see org.slf4j.Logger#error(String)
2586 */
2587 public <T1, T2, T3, T4> void error(final Marker m, final Arg4<T1, T2, T3, T4> d, final T1 a1,
2588 final T2 a2, final T3 a3, final T4 a4) {
2589 if (logger.isErrorEnabled(m)) {
2590 logger.error(m, d.get(a1, a2, a3, a4).toString(locale));
2591 }
2592 }
2593
2594 /**
2595 * Logs an error message with an accompanying exception.
2596 *
2597 * @param <T1>
2598 * The type of the first message argument.
2599 * @param <T2>
2600 * The type of the second message argument.
2601 * @param <T3>
2602 * The type of the third message argument.
2603 * @param <T4>
2604 * The type of the fourth message argument.
2605 * @param m
2606 * The marker information associated with this log message.
2607 * @param d
2608 * The message descriptor.
2609 * @param a1
2610 * The first message argument.
2611 * @param a2
2612 * The second message argument.
2613 * @param a3
2614 * The third message argument.
2615 * @param a4
2616 * The fourth message argument.
2617 * @param t
2618 * The throwable to log.
2619 * @see org.slf4j.Logger#error(String, Throwable)
2620 */
2621 public <T1, T2, T3, T4> void error(final Marker m, final Arg4<T1, T2, T3, T4> d, final T1 a1,
2622 final T2 a2, final T3 a3, final T4 a4, final Throwable t) {
2623 if (logger.isErrorEnabled(m)) {
2624 logger.error(m, d.get(a1, a2, a3, a4).toString(locale), t);
2625 }
2626 }
2627
2628 /**
2629 * Logs an error message.
2630 *
2631 * @param <T1>
2632 * The type of the first message argument.
2633 * @param <T2>
2634 * The type of the second message argument.
2635 * @param <T3>
2636 * The type of the third message argument.
2637 * @param <T4>
2638 * The type of the fourth message argument.
2639 * @param <T5>
2640 * The type of the fifth message argument.
2641 * @param m
2642 * The marker information associated with this log message.
2643 * @param d
2644 * The message descriptor.
2645 * @param a1
2646 * The first message argument.
2647 * @param a2
2648 * The second message argument.
2649 * @param a3
2650 * The third message argument.
2651 * @param a4
2652 * The fourth message argument.
2653 * @param a5
2654 * The fifth message argument.
2655 * @see org.slf4j.Logger#error(String)
2656 */
2657 public <T1, T2, T3, T4, T5> void error(final Marker m, final Arg5<T1, T2, T3, T4, T5> d,
2658 final T1 a1, final T2 a2, final T3 a3, final T4 a4, final T5 a5) {
2659 if (logger.isErrorEnabled(m)) {
2660 logger.error(m, d.get(a1, a2, a3, a4, a5).toString(locale));
2661 }
2662 }
2663
2664 /**
2665 * Logs an error message with an accompanying exception.
2666 *
2667 * @param <T1>
2668 * The type of the first message argument.
2669 * @param <T2>
2670 * The type of the second message argument.
2671 * @param <T3>
2672 * The type of the third message argument.
2673 * @param <T4>
2674 * The type of the fourth message argument.
2675 * @param <T5>
2676 * The type of the fifth message argument.
2677 * @param m
2678 * The marker information associated with this log message.
2679 * @param d
2680 * The message descriptor.
2681 * @param a1
2682 * The first message argument.
2683 * @param a2
2684 * The second message argument.
2685 * @param a3
2686 * The third message argument.
2687 * @param a4
2688 * The fourth message argument.
2689 * @param a5
2690 * The fifth message argument.
2691 * @param t
2692 * The throwable to log.
2693 * @see org.slf4j.Logger#error(String, Throwable)
2694 */
2695 public <T1, T2, T3, T4, T5> void error(final Marker m, final Arg5<T1, T2, T3, T4, T5> d,
2696 final T1 a1, final T2 a2, final T3 a3, final T4 a4, final T5 a5, final Throwable t) {
2697 if (logger.isErrorEnabled(m)) {
2698 logger.error(m, d.get(a1, a2, a3, a4, a5).toString(locale), t);
2699 }
2700 }
2701
2702 /**
2703 * Logs an error message.
2704 *
2705 * @param <T1>
2706 * The type of the first message argument.
2707 * @param <T2>
2708 * The type of the second message argument.
2709 * @param <T3>
2710 * The type of the third message argument.
2711 * @param <T4>
2712 * The type of the fourth message argument.
2713 * @param <T5>
2714 * The type of the fifth message argument.
2715 * @param <T6>
2716 * The type of the sixth message argument.
2717 * @param m
2718 * The marker information associated with this log message.
2719 * @param d
2720 * The message descriptor.
2721 * @param a1
2722 * The first message argument.
2723 * @param a2
2724 * The second message argument.
2725 * @param a3
2726 * The third message argument.
2727 * @param a4
2728 * The fourth message argument.
2729 * @param a5
2730 * The fifth message argument.
2731 * @param a6
2732 * The sixth message argument.
2733 * @see org.slf4j.Logger#error(String)
2734 */
2735 public <T1, T2, T3, T4, T5, T6> void error(final Marker m,
2736 final Arg6<T1, T2, T3, T4, T5, T6> d, final T1 a1, final T2 a2, final T3 a3,
2737 final T4 a4, final T5 a5, final T6 a6) {
2738 if (logger.isErrorEnabled(m)) {
2739 logger.error(m, d.get(a1, a2, a3, a4, a5, a6).toString(locale));
2740 }
2741 }
2742
2743 /**
2744 * Logs an error message with an accompanying exception.
2745 *
2746 * @param <T1>
2747 * The type of the first message argument.
2748 * @param <T2>
2749 * The type of the second message argument.
2750 * @param <T3>
2751 * The type of the third message argument.
2752 * @param <T4>
2753 * The type of the fourth message argument.
2754 * @param <T5>
2755 * The type of the fifth message argument.
2756 * @param <T6>
2757 * The type of the sixth message argument.
2758 * @param m
2759 * The marker information associated with this log message.
2760 * @param d
2761 * The message descriptor.
2762 * @param a1
2763 * The first message argument.
2764 * @param a2
2765 * The second message argument.
2766 * @param a3
2767 * The third message argument.
2768 * @param a4
2769 * The fourth message argument.
2770 * @param a5
2771 * The fifth message argument.
2772 * @param a6
2773 * The sixth message argument.
2774 * @param t
2775 * The throwable to log.
2776 * @see org.slf4j.Logger#error(String, Throwable)
2777 */
2778 public <T1, T2, T3, T4, T5, T6> void error(final Marker m,
2779 final Arg6<T1, T2, T3, T4, T5, T6> d, final T1 a1, final T2 a2, final T3 a3,
2780 final T4 a4, final T5 a5, final T6 a6, final Throwable t) {
2781 if (logger.isErrorEnabled(m)) {
2782 logger.error(m, d.get(a1, a2, a3, a4, a5, a6).toString(locale), t);
2783 }
2784 }
2785
2786 /**
2787 * Logs an error message.
2788 *
2789 * @param <T1>
2790 * The type of the first message argument.
2791 * @param <T2>
2792 * The type of the second message argument.
2793 * @param <T3>
2794 * The type of the third message argument.
2795 * @param <T4>
2796 * The type of the fourth message argument.
2797 * @param <T5>
2798 * The type of the fifth message argument.
2799 * @param <T6>
2800 * The type of the sixth message argument.
2801 * @param <T7>
2802 * The type of the seventh message argument.
2803 * @param m
2804 * The marker information associated with this log message.
2805 * @param d
2806 * The message descriptor.
2807 * @param a1
2808 * The first message argument.
2809 * @param a2
2810 * The second message argument.
2811 * @param a3
2812 * The third message argument.
2813 * @param a4
2814 * The fourth message argument.
2815 * @param a5
2816 * The fifth message argument.
2817 * @param a6
2818 * The sixth message argument.
2819 * @param a7
2820 * The seventh message argument.
2821 * @see org.slf4j.Logger#error(String)
2822 */
2823 public <T1, T2, T3, T4, T5, T6, T7> void error(final Marker m,
2824 final Arg7<T1, T2, T3, T4, T5, T6, T7> d, final T1 a1, final T2 a2, final T3 a3,
2825 final T4 a4, final T5 a5, final T6 a6, final T7 a7) {
2826 if (logger.isErrorEnabled(m)) {
2827 logger.error(m, d.get(a1, a2, a3, a4, a5, a6, a7).toString(locale));
2828 }
2829 }
2830
2831 /**
2832 * Logs an error message with an accompanying exception.
2833 *
2834 * @param <T1>
2835 * The type of the first message argument.
2836 * @param <T2>
2837 * The type of the second message argument.
2838 * @param <T3>
2839 * The type of the third message argument.
2840 * @param <T4>
2841 * The type of the fourth message argument.
2842 * @param <T5>
2843 * The type of the fifth message argument.
2844 * @param <T6>
2845 * The type of the sixth message argument.
2846 * @param <T7>
2847 * The type of the seventh message argument.
2848 * @param m
2849 * The marker information associated with this log message.
2850 * @param d
2851 * The message descriptor.
2852 * @param a1
2853 * The first message argument.
2854 * @param a2
2855 * The second message argument.
2856 * @param a3
2857 * The third message argument.
2858 * @param a4
2859 * The fourth message argument.
2860 * @param a5
2861 * The fifth message argument.
2862 * @param a6
2863 * The sixth message argument.
2864 * @param a7
2865 * The seventh message argument.
2866 * @param t
2867 * The throwable to log.
2868 * @see org.slf4j.Logger#error(String, Throwable)
2869 */
2870 public <T1, T2, T3, T4, T5, T6, T7> void error(final Marker m,
2871 final Arg7<T1, T2, T3, T4, T5, T6, T7> d, final T1 a1, final T2 a2, final T3 a3,
2872 final T4 a4, final T5 a5, final T6 a6, final T7 a7, final Throwable t) {
2873 if (logger.isErrorEnabled(m)) {
2874 logger.error(m, d.get(a1, a2, a3, a4, a5, a6, a7).toString(locale), t);
2875 }
2876 }
2877
2878 /**
2879 * Logs an error message.
2880 *
2881 * @param <T1>
2882 * The type of the first message argument.
2883 * @param <T2>
2884 * The type of the second message argument.
2885 * @param <T3>
2886 * The type of the third message argument.
2887 * @param <T4>
2888 * The type of the fourth message argument.
2889 * @param <T5>
2890 * The type of the fifth message argument.
2891 * @param <T6>
2892 * The type of the sixth message argument.
2893 * @param <T7>
2894 * The type of the seventh message argument.
2895 * @param <T8>
2896 * The type of the eighth message argument.
2897 * @param m
2898 * The marker information associated with this log message.
2899 * @param d
2900 * The message descriptor.
2901 * @param a1
2902 * The first message argument.
2903 * @param a2
2904 * The second message argument.
2905 * @param a3
2906 * The third message argument.
2907 * @param a4
2908 * The fourth message argument.
2909 * @param a5
2910 * The fifth message argument.
2911 * @param a6
2912 * The sixth message argument.
2913 * @param a7
2914 * The seventh message argument.
2915 * @param a8
2916 * The eighth message argument.
2917 * @see org.slf4j.Logger#error(String)
2918 */
2919 public <T1, T2, T3, T4, T5, T6, T7, T8> void error(final Marker m,
2920 final Arg8<T1, T2, T3, T4, T5, T6, T7, T8> d, final T1 a1, final T2 a2, final T3 a3,
2921 final T4 a4, final T5 a5, final T6 a6, final T7 a7, final T8 a8) {
2922 if (logger.isErrorEnabled(m)) {
2923 logger.error(m, d.get(a1, a2, a3, a4, a5, a6, a7, a8).toString(locale));
2924 }
2925 }
2926
2927 /**
2928 * Logs an error message with an accompanying exception.
2929 *
2930 * @param <T1>
2931 * The type of the first message argument.
2932 * @param <T2>
2933 * The type of the second message argument.
2934 * @param <T3>
2935 * The type of the third message argument.
2936 * @param <T4>
2937 * The type of the fourth message argument.
2938 * @param <T5>
2939 * The type of the fifth message argument.
2940 * @param <T6>
2941 * The type of the sixth message argument.
2942 * @param <T7>
2943 * The type of the seventh message argument.
2944 * @param <T8>
2945 * The type of the eighth message argument.
2946 * @param m
2947 * The marker information associated with this log message.
2948 * @param d
2949 * The message descriptor.
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 * @param a5
2959 * The fifth message argument.
2960 * @param a6
2961 * The sixth message argument.
2962 * @param a7
2963 * The seventh message argument.
2964 * @param a8
2965 * The eighth message argument.
2966 * @param t
2967 * The throwable to log.
2968 * @see org.slf4j.Logger#error(String, Throwable)
2969 */
2970 public <T1, T2, T3, T4, T5, T6, T7, T8> void error(final Marker m,
2971 final Arg8<T1, T2, T3, T4, T5, T6, T7, T8> d, final T1 a1, final T2 a2, final T3 a3,
2972 final T4 a4, final T5 a5, final T6 a6, final T7 a7, final T8 a8, final Throwable t) {
2973 if (logger.isErrorEnabled(m)) {
2974 logger.error(m, d.get(a1, a2, a3, a4, a5, a6, a7, a8).toString(locale), t);
2975 }
2976 }
2977
2978 /**
2979 * Logs an error message.
2980 *
2981 * @param <T1>
2982 * The type of the first message argument.
2983 * @param <T2>
2984 * The type of the second message argument.
2985 * @param <T3>
2986 * The type of the third message argument.
2987 * @param <T4>
2988 * The type of the fourth message argument.
2989 * @param <T5>
2990 * The type of the fifth message argument.
2991 * @param <T6>
2992 * The type of the sixth message argument.
2993 * @param <T7>
2994 * The type of the seventh message argument.
2995 * @param <T8>
2996 * The type of the eighth message argument.
2997 * @param <T9>
2998 * The type of the ninth message argument.
2999 * @param m
3000 * The marker information associated with this log message.
3001 * @param d
3002 * The message descriptor.
3003 * @param a1
3004 * The first message argument.
3005 * @param a2
3006 * The second message argument.
3007 * @param a3
3008 * The third message argument.
3009 * @param a4
3010 * The fourth message argument.
3011 * @param a5
3012 * The fifth message argument.
3013 * @param a6
3014 * The sixth message argument.
3015 * @param a7
3016 * The seventh message argument.
3017 * @param a8
3018 * The eighth message argument.
3019 * @param a9
3020 * The ninth message argument.
3021 * @see org.slf4j.Logger#error(String)
3022 */
3023 public <T1, T2, T3, T4, T5, T6, T7, T8, T9> void error(final Marker m,
3024 final Arg9<T1, T2, T3, T4, T5, T6, T7, T8, T9> d, final T1 a1, final T2 a2,
3025 final T3 a3, final T4 a4, final T5 a5, final T6 a6, final T7 a7, final T8 a8,
3026 final T9 a9) {
3027 if (logger.isErrorEnabled(m)) {
3028 logger.error(m, d.get(a1, a2, a3, a4, a5, a6, a7, a8, a9).toString(locale));
3029 }
3030 }
3031
3032 /**
3033 * Logs an error message with an accompanying exception.
3034 *
3035 * @param <T1>
3036 * The type of the first message argument.
3037 * @param <T2>
3038 * The type of the second message argument.
3039 * @param <T3>
3040 * The type of the third message argument.
3041 * @param <T4>
3042 * The type of the fourth message argument.
3043 * @param <T5>
3044 * The type of the fifth message argument.
3045 * @param <T6>
3046 * The type of the sixth message argument.
3047 * @param <T7>
3048 * The type of the seventh message argument.
3049 * @param <T8>
3050 * The type of the eighth message argument.
3051 * @param <T9>
3052 * The type of the ninth message argument.
3053 * @param m
3054 * The marker information associated with this log message.
3055 * @param d
3056 * The message descriptor.
3057 * @param a1
3058 * The first message argument.
3059 * @param a2
3060 * The second message argument.
3061 * @param a3
3062 * The third message argument.
3063 * @param a4
3064 * The fourth message argument.
3065 * @param a5
3066 * The fifth message argument.
3067 * @param a6
3068 * The sixth message argument.
3069 * @param a7
3070 * The seventh message argument.
3071 * @param a8
3072 * The eighth message argument.
3073 * @param a9
3074 * The ninth message argument.
3075 * @param t
3076 * The throwable to log.
3077 * @see org.slf4j.Logger#error(String, Throwable)
3078 */
3079 public <T1, T2, T3, T4, T5, T6, T7, T8, T9> void error(final Marker m,
3080 final Arg9<T1, T2, T3, T4, T5, T6, T7, T8, T9> d, final T1 a1, final T2 a2,
3081 final T3 a3, final T4 a4, final T5 a5, final T6 a6, final T7 a7, final T8 a8,
3082 final T9 a9, final Throwable t) {
3083 if (logger.isErrorEnabled(m)) {
3084 logger.error(m, d.get(a1, a2, a3, a4, a5, a6, a7, a8, a9).toString(locale), t);
3085 }
3086 }
3087
3088 /**
3089 * Logs an error message.
3090 *
3091 * @param m
3092 * The marker information associated with this log message.
3093 * @param d
3094 * The message descriptor.
3095 * @param args
3096 * The message arguments.
3097 * @see org.slf4j.Logger#error(String)
3098 */
3099 public void error(final Marker m, final ArgN d, final Object... args) {
3100 if (logger.isErrorEnabled(m)) {
3101 logger.error(m, d.get(args).toString(locale));
3102 }
3103 }
3104
3105 /**
3106 * Logs an error message with an accompanying exception.
3107 *
3108 * @param m
3109 * The marker information associated with this log message.
3110 * @param d
3111 * The message descriptor.
3112 * @param t
3113 * The throwable to log.
3114 * @param args
3115 * The message arguments.
3116 * @see org.slf4j.Logger#error(String, Throwable)
3117 */
3118 public void error(final Marker m, final ArgN d, final Throwable t, final Object... args) {
3119 if (logger.isErrorEnabled(m)) {
3120 logger.error(m, d.get(args).toString(locale), t);
3121 }
3122 }
3123
3124 /**
3125 * Returns the locale to which this logger will localize all log messages.
3126 *
3127 * @return The locale to which this logger will localize all log messages.
3128 */
3129 public Locale getLocale() {
3130 return locale;
3131 }
3132
3133 /**
3134 * Returns the underlying SLF4J {@code Logger} wrapped by this logger.
3135 *
3136 * @return The underlying SLF4J {@code Logger} wrapped by this logger.
3137 */
3138 public Logger getLogger() {
3139 return logger;
3140 }
3141
3142 /**
3143 * Returns the name of this logger.
3144 *
3145 * @return The name of this logger.
3146 * @see org.slf4j.Logger#getName()
3147 */
3148 public String getName() {
3149 return logger.getName();
3150 }
3151
3152 /**
3153 * Logs an info message.
3154 *
3155 * @param d
3156 * The message descriptor.
3157 * @see org.slf4j.Logger#info(String)
3158 */
3159 public void info(final Arg0 d) {
3160 if (logger.isInfoEnabled()) {
3161 final LocalizableMessage message = d.get();
3162 logger.info(new LocalizedMarker(message), message.toString(locale));
3163 }
3164 }
3165
3166 /**
3167 * Logs an info message with an accompanying exception.
3168 *
3169 * @param d
3170 * The message descriptor.
3171 * @param t
3172 * The throwable to log.
3173 * @see org.slf4j.Logger#info(String, Throwable)
3174 */
3175 public void info(final Arg0 d, final Throwable t) {
3176 if (logger.isInfoEnabled()) {
3177 final LocalizableMessage message = d.get();
3178 logger.info(new LocalizedMarker(message), message.toString(locale), t);
3179 }
3180 }
3181
3182 /**
3183 * Logs an info message.
3184 *
3185 * @param <T1>
3186 * The type of the first message argument.
3187 * @param d
3188 * The message descriptor.
3189 * @param a1
3190 * The first message argument.
3191 * @see org.slf4j.Logger#info(String)
3192 */
3193 public <T1> void info(final Arg1<T1> d, final T1 a1) {
3194 if (logger.isInfoEnabled()) {
3195 final LocalizableMessage message = d.get(a1);
3196 logger.info(new LocalizedMarker(message), message.toString(locale));
3197 }
3198 }
3199
3200 /**
3201 * Logs an info message with an accompanying exception.
3202 *
3203 * @param <T1>
3204 * The type of the first message argument.
3205 * @param d
3206 * The message descriptor.
3207 * @param a1
3208 * The first message argument.
3209 * @param t
3210 * The throwable to log.
3211 * @see org.slf4j.Logger#info(String, Throwable)
3212 */
3213 public <T1> void info(final Arg1<T1> d, final T1 a1, final Throwable t) {
3214 if (logger.isInfoEnabled()) {
3215 final LocalizableMessage message = d.get(a1);
3216 logger.info(new LocalizedMarker(message), message.toString(locale), t);
3217 }
3218 }
3219
3220 /**
3221 * Logs an info message.
3222 *
3223 * @param <T1>
3224 * The type of the first message argument.
3225 * @param <T2>
3226 * The type of the second message argument.
3227 * @param d
3228 * The message descriptor.
3229 * @param a1
3230 * The first message argument.
3231 * @param a2
3232 * The second message argument.
3233 * @see org.slf4j.Logger#info(String)
3234 */
3235 public <T1, T2> void info(final Arg2<T1, T2> d, final T1 a1, final T2 a2) {
3236 if (logger.isInfoEnabled()) {
3237 final LocalizableMessage message = d.get(a1, a2);
3238 logger.info(new LocalizedMarker(message), message.toString(locale));
3239 }
3240 }
3241
3242 /**
3243 * Logs an info message with an accompanying exception.
3244 *
3245 * @param <T1>
3246 * The type of the first message argument.
3247 * @param <T2>
3248 * The type of the second message argument.
3249 * @param d
3250 * The message descriptor.
3251 * @param a1
3252 * The first message argument.
3253 * @param a2
3254 * The second message argument.
3255 * @param t
3256 * The throwable to log.
3257 * @see org.slf4j.Logger#info(String, Throwable)
3258 */
3259 public <T1, T2> void info(final Arg2<T1, T2> d, final T1 a1, final T2 a2, final Throwable t) {
3260 if (logger.isInfoEnabled()) {
3261 final LocalizableMessage message = d.get(a1, a2);
3262 logger.info(new LocalizedMarker(message), message.toString(locale), t);
3263 }
3264 }
3265
3266 /**
3267 * Logs an info message.
3268 *
3269 * @param <T1>
3270 * The type of the first message argument.
3271 * @param <T2>
3272 * The type of the second message argument.
3273 * @param <T3>
3274 * The type of the third message argument.
3275 * @param d
3276 * The message descriptor.
3277 * @param a1
3278 * The first message argument.
3279 * @param a2
3280 * The second message argument.
3281 * @param a3
3282 * The third message argument.
3283 * @see org.slf4j.Logger#info(String)
3284 */
3285 public <T1, T2, T3> void info(final Arg3<T1, T2, T3> d, final T1 a1, final T2 a2, final T3 a3) {
3286 if (logger.isInfoEnabled()) {
3287 final LocalizableMessage message = d.get(a1, a2, a3);
3288 logger.info(new LocalizedMarker(message), message.toString(locale));
3289 }
3290 }
3291
3292 /**
3293 * Logs an info message with an accompanying exception.
3294 *
3295 * @param <T1>
3296 * The type of the first message argument.
3297 * @param <T2>
3298 * The type of the second message argument.
3299 * @param <T3>
3300 * The type of the third message argument.
3301 * @param d
3302 * The message descriptor.
3303 * @param a1
3304 * The first message argument.
3305 * @param a2
3306 * The second message argument.
3307 * @param a3
3308 * The third message argument.
3309 * @param t
3310 * The throwable to log.
3311 * @see org.slf4j.Logger#info(String, Throwable)
3312 */
3313 public <T1, T2, T3> void info(final Arg3<T1, T2, T3> d, final T1 a1, final T2 a2, final T3 a3,
3314 final Throwable t) {
3315 if (logger.isInfoEnabled()) {
3316 final LocalizableMessage message = d.get(a1, a2, a3);
3317 logger.info(new LocalizedMarker(message), message.toString(locale), t);
3318 }
3319 }
3320
3321 /**
3322 * Logs an info message.
3323 *
3324 * @param <T1>
3325 * The type of the first message argument.
3326 * @param <T2>
3327 * The type of the second message argument.
3328 * @param <T3>
3329 * The type of the third message argument.
3330 * @param <T4>
3331 * The type of the fourth message argument.
3332 * @param d
3333 * The message descriptor.
3334 * @param a1
3335 * The first message argument.
3336 * @param a2
3337 * The second message argument.
3338 * @param a3
3339 * The third message argument.
3340 * @param a4
3341 * The fourth message argument.
3342 * @see org.slf4j.Logger#info(String)
3343 */
3344 public <T1, T2, T3, T4> void info(final Arg4<T1, T2, T3, T4> d, final T1 a1, final T2 a2,
3345 final T3 a3, final T4 a4) {
3346 if (logger.isInfoEnabled()) {
3347 final LocalizableMessage message = d.get(a1, a2, a3, a4);
3348 logger.info(new LocalizedMarker(message), message.toString(locale));
3349 }
3350 }
3351
3352 /**
3353 * Logs an info message with an accompanying exception.
3354 *
3355 * @param <T1>
3356 * The type of the first message argument.
3357 * @param <T2>
3358 * The type of the second message argument.
3359 * @param <T3>
3360 * The type of the third message argument.
3361 * @param <T4>
3362 * The type of the fourth message argument.
3363 * @param d
3364 * The message descriptor.
3365 * @param a1
3366 * The first message argument.
3367 * @param a2
3368 * The second message argument.
3369 * @param a3
3370 * The third message argument.
3371 * @param a4
3372 * The fourth message argument.
3373 * @param t
3374 * The throwable to log.
3375 * @see org.slf4j.Logger#info(String, Throwable)
3376 */
3377 public <T1, T2, T3, T4> void info(final Arg4<T1, T2, T3, T4> d, final T1 a1, final T2 a2,
3378 final T3 a3, final T4 a4, final Throwable t) {
3379 if (logger.isInfoEnabled()) {
3380 final LocalizableMessage message = d.get(a1, a2, a3, a4);
3381 logger.info(new LocalizedMarker(message), message.toString(locale), t);
3382 }
3383 }
3384
3385 /**
3386 * Logs an info message.
3387 *
3388 * @param <T1>
3389 * The type of the first message argument.
3390 * @param <T2>
3391 * The type of the second message argument.
3392 * @param <T3>
3393 * The type of the third message argument.
3394 * @param <T4>
3395 * The type of the fourth message argument.
3396 * @param <T5>
3397 * The type of the fifth message argument.
3398 * @param d
3399 * The message descriptor.
3400 * @param a1
3401 * The first message argument.
3402 * @param a2
3403 * The second message argument.
3404 * @param a3
3405 * The third message argument.
3406 * @param a4
3407 * The fourth message argument.
3408 * @param a5
3409 * The fifth message argument.
3410 * @see org.slf4j.Logger#info(String)
3411 */
3412 public <T1, T2, T3, T4, T5> void info(final Arg5<T1, T2, T3, T4, T5> d, final T1 a1,
3413 final T2 a2, final T3 a3, final T4 a4, final T5 a5) {
3414 if (logger.isInfoEnabled()) {
3415 final LocalizableMessage message = d.get(a1, a2, a3, a4, a5);
3416 logger.info(new LocalizedMarker(message), message.toString(locale));
3417 }
3418 }
3419
3420 /**
3421 * Logs an info message with an accompanying exception.
3422 *
3423 * @param <T1>
3424 * The type of the first message argument.
3425 * @param <T2>
3426 * The type of the second message argument.
3427 * @param <T3>
3428 * The type of the third message argument.
3429 * @param <T4>
3430 * The type of the fourth message argument.
3431 * @param <T5>
3432 * The type of the fifth message argument.
3433 * @param d
3434 * The message descriptor.
3435 * @param a1
3436 * The first message argument.
3437 * @param a2
3438 * The second message argument.
3439 * @param a3
3440 * The third message argument.
3441 * @param a4
3442 * The fourth message argument.
3443 * @param a5
3444 * The fifth message argument.
3445 * @param t
3446 * The throwable to log.
3447 * @see org.slf4j.Logger#info(String, Throwable)
3448 */
3449 public <T1, T2, T3, T4, T5> void info(final Arg5<T1, T2, T3, T4, T5> d, final T1 a1,
3450 final T2 a2, final T3 a3, final T4 a4, final T5 a5, final Throwable t) {
3451 if (logger.isInfoEnabled()) {
3452 final LocalizableMessage message = d.get(a1, a2, a3, a4, a5);
3453 logger.info(new LocalizedMarker(message), message.toString(locale), t);
3454 }
3455 }
3456
3457 /**
3458 * Logs an info message.
3459 *
3460 * @param <T1>
3461 * The type of the first message argument.
3462 * @param <T2>
3463 * The type of the second message argument.
3464 * @param <T3>
3465 * The type of the third message argument.
3466 * @param <T4>
3467 * The type of the fourth message argument.
3468 * @param <T5>
3469 * The type of the fifth message argument.
3470 * @param <T6>
3471 * The type of the sixth message argument.
3472 * @param d
3473 * The message descriptor.
3474 * @param a1
3475 * The first message argument.
3476 * @param a2
3477 * The second message argument.
3478 * @param a3
3479 * The third message argument.
3480 * @param a4
3481 * The fourth message argument.
3482 * @param a5
3483 * The fifth message argument.
3484 * @param a6
3485 * The sixth message argument.
3486 * @see org.slf4j.Logger#info(String)
3487 */
3488 public <T1, T2, T3, T4, T5, T6> void info(final Arg6<T1, T2, T3, T4, T5, T6> d, final T1 a1,
3489 final T2 a2, final T3 a3, final T4 a4, final T5 a5, final T6 a6) {
3490 if (logger.isInfoEnabled()) {
3491 final LocalizableMessage message = d.get(a1, a2, a3, a4, a5, a6);
3492 logger.info(new LocalizedMarker(message), message.toString(locale));
3493 }
3494 }
3495
3496 /**
3497 * Logs an info message with an accompanying exception.
3498 *
3499 * @param <T1>
3500 * The type of the first message argument.
3501 * @param <T2>
3502 * The type of the second message argument.
3503 * @param <T3>
3504 * The type of the third message argument.
3505 * @param <T4>
3506 * The type of the fourth message argument.
3507 * @param <T5>
3508 * The type of the fifth message argument.
3509 * @param <T6>
3510 * The type of the sixth message argument.
3511 * @param d
3512 * The message descriptor.
3513 * @param a1
3514 * The first message argument.
3515 * @param a2
3516 * The second message argument.
3517 * @param a3
3518 * The third message argument.
3519 * @param a4
3520 * The fourth message argument.
3521 * @param a5
3522 * The fifth message argument.
3523 * @param a6
3524 * The sixth message argument.
3525 * @param t
3526 * The throwable to log.
3527 * @see org.slf4j.Logger#info(String, Throwable)
3528 */
3529 public <T1, T2, T3, T4, T5, T6> void info(final Arg6<T1, T2, T3, T4, T5, T6> d, final T1 a1,
3530 final T2 a2, final T3 a3, final T4 a4, final T5 a5, final T6 a6, final Throwable t) {
3531 if (logger.isInfoEnabled()) {
3532 final LocalizableMessage message = d.get(a1, a2, a3, a4, a5, a6);
3533 logger.info(new LocalizedMarker(message), message.toString(locale), t);
3534 }
3535 }
3536
3537 /**
3538 * Logs an info message.
3539 *
3540 * @param <T1>
3541 * The type of the first message argument.
3542 * @param <T2>
3543 * The type of the second message argument.
3544 * @param <T3>
3545 * The type of the third message argument.
3546 * @param <T4>
3547 * The type of the fourth message argument.
3548 * @param <T5>
3549 * The type of the fifth message argument.
3550 * @param <T6>
3551 * The type of the sixth message argument.
3552 * @param <T7>
3553 * The type of the seventh message argument.
3554 * @param d
3555 * The message descriptor.
3556 * @param a1
3557 * The first message argument.
3558 * @param a2
3559 * The second message argument.
3560 * @param a3
3561 * The third message argument.
3562 * @param a4
3563 * The fourth message argument.
3564 * @param a5
3565 * The fifth message argument.
3566 * @param a6
3567 * The sixth message argument.
3568 * @param a7
3569 * The seventh message argument.
3570 * @see org.slf4j.Logger#info(String)
3571 */
3572 public <T1, T2, T3, T4, T5, T6, T7> void info(final Arg7<T1, T2, T3, T4, T5, T6, T7> d,
3573 final T1 a1, final T2 a2, final T3 a3, final T4 a4, final T5 a5, final T6 a6,
3574 final T7 a7) {
3575 if (logger.isInfoEnabled()) {
3576 final LocalizableMessage message = d.get(a1, a2, a3, a4, a5, a6, a7);
3577 logger.info(new LocalizedMarker(message), message.toString(locale));
3578 }
3579 }
3580
3581 /**
3582 * Logs an info message with an accompanying exception.
3583 *
3584 * @param <T1>
3585 * The type of the first message argument.
3586 * @param <T2>
3587 * The type of the second message argument.
3588 * @param <T3>
3589 * The type of the third message argument.
3590 * @param <T4>
3591 * The type of the fourth message argument.
3592 * @param <T5>
3593 * The type of the fifth message argument.
3594 * @param <T6>
3595 * The type of the sixth message argument.
3596 * @param <T7>
3597 * The type of the seventh message argument.
3598 * @param d
3599 * The message descriptor.
3600 * @param a1
3601 * The first message argument.
3602 * @param a2
3603 * The second message argument.
3604 * @param a3
3605 * The third message argument.
3606 * @param a4
3607 * The fourth message argument.
3608 * @param a5
3609 * The fifth message argument.
3610 * @param a6
3611 * The sixth message argument.
3612 * @param a7
3613 * The seventh message argument.
3614 * @param t
3615 * The throwable to log.
3616 * @see org.slf4j.Logger#info(String, Throwable)
3617 */
3618 public <T1, T2, T3, T4, T5, T6, T7> void info(final Arg7<T1, T2, T3, T4, T5, T6, T7> d,
3619 final T1 a1, final T2 a2, final T3 a3, final T4 a4, final T5 a5, final T6 a6,
3620 final T7 a7, final Throwable t) {
3621 if (logger.isInfoEnabled()) {
3622 final LocalizableMessage message = d.get(a1, a2, a3, a4, a5, a6, a7);
3623 logger.info(new LocalizedMarker(message), message.toString(locale), t);
3624 }
3625 }
3626
3627 /**
3628 * Logs an info message.
3629 *
3630 * @param <T1>
3631 * The type of the first message argument.
3632 * @param <T2>
3633 * The type of the second message argument.
3634 * @param <T3>
3635 * The type of the third message argument.
3636 * @param <T4>
3637 * The type of the fourth message argument.
3638 * @param <T5>
3639 * The type of the fifth message argument.
3640 * @param <T6>
3641 * The type of the sixth message argument.
3642 * @param <T7>
3643 * The type of the seventh message argument.
3644 * @param <T8>
3645 * The type of the eighth message argument.
3646 * @param d
3647 * The message descriptor.
3648 * @param a1
3649 * The first message argument.
3650 * @param a2
3651 * The second message argument.
3652 * @param a3
3653 * The third message argument.
3654 * @param a4
3655 * The fourth message argument.
3656 * @param a5
3657 * The fifth message argument.
3658 * @param a6
3659 * The sixth message argument.
3660 * @param a7
3661 * The seventh message argument.
3662 * @param a8
3663 * The eighth message argument.
3664 * @see org.slf4j.Logger#info(String)
3665 */
3666 public <T1, T2, T3, T4, T5, T6, T7, T8> void info(final Arg8<T1, T2, T3, T4, T5, T6, T7, T8> d,
3667 final T1 a1, final T2 a2, final T3 a3, final T4 a4, final T5 a5, final T6 a6,
3668 final T7 a7, final T8 a8) {
3669 if (logger.isInfoEnabled()) {
3670 final LocalizableMessage message = d.get(a1, a2, a3, a4, a5, a6, a7, a8);
3671 logger.info(new LocalizedMarker(message), message.toString(locale));
3672 }
3673 }
3674
3675 /**
3676 * Logs an info message with an accompanying exception.
3677 *
3678 * @param <T1>
3679 * The type of the first message argument.
3680 * @param <T2>
3681 * The type of the second message argument.
3682 * @param <T3>
3683 * The type of the third message argument.
3684 * @param <T4>
3685 * The type of the fourth message argument.
3686 * @param <T5>
3687 * The type of the fifth message argument.
3688 * @param <T6>
3689 * The type of the sixth message argument.
3690 * @param <T7>
3691 * The type of the seventh message argument.
3692 * @param <T8>
3693 * The type of the eighth message argument.
3694 * @param d
3695 * The message descriptor.
3696 * @param a1
3697 * The first message argument.
3698 * @param a2
3699 * The second message argument.
3700 * @param a3
3701 * The third message argument.
3702 * @param a4
3703 * The fourth message argument.
3704 * @param a5
3705 * The fifth message argument.
3706 * @param a6
3707 * The sixth message argument.
3708 * @param a7
3709 * The seventh message argument.
3710 * @param a8
3711 * The eighth message argument.
3712 * @param t
3713 * The throwable to log.
3714 * @see org.slf4j.Logger#info(String, Throwable)
3715 */
3716 public <T1, T2, T3, T4, T5, T6, T7, T8> void info(final Arg8<T1, T2, T3, T4, T5, T6, T7, T8> d,
3717 final T1 a1, final T2 a2, final T3 a3, final T4 a4, final T5 a5, final T6 a6,
3718 final T7 a7, final T8 a8, final Throwable t) {
3719 if (logger.isInfoEnabled()) {
3720 final LocalizableMessage message = d.get(a1, a2, a3, a4, a5, a6, a7, a8);
3721 logger.info(new LocalizedMarker(message), message.toString(locale), t);
3722 }
3723 }
3724
3725 /**
3726 * Logs an info message.
3727 *
3728 * @param <T1>
3729 * The type of the first message argument.
3730 * @param <T2>
3731 * The type of the second message argument.
3732 * @param <T3>
3733 * The type of the third message argument.
3734 * @param <T4>
3735 * The type of the fourth message argument.
3736 * @param <T5>
3737 * The type of the fifth message argument.
3738 * @param <T6>
3739 * The type of the sixth message argument.
3740 * @param <T7>
3741 * The type of the seventh message argument.
3742 * @param <T8>
3743 * The type of the eighth message argument.
3744 * @param <T9>
3745 * The type of the ninth message argument.
3746 * @param d
3747 * The message descriptor.
3748 * @param a1
3749 * The first message argument.
3750 * @param a2
3751 * The second message argument.
3752 * @param a3
3753 * The third message argument.
3754 * @param a4
3755 * The fourth message argument.
3756 * @param a5
3757 * The fifth message argument.
3758 * @param a6
3759 * The sixth message argument.
3760 * @param a7
3761 * The seventh message argument.
3762 * @param a8
3763 * The eighth message argument.
3764 * @param a9
3765 * The ninth message argument.
3766 * @see org.slf4j.Logger#info(String)
3767 */
3768 public <T1, T2, T3, T4, T5, T6, T7, T8, T9> void info(
3769 final Arg9<T1, T2, T3, T4, T5, T6, T7, T8, T9> d, final T1 a1, final T2 a2,
3770 final T3 a3, final T4 a4, final T5 a5, final T6 a6, final T7 a7, final T8 a8,
3771 final T9 a9) {
3772 if (logger.isInfoEnabled()) {
3773 final LocalizableMessage message = d.get(a1, a2, a3, a4, a5, a6, a7, a8, a9);
3774 logger.info(new LocalizedMarker(message), message.toString(locale));
3775 }
3776 }
3777
3778 /**
3779 * Logs an info message with an accompanying exception.
3780 *
3781 * @param <T1>
3782 * The type of the first message argument.
3783 * @param <T2>
3784 * The type of the second message argument.
3785 * @param <T3>
3786 * The type of the third message argument.
3787 * @param <T4>
3788 * The type of the fourth message argument.
3789 * @param <T5>
3790 * The type of the fifth message argument.
3791 * @param <T6>
3792 * The type of the sixth message argument.
3793 * @param <T7>
3794 * The type of the seventh message argument.
3795 * @param <T8>
3796 * The type of the eighth message argument.
3797 * @param <T9>
3798 * The type of the ninth message argument.
3799 * @param d
3800 * The message descriptor.
3801 * @param a1
3802 * The first message argument.
3803 * @param a2
3804 * The second message argument.
3805 * @param a3
3806 * The third message argument.
3807 * @param a4
3808 * The fourth message argument.
3809 * @param a5
3810 * The fifth message argument.
3811 * @param a6
3812 * The sixth message argument.
3813 * @param a7
3814 * The seventh message argument.
3815 * @param a8
3816 * The eighth message argument.
3817 * @param a9
3818 * The ninth message argument.
3819 * @param t
3820 * The throwable to log.
3821 * @see org.slf4j.Logger#info(String, Throwable)
3822 */
3823 public <T1, T2, T3, T4, T5, T6, T7, T8, T9> void info(
3824 final Arg9<T1, T2, T3, T4, T5, T6, T7, T8, T9> d, final T1 a1, final T2 a2,
3825 final T3 a3, final T4 a4, final T5 a5, final T6 a6, final T7 a7, final T8 a8,
3826 final T9 a9, final Throwable t) {
3827 if (logger.isInfoEnabled()) {
3828 final LocalizableMessage message = d.get(a1, a2, a3, a4, a5, a6, a7, a8, a9);
3829 logger.info(new LocalizedMarker(message), message.toString(locale), t);
3830 }
3831 }
3832
3833 /**
3834 * Logs an info message.
3835 *
3836 * @param d
3837 * The message descriptor.
3838 * @param args
3839 * The message arguments.
3840 * @see org.slf4j.Logger#info(String)
3841 */
3842 public void info(final ArgN d, final Object... args) {
3843 if (logger.isInfoEnabled()) {
3844 final LocalizableMessage message = d.get(args);
3845 logger.info(new LocalizedMarker(message), message.toString(locale));
3846 }
3847 }
3848
3849 /**
3850 * Logs an info message with an accompanying exception.
3851 *
3852 * @param d
3853 * The message descriptor.
3854 * @param t
3855 * The throwable to log.
3856 * @param args
3857 * The message arguments.
3858 * @see org.slf4j.Logger#info(String, Throwable)
3859 */
3860 public void info(final ArgN d, final Throwable t, final Object... args) {
3861 if (logger.isInfoEnabled()) {
3862 final LocalizableMessage message = d.get(args);
3863 logger.info(new LocalizedMarker(message), message.toString(locale), t);
3864 }
3865 }
3866
3867 /**
3868 * Logs an info message.
3869 *
3870 * @param m
3871 * The pre-formatted message.
3872 * @see org.slf4j.Logger#info(String)
3873 */
3874 public void info(final LocalizableMessage m) {
3875 if (logger.isInfoEnabled()) {
3876 logger.info(new LocalizedMarker(m), m.toString(locale));
3877 }
3878 }
3879
3880 /**
3881 * Logs an info message with an accompanying exception.
3882 *
3883 * @param m
3884 * The pre-formatted message.
3885 * @param t
3886 * The throwable to log.
3887 * @see org.slf4j.Logger#info(String, Throwable)
3888 */
3889 public void info(final LocalizableMessage m, final Throwable t) {
3890 if (logger.isInfoEnabled()) {
3891 logger.info(new LocalizedMarker(m), m.toString(locale), t);
3892 }
3893 }
3894
3895 /**
3896 * Logs an info message using the provided {@code Marker}.
3897 *
3898 * @param m
3899 * The marker information associated with this log message.
3900 * @param d
3901 * The message descriptor.
3902 * @see org.slf4j.Logger#info(org.slf4j.Marker, String)
3903 */
3904 public void info(final Marker m, final Arg0 d) {
3905 if (logger.isInfoEnabled(m)) {
3906 logger.info(m, d.get().toString(locale));
3907 }
3908 }
3909
3910 /**
3911 * Logs an info message using the provided {@code Marker}.
3912 *
3913 * @param m
3914 * The marker information associated with this log message.
3915 * @param d
3916 * The message descriptor.
3917 * @param t
3918 * The throwable to log.
3919 * @see org.slf4j.Logger#info(org.slf4j.Marker, String)
3920 */
3921 public void info(final Marker m, final Arg0 d, final Throwable t) {
3922 if (logger.isInfoEnabled(m)) {
3923 logger.info(m, d.get().toString(locale), t);
3924 }
3925 }
3926
3927 /**
3928 * Logs an info message.
3929 *
3930 * @param <T1>
3931 * The type of the first message argument.
3932 * @param m
3933 * The marker information associated with this log message.
3934 * @param d
3935 * The message descriptor.
3936 * @param a1
3937 * The first message argument.
3938 * @see org.slf4j.Logger#info(String)
3939 */
3940 public <T1> void info(final Marker m, final Arg1<T1> d, final T1 a1) {
3941 if (logger.isInfoEnabled(m)) {
3942 logger.info(m, d.get(a1).toString(locale));
3943 }
3944 }
3945
3946 /**
3947 * Logs an info message with an accompanying exception.
3948 *
3949 * @param <T1>
3950 * The type of the first message argument.
3951 * @param m
3952 * The marker information associated with this log message.
3953 * @param d
3954 * The message descriptor.
3955 * @param a1
3956 * The first message argument.
3957 * @param t
3958 * The throwable to log.
3959 * @see org.slf4j.Logger#info(String, Throwable)
3960 */
3961 public <T1> void info(final Marker m, final Arg1<T1> d, final T1 a1, final Throwable t) {
3962 if (logger.isInfoEnabled(m)) {
3963 logger.info(m, d.get(a1).toString(locale), t);
3964 }
3965 }
3966
3967 /**
3968 * Logs an info message.
3969 *
3970 * @param <T1>
3971 * The type of the first message argument.
3972 * @param <T2>
3973 * The type of the second message argument.
3974 * @param m
3975 * The marker information associated with this log message.
3976 * @param d
3977 * The message descriptor.
3978 * @param a1
3979 * The first message argument.
3980 * @param a2
3981 * The second message argument.
3982 * @see org.slf4j.Logger#info(String)
3983 */
3984 public <T1, T2> void info(final Marker m, final Arg2<T1, T2> d, final T1 a1, final T2 a2) {
3985 if (logger.isInfoEnabled(m)) {
3986 logger.info(m, d.get(a1, a2).toString(locale));
3987 }
3988 }
3989
3990 /**
3991 * Logs an info message with an accompanying exception.
3992 *
3993 * @param <T1>
3994 * The type of the first message argument.
3995 * @param <T2>
3996 * The type of the second message argument.
3997 * @param m
3998 * The marker information associated with this log message.
3999 * @param d
4000 * The message descriptor.
4001 * @param a1
4002 * The first message argument.
4003 * @param a2
4004 * The second message argument.
4005 * @param t
4006 * The throwable to log.
4007 * @see org.slf4j.Logger#info(String, Throwable)
4008 */
4009 public <T1, T2> void info(final Marker m, final Arg2<T1, T2> d, final T1 a1, final T2 a2,
4010 final Throwable t) {
4011 if (logger.isInfoEnabled(m)) {
4012 logger.info(m, d.get(a1, a2).toString(locale), t);
4013 }
4014 }
4015
4016 /**
4017 * Logs an info message.
4018 *
4019 * @param <T1>
4020 * The type of the first message argument.
4021 * @param <T2>
4022 * The type of the second message argument.
4023 * @param <T3>
4024 * The type of the third message argument.
4025 * @param m
4026 * The marker information associated with this log message.
4027 * @param d
4028 * The message descriptor.
4029 * @param a1
4030 * The first message argument.
4031 * @param a2
4032 * The second message argument.
4033 * @param a3
4034 * The third message argument.
4035 * @see org.slf4j.Logger#info(String)
4036 */
4037 public <T1, T2, T3> void info(final Marker m, final Arg3<T1, T2, T3> d, final T1 a1,
4038 final T2 a2, final T3 a3) {
4039 if (logger.isInfoEnabled(m)) {
4040 logger.info(m, d.get(a1, a2, a3).toString(locale));
4041 }
4042 }
4043
4044 /**
4045 * Logs an info message with an accompanying exception.
4046 *
4047 * @param <T1>
4048 * The type of the first message argument.
4049 * @param <T2>
4050 * The type of the second message argument.
4051 * @param <T3>
4052 * The type of the third message argument.
4053 * @param m
4054 * The marker information associated with this log message.
4055 * @param d
4056 * The message descriptor.
4057 * @param a1
4058 * The first message argument.
4059 * @param a2
4060 * The second message argument.
4061 * @param a3
4062 * The third message argument.
4063 * @param t
4064 * The throwable to log.
4065 * @see org.slf4j.Logger#info(String, Throwable)
4066 */
4067 public <T1, T2, T3> void info(final Marker m, final Arg3<T1, T2, T3> d, final T1 a1,
4068 final T2 a2, final T3 a3, final Throwable t) {
4069 if (logger.isInfoEnabled(m)) {
4070 logger.info(m, d.get(a1, a2, a3).toString(locale), t);
4071 }
4072 }
4073
4074 /**
4075 * Logs an info message.
4076 *
4077 * @param <T1>
4078 * The type of the first message argument.
4079 * @param <T2>
4080 * The type of the second message argument.
4081 * @param <T3>
4082 * The type of the third message argument.
4083 * @param <T4>
4084 * The type of the fourth message argument.
4085 * @param m
4086 * The marker information associated with this log message.
4087 * @param d
4088 * The message descriptor.
4089 * @param a1
4090 * The first message argument.
4091 * @param a2
4092 * The second message argument.
4093 * @param a3
4094 * The third message argument.
4095 * @param a4
4096 * The fourth message argument.
4097 * @see org.slf4j.Logger#info(String)
4098 */
4099 public <T1, T2, T3, T4> void info(final Marker m, final Arg4<T1, T2, T3, T4> d, final T1 a1,
4100 final T2 a2, final T3 a3, final T4 a4) {
4101 if (logger.isInfoEnabled(m)) {
4102 logger.info(m, d.get(a1, a2, a3, a4).toString(locale));
4103 }
4104 }
4105
4106 /**
4107 * Logs an info message with an accompanying exception.
4108 *
4109 * @param <T1>
4110 * The type of the first message argument.
4111 * @param <T2>
4112 * The type of the second message argument.
4113 * @param <T3>
4114 * The type of the third message argument.
4115 * @param <T4>
4116 * The type of the fourth message argument.
4117 * @param m
4118 * The marker information associated with this log message.
4119 * @param d
4120 * The message descriptor.
4121 * @param a1
4122 * The first message argument.
4123 * @param a2
4124 * The second message argument.
4125 * @param a3
4126 * The third message argument.
4127 * @param a4
4128 * The fourth message argument.
4129 * @param t
4130 * The throwable to log.
4131 * @see org.slf4j.Logger#info(String, Throwable)
4132 */
4133 public <T1, T2, T3, T4> void info(final Marker m, final Arg4<T1, T2, T3, T4> d, final T1 a1,
4134 final T2 a2, final T3 a3, final T4 a4, final Throwable t) {
4135 if (logger.isInfoEnabled(m)) {
4136 logger.info(m, d.get(a1, a2, a3, a4).toString(locale), t);
4137 }
4138 }
4139
4140 /**
4141 * Logs an info message.
4142 *
4143 * @param <T1>
4144 * The type of the first message argument.
4145 * @param <T2>
4146 * The type of the second message argument.
4147 * @param <T3>
4148 * The type of the third message argument.
4149 * @param <T4>
4150 * The type of the fourth message argument.
4151 * @param <T5>
4152 * The type of the fifth message argument.
4153 * @param m
4154 * The marker information associated with this log message.
4155 * @param d
4156 * The message descriptor.
4157 * @param a1
4158 * The first message argument.
4159 * @param a2
4160 * The second message argument.
4161 * @param a3
4162 * The third message argument.
4163 * @param a4
4164 * The fourth message argument.
4165 * @param a5
4166 * The fifth message argument.
4167 * @see org.slf4j.Logger#info(String)
4168 */
4169 public <T1, T2, T3, T4, T5> void info(final Marker m, final Arg5<T1, T2, T3, T4, T5> d,
4170 final T1 a1, final T2 a2, final T3 a3, final T4 a4, final T5 a5) {
4171 if (logger.isInfoEnabled(m)) {
4172 logger.info(m, d.get(a1, a2, a3, a4, a5).toString(locale));
4173 }
4174 }
4175
4176 /**
4177 * Logs an info message with an accompanying exception.
4178 *
4179 * @param <T1>
4180 * The type of the first message argument.
4181 * @param <T2>
4182 * The type of the second message argument.
4183 * @param <T3>
4184 * The type of the third message argument.
4185 * @param <T4>
4186 * The type of the fourth message argument.
4187 * @param <T5>
4188 * The type of the fifth message argument.
4189 * @param m
4190 * The marker information associated with this log message.
4191 * @param d
4192 * The message descriptor.
4193 * @param a1
4194 * The first message argument.
4195 * @param a2
4196 * The second message argument.
4197 * @param a3
4198 * The third message argument.
4199 * @param a4
4200 * The fourth message argument.
4201 * @param a5
4202 * The fifth message argument.
4203 * @param t
4204 * The throwable to log.
4205 * @see org.slf4j.Logger#info(String, Throwable)
4206 */
4207 public <T1, T2, T3, T4, T5> void info(final Marker m, final Arg5<T1, T2, T3, T4, T5> d,
4208 final T1 a1, final T2 a2, final T3 a3, final T4 a4, final T5 a5, final Throwable t) {
4209 if (logger.isInfoEnabled(m)) {
4210 logger.info(m, d.get(a1, a2, a3, a4, a5).toString(locale), t);
4211 }
4212 }
4213
4214 /**
4215 * Logs an info message.
4216 *
4217 * @param <T1>
4218 * The type of the first message argument.
4219 * @param <T2>
4220 * The type of the second message argument.
4221 * @param <T3>
4222 * The type of the third message argument.
4223 * @param <T4>
4224 * The type of the fourth message argument.
4225 * @param <T5>
4226 * The type of the fifth message argument.
4227 * @param <T6>
4228 * The type of the sixth message argument.
4229 * @param m
4230 * The marker information associated with this log message.
4231 * @param d
4232 * The message descriptor.
4233 * @param a1
4234 * The first message argument.
4235 * @param a2
4236 * The second message argument.
4237 * @param a3
4238 * The third message argument.
4239 * @param a4
4240 * The fourth message argument.
4241 * @param a5
4242 * The fifth message argument.
4243 * @param a6
4244 * The sixth message argument.
4245 * @see org.slf4j.Logger#info(String)
4246 */
4247 public <T1, T2, T3, T4, T5, T6> void info(final Marker m, final Arg6<T1, T2, T3, T4, T5, T6> d,
4248 final T1 a1, final T2 a2, final T3 a3, final T4 a4, final T5 a5, final T6 a6) {
4249 if (logger.isInfoEnabled(m)) {
4250 logger.info(m, d.get(a1, a2, a3, a4, a5, a6).toString(locale));
4251 }
4252 }
4253
4254 /**
4255 * Logs an info message with an accompanying exception.
4256 *
4257 * @param <T1>
4258 * The type of the first message argument.
4259 * @param <T2>
4260 * The type of the second message argument.
4261 * @param <T3>
4262 * The type of the third message argument.
4263 * @param <T4>
4264 * The type of the fourth message argument.
4265 * @param <T5>
4266 * The type of the fifth message argument.
4267 * @param <T6>
4268 * The type of the sixth message argument.
4269 * @param m
4270 * The marker information associated with this log message.
4271 * @param d
4272 * The message descriptor.
4273 * @param a1
4274 * The first message argument.
4275 * @param a2
4276 * The second message argument.
4277 * @param a3
4278 * The third message argument.
4279 * @param a4
4280 * The fourth message argument.
4281 * @param a5
4282 * The fifth message argument.
4283 * @param a6
4284 * The sixth message argument.
4285 * @param t
4286 * The throwable to log.
4287 * @see org.slf4j.Logger#info(String, Throwable)
4288 */
4289 public <T1, T2, T3, T4, T5, T6> void info(final Marker m, final Arg6<T1, T2, T3, T4, T5, T6> d,
4290 final T1 a1, final T2 a2, final T3 a3, final T4 a4, final T5 a5, final T6 a6,
4291 final Throwable t) {
4292 if (logger.isInfoEnabled(m)) {
4293 logger.info(m, d.get(a1, a2, a3, a4, a5, a6).toString(locale), t);
4294 }
4295 }
4296
4297 /**
4298 * Logs an info message.
4299 *
4300 * @param <T1>
4301 * The type of the first message argument.
4302 * @param <T2>
4303 * The type of the second message argument.
4304 * @param <T3>
4305 * The type of the third message argument.
4306 * @param <T4>
4307 * The type of the fourth message argument.
4308 * @param <T5>
4309 * The type of the fifth message argument.
4310 * @param <T6>
4311 * The type of the sixth message argument.
4312 * @param <T7>
4313 * The type of the seventh message argument.
4314 * @param m
4315 * The marker information associated with this log message.
4316 * @param d
4317 * The message descriptor.
4318 * @param a1
4319 * The first message argument.
4320 * @param a2
4321 * The second message argument.
4322 * @param a3
4323 * The third message argument.
4324 * @param a4
4325 * The fourth message argument.
4326 * @param a5
4327 * The fifth message argument.
4328 * @param a6
4329 * The sixth message argument.
4330 * @param a7
4331 * The seventh message argument.
4332 * @see org.slf4j.Logger#info(String)
4333 */
4334 public <T1, T2, T3, T4, T5, T6, T7> void info(final Marker m,
4335 final Arg7<T1, T2, T3, T4, T5, T6, T7> d, final T1 a1, final T2 a2, final T3 a3,
4336 final T4 a4, final T5 a5, final T6 a6, final T7 a7) {
4337 if (logger.isInfoEnabled(m)) {
4338 logger.info(m, d.get(a1, a2, a3, a4, a5, a6, a7).toString(locale));
4339 }
4340 }
4341
4342 /**
4343 * Logs an info message with an accompanying exception.
4344 *
4345 * @param <T1>
4346 * The type of the first message argument.
4347 * @param <T2>
4348 * The type of the second message argument.
4349 * @param <T3>
4350 * The type of the third message argument.
4351 * @param <T4>
4352 * The type of the fourth message argument.
4353 * @param <T5>
4354 * The type of the fifth message argument.
4355 * @param <T6>
4356 * The type of the sixth message argument.
4357 * @param <T7>
4358 * The type of the seventh message argument.
4359 * @param m
4360 * The marker information associated with this log message.
4361 * @param d
4362 * The message descriptor.
4363 * @param a1
4364 * The first message argument.
4365 * @param a2
4366 * The second message argument.
4367 * @param a3
4368 * The third message argument.
4369 * @param a4
4370 * The fourth message argument.
4371 * @param a5
4372 * The fifth message argument.
4373 * @param a6
4374 * The sixth message argument.
4375 * @param a7
4376 * The seventh message argument.
4377 * @param t
4378 * The throwable to log.
4379 * @see org.slf4j.Logger#info(String, Throwable)
4380 */
4381 public <T1, T2, T3, T4, T5, T6, T7> void info(final Marker m,
4382 final Arg7<T1, T2, T3, T4, T5, T6, T7> d, final T1 a1, final T2 a2, final T3 a3,
4383 final T4 a4, final T5 a5, final T6 a6, final T7 a7, final Throwable t) {
4384 if (logger.isInfoEnabled(m)) {
4385 logger.info(m, d.get(a1, a2, a3, a4, a5, a6, a7).toString(locale), t);
4386 }
4387 }
4388
4389 /**
4390 * Logs an info message.
4391 *
4392 * @param <T1>
4393 * The type of the first message argument.
4394 * @param <T2>
4395 * The type of the second message argument.
4396 * @param <T3>
4397 * The type of the third message argument.
4398 * @param <T4>
4399 * The type of the fourth message argument.
4400 * @param <T5>
4401 * The type of the fifth message argument.
4402 * @param <T6>
4403 * The type of the sixth message argument.
4404 * @param <T7>
4405 * The type of the seventh message argument.
4406 * @param <T8>
4407 * The type of the eighth message argument.
4408 * @param m
4409 * The marker information associated with this log message.
4410 * @param d
4411 * The message descriptor.
4412 * @param a1
4413 * The first message argument.
4414 * @param a2
4415 * The second message argument.
4416 * @param a3
4417 * The third message argument.
4418 * @param a4
4419 * The fourth message argument.
4420 * @param a5
4421 * The fifth message argument.
4422 * @param a6
4423 * The sixth message argument.
4424 * @param a7
4425 * The seventh message argument.
4426 * @param a8
4427 * The eighth message argument.
4428 * @see org.slf4j.Logger#info(String)
4429 */
4430 public <T1, T2, T3, T4, T5, T6, T7, T8> void info(final Marker m,
4431 final Arg8<T1, T2, T3, T4, T5, T6, T7, T8> d, final T1 a1, final T2 a2, final T3 a3,
4432 final T4 a4, final T5 a5, final T6 a6, final T7 a7, final T8 a8) {
4433 if (logger.isInfoEnabled(m)) {
4434 logger.info(m, d.get(a1, a2, a3, a4, a5, a6, a7, a8).toString(locale));
4435 }
4436 }
4437
4438 /**
4439 * Logs an info message with an accompanying exception.
4440 *
4441 * @param <T1>
4442 * The type of the first message argument.
4443 * @param <T2>
4444 * The type of the second message argument.
4445 * @param <T3>
4446 * The type of the third message argument.
4447 * @param <T4>
4448 * The type of the fourth message argument.
4449 * @param <T5>
4450 * The type of the fifth message argument.
4451 * @param <T6>
4452 * The type of the sixth message argument.
4453 * @param <T7>
4454 * The type of the seventh message argument.
4455 * @param <T8>
4456 * The type of the eighth message argument.
4457 * @param m
4458 * The marker information associated with this log message.
4459 * @param d
4460 * The message descriptor.
4461 * @param a1
4462 * The first message argument.
4463 * @param a2
4464 * The second message argument.
4465 * @param a3
4466 * The third message argument.
4467 * @param a4
4468 * The fourth message argument.
4469 * @param a5
4470 * The fifth message argument.
4471 * @param a6
4472 * The sixth message argument.
4473 * @param a7
4474 * The seventh message argument.
4475 * @param a8
4476 * The eighth message argument.
4477 * @param t
4478 * The throwable to log.
4479 * @see org.slf4j.Logger#info(String, Throwable)
4480 */
4481 public <T1, T2, T3, T4, T5, T6, T7, T8> void info(final Marker m,
4482 final Arg8<T1, T2, T3, T4, T5, T6, T7, T8> d, final T1 a1, final T2 a2, final T3 a3,
4483 final T4 a4, final T5 a5, final T6 a6, final T7 a7, final T8 a8, final Throwable t) {
4484 if (logger.isInfoEnabled(m)) {
4485 logger.info(m, d.get(a1, a2, a3, a4, a5, a6, a7, a8).toString(locale), t);
4486 }
4487 }
4488
4489 /**
4490 * Logs an info message.
4491 *
4492 * @param <T1>
4493 * The type of the first message argument.
4494 * @param <T2>
4495 * The type of the second message argument.
4496 * @param <T3>
4497 * The type of the third message argument.
4498 * @param <T4>
4499 * The type of the fourth message argument.
4500 * @param <T5>
4501 * The type of the fifth message argument.
4502 * @param <T6>
4503 * The type of the sixth message argument.
4504 * @param <T7>
4505 * The type of the seventh message argument.
4506 * @param <T8>
4507 * The type of the eighth message argument.
4508 * @param <T9>
4509 * The type of the ninth message argument.
4510 * @param m
4511 * The marker information associated with this log message.
4512 * @param d
4513 * The message descriptor.
4514 * @param a1
4515 * The first message argument.
4516 * @param a2
4517 * The second message argument.
4518 * @param a3
4519 * The third message argument.
4520 * @param a4
4521 * The fourth message argument.
4522 * @param a5
4523 * The fifth message argument.
4524 * @param a6
4525 * The sixth message argument.
4526 * @param a7
4527 * The seventh message argument.
4528 * @param a8
4529 * The eighth message argument.
4530 * @param a9
4531 * The ninth message argument.
4532 * @see org.slf4j.Logger#info(String)
4533 */
4534 public <T1, T2, T3, T4, T5, T6, T7, T8, T9> void info(final Marker m,
4535 final Arg9<T1, T2, T3, T4, T5, T6, T7, T8, T9> d, final T1 a1, final T2 a2,
4536 final T3 a3, final T4 a4, final T5 a5, final T6 a6, final T7 a7, final T8 a8,
4537 final T9 a9) {
4538 if (logger.isInfoEnabled(m)) {
4539 logger.info(m, d.get(a1, a2, a3, a4, a5, a6, a7, a8, a9).toString(locale));
4540 }
4541 }
4542
4543 /**
4544 * Logs an info message with an accompanying exception.
4545 *
4546 * @param <T1>
4547 * The type of the first message argument.
4548 * @param <T2>
4549 * The type of the second message argument.
4550 * @param <T3>
4551 * The type of the third message argument.
4552 * @param <T4>
4553 * The type of the fourth message argument.
4554 * @param <T5>
4555 * The type of the fifth message argument.
4556 * @param <T6>
4557 * The type of the sixth message argument.
4558 * @param <T7>
4559 * The type of the seventh message argument.
4560 * @param <T8>
4561 * The type of the eighth message argument.
4562 * @param <T9>
4563 * The type of the ninth message argument.
4564 * @param m
4565 * The marker information associated with this log message.
4566 * @param d
4567 * The message descriptor.
4568 * @param a1
4569 * The first message argument.
4570 * @param a2
4571 * The second message argument.
4572 * @param a3
4573 * The third message argument.
4574 * @param a4
4575 * The fourth message argument.
4576 * @param a5
4577 * The fifth message argument.
4578 * @param a6
4579 * The sixth message argument.
4580 * @param a7
4581 * The seventh message argument.
4582 * @param a8
4583 * The eighth message argument.
4584 * @param a9
4585 * The ninth message argument.
4586 * @param t
4587 * The throwable to log.
4588 * @see org.slf4j.Logger#info(String, Throwable)
4589 */
4590 public <T1, T2, T3, T4, T5, T6, T7, T8, T9> void info(final Marker m,
4591 final Arg9<T1, T2, T3, T4, T5, T6, T7, T8, T9> d, final T1 a1, final T2 a2,
4592 final T3 a3, final T4 a4, final T5 a5, final T6 a6, final T7 a7, final T8 a8,
4593 final T9 a9, final Throwable t) {
4594 if (logger.isInfoEnabled(m)) {
4595 logger.info(m, d.get(a1, a2, a3, a4, a5, a6, a7, a8, a9).toString(locale), t);
4596 }
4597 }
4598
4599 /**
4600 * Logs an info message.
4601 *
4602 * @param m
4603 * The marker information associated with this log message.
4604 * @param d
4605 * The message descriptor.
4606 * @param args
4607 * The message arguments.
4608 * @see org.slf4j.Logger#info(String)
4609 */
4610 public void info(final Marker m, final ArgN d, final Object... args) {
4611 if (logger.isInfoEnabled(m)) {
4612 logger.info(m, d.get(args).toString(locale));
4613 }
4614 }
4615
4616 /**
4617 * Logs an info message with an accompanying exception.
4618 *
4619 * @param m
4620 * The marker information associated with this log message.
4621 * @param d
4622 * The message descriptor.
4623 * @param t
4624 * The throwable to log.
4625 * @param args
4626 * The message arguments.
4627 * @see org.slf4j.Logger#info(String, Throwable)
4628 */
4629 public void info(final Marker m, final ArgN d, final Throwable t, final Object... args) {
4630 if (logger.isInfoEnabled(m)) {
4631 logger.info(m, d.get(args).toString(locale), t);
4632 }
4633 }
4634
4635 /**
4636 * Returns {@code true} if this logger will log debug messages.
4637 *
4638 * @return {@code true} if this logger will log debug messages, otherwise
4639 * {@code false}.
4640 * @see org.slf4j.Logger#isDebugEnabled()
4641 */
4642 public boolean isDebugEnabled() {
4643 return logger.isDebugEnabled();
4644 }
4645
4646 /**
4647 * Returns {@code true} if this logger will log debug messages associated
4648 * with the provided marker.
4649 *
4650 * @param m
4651 * The marker information.
4652 * @return {@code true} if this logger will log debug messages, otherwise
4653 * {@code false}.
4654 * @see org.slf4j.Logger#isDebugEnabled(org.slf4j.Marker)
4655 */
4656 public boolean isDebugEnabled(final Marker m) {
4657 return logger.isDebugEnabled(m);
4658 }
4659
4660 /**
4661 * Returns {@code true} if this logger will log error messages.
4662 *
4663 * @return {@code true} if this logger will log error messages, otherwise
4664 * {@code false}.
4665 * @see org.slf4j.Logger#isErrorEnabled()
4666 */
4667 public boolean isErrorEnabled() {
4668 return logger.isErrorEnabled();
4669 }
4670
4671 /**
4672 * Returns {@code true} if this logger will log error messages associated
4673 * with the provided marker.
4674 *
4675 * @param m
4676 * The marker information.
4677 * @return {@code true} if this logger will log error messages, otherwise
4678 * {@code false}.
4679 * @see org.slf4j.Logger#isErrorEnabled(org.slf4j.Marker)
4680 */
4681 public boolean isErrorEnabled(final Marker m) {
4682 return logger.isErrorEnabled(m);
4683 }
4684
4685 /**
4686 * Returns {@code true} if this logger will log info messages.
4687 *
4688 * @return {@code true} if this logger will log info messages, otherwise
4689 * {@code false}.
4690 * @see org.slf4j.Logger#isInfoEnabled()
4691 */
4692 public boolean isInfoEnabled() {
4693 return logger.isInfoEnabled();
4694 }
4695
4696 /**
4697 * Returns {@code true} if this logger will log info messages associated
4698 * with the provided marker.
4699 *
4700 * @param m
4701 * The marker information.
4702 * @return {@code true} if this logger will log info messages, otherwise
4703 * {@code false}.
4704 * @see org.slf4j.Logger#isInfoEnabled(org.slf4j.Marker)
4705 */
4706 public boolean isInfoEnabled(final Marker m) {
4707 return logger.isInfoEnabled(m);
4708 }
4709
4710 /**
4711 * Returns {@code true} if this logger will log trace messages.
4712 *
4713 * @return {@code true} if this logger will log trace messages, otherwise
4714 * {@code false}.
4715 * @see org.slf4j.Logger#isTraceEnabled()
4716 */
4717 public boolean isTraceEnabled() {
4718 return logger.isTraceEnabled();
4719 }
4720
4721 /**
4722 * Returns {@code true} if this logger will log trace messages associated
4723 * with the provided marker.
4724 *
4725 * @param m
4726 * The marker information.
4727 * @return {@code true} if this logger will log trace messages, otherwise
4728 * {@code false}.
4729 * @see org.slf4j.Logger#isTraceEnabled(org.slf4j.Marker)
4730 */
4731 public boolean isTraceEnabled(final Marker m) {
4732 return logger.isTraceEnabled(m);
4733 }
4734
4735 /**
4736 * Returns {@code true} if this logger will log warning messages.
4737 *
4738 * @return {@code true} if this logger will log warning messages, otherwise
4739 * {@code false}.
4740 * @see org.slf4j.Logger#isWarnEnabled()
4741 */
4742 public boolean isWarnEnabled() {
4743 return logger.isWarnEnabled();
4744 }
4745
4746 /**
4747 * Returns {@code true} if this logger will log warning messages associated
4748 * with the provided marker.
4749 *
4750 * @param m
4751 * The marker information.
4752 * @return {@code true} if this logger will log warning messages, otherwise
4753 * {@code false}.
4754 * @see org.slf4j.Logger#isWarnEnabled(org.slf4j.Marker)
4755 */
4756 public boolean isWarnEnabled(final Marker m) {
4757 return logger.isWarnEnabled(m);
4758 }
4759
4760 /**
4761 * Logs a trace message.
4762 *
4763 * @param d
4764 * The message descriptor.
4765 * @see org.slf4j.Logger#trace(String)
4766 */
4767 public void trace(final Arg0 d) {
4768 if (logger.isTraceEnabled()) {
4769 final LocalizableMessage message = d.get();
4770 logger.trace(new LocalizedMarker(message), message.toString(locale));
4771 }
4772 }
4773
4774 /**
4775 * Logs a trace message.
4776 *
4777 * @param msg
4778 * The message.
4779 * @see org.slf4j.Logger#trace(String)
4780 */
4781 public void trace(final String msg) {
4782 if (logger.isTraceEnabled()) {
4783 logger.trace(new LocalizedMarker(LocalizableMessage.raw(msg)), msg);
4784 }
4785 }
4786
4787 /**
4788 * Logs a trace message with provided exception.
4789 *
4790 * @param t
4791 * The exception.
4792 * @see org.slf4j.Logger#trace(String)
4793 */
4794 public void traceException(final Throwable t) {
4795 traceException(t, (t.getMessage() == null ? "" : t.getMessage()));
4796 }
4797
4798 /**
4799 * Logs a trace message with an accompanying exception.
4800 *
4801 * @param d
4802 * The message descriptor.
4803 * @param t
4804 * The throwable to log.
4805 * @see org.slf4j.Logger#trace(String, Throwable)
4806 */
4807 public void trace(final Arg0 d, final Throwable t) {
4808 if (logger.isTraceEnabled()) {
4809 final LocalizableMessage message = d.get();
4810 logger.trace(new LocalizedMarker(message), message.toString(locale), t);
4811 }
4812 }
4813
4814 /**
4815 * Logs a trace message with an accompanying exception.
4816 *
4817 * @param t
4818 * The throwable to log.
4819 * @param msg
4820 * The message.
4821 * @see org.slf4j.Logger#trace(String, Throwable)
4822 */
4823 public void traceException(final Throwable t, final String msg) {
4824 if (logger.isTraceEnabled()) {
4825 logger.trace(new LocalizedMarker(LocalizableMessage.raw(msg)), msg, t);
4826 }
4827 }
4828
4829 /**
4830 * Logs a trace message.
4831 *
4832 * @param <T1>
4833 * The type of the first message argument.
4834 * @param d
4835 * The message descriptor.
4836 * @param a1
4837 * The first message argument.
4838 * @see org.slf4j.Logger#trace(String)
4839 */
4840 public <T1> void trace(final Arg1<T1> d, final T1 a1) {
4841 if (logger.isTraceEnabled()) {
4842 final LocalizableMessage message = d.get(a1);
4843 logger.trace(new LocalizedMarker(message), message.toString(locale));
4844 }
4845 }
4846
4847 /**
4848 * Logs a trace message.
4849 *
4850 * @param format
4851 * The message format, compatible with
4852 * {@code java.util.Formatter} rules
4853 * @param a1
4854 * The first message argument.
4855 * @see org.slf4j.Logger#trace(String)
4856 */
4857 public void trace(final String format, final Object a1) {
4858 if (logger.isTraceEnabled()) {
4859 final LocalizableMessage message = LocalizableMessage.raw(format, a1);
4860 logger.trace(new LocalizedMarker(message), message.toString());
4861 }
4862 }
4863
4864 /**
4865 * Logs a trace message with an accompanying exception.
4866 *
4867 * @param <T1>
4868 * The type of the first message argument.
4869 * @param d
4870 * The message descriptor.
4871 * @param a1
4872 * The first message argument.
4873 * @param t
4874 * The throwable to log.
4875 * @see org.slf4j.Logger#trace(String, Throwable)
4876 */
4877 public <T1> void trace(final Arg1<T1> d, final T1 a1, final Throwable t) {
4878 if (logger.isTraceEnabled()) {
4879 final LocalizableMessage message = d.get(a1);
4880 logger.trace(new LocalizedMarker(message), message.toString(locale), t);
4881 }
4882 }
4883
4884 /**
4885 * Logs a trace message with an accompanying exception.
4886 *
4887 * @param t
4888 * The throwable to log.
4889 * @param format
4890 * The message format, compatible with
4891 * {@code java.util.Formatter} rules
4892 * @param a1
4893 * The first message argument.
4894 * @see org.slf4j.Logger#trace(String, Throwable)
4895 */
4896 public void traceException(final Throwable t, final String format, final Object a1) {
4897 if (logger.isTraceEnabled()) {
4898 final LocalizableMessage message = LocalizableMessage.raw(format, a1);
4899 logger.trace(new LocalizedMarker(message), message.toString(), t);
4900 }
4901 }
4902
4903 /**
4904 * Logs a trace message.
4905 *
4906 * @param <T1>
4907 * The type of the first message argument.
4908 * @param <T2>
4909 * The type of the second message argument.
4910 * @param d
4911 * The message descriptor.
4912 * @param a1
4913 * The first message argument.
4914 * @param a2
4915 * The second message argument.
4916 * @see org.slf4j.Logger#trace(String)
4917 */
4918 public <T1, T2> void trace(final Arg2<T1, T2> d, final T1 a1, final T2 a2) {
4919 if (logger.isTraceEnabled()) {
4920 final LocalizableMessage message = d.get(a1, a2);
4921 logger.trace(new LocalizedMarker(message), message.toString(locale));
4922 }
4923 }
4924
4925 /**
4926 * Logs a trace message.
4927 *
4928 * @param format
4929 * The message format, compatible with
4930 * {@code java.util.Formatter} rules
4931 * @param a1
4932 * The first message argument.
4933 * @param a2
4934 * The second message argument.
4935 * @see org.slf4j.Logger#trace(String)
4936 */
4937 public void trace(final String format, final Object a1, final Object a2) {
4938 if (logger.isTraceEnabled()) {
4939 final LocalizableMessage message = LocalizableMessage.raw(format, a1, a2);
4940 logger.trace(new LocalizedMarker(message), message.toString());
4941 }
4942 }
4943
4944 /**
4945 * Logs a trace message with an accompanying exception.
4946 *
4947 * @param <T1>
4948 * The type of the first message argument.
4949 * @param <T2>
4950 * The type of the second message argument.
4951 * @param d
4952 * The message descriptor.
4953 * @param a1
4954 * The first message argument.
4955 * @param a2
4956 * The second message argument.
4957 * @param t
4958 * The throwable to log.
4959 * @see org.slf4j.Logger#trace(String, Throwable)
4960 */
4961 public <T1, T2> void trace(final Arg2<T1, T2> d, final T1 a1, final T2 a2, final Throwable t) {
4962 if (logger.isTraceEnabled()) {
4963 final LocalizableMessage message = d.get(a1, a2);
4964 logger.trace(new LocalizedMarker(message), message.toString(locale), t);
4965 }
4966 }
4967
4968 /**
4969 * Logs a trace message with an accompanying exception.
4970 *
4971 * @param t
4972 * The throwable to log.
4973 * @param format
4974 * The message format, compatible with
4975 * {@code java.util.Formatter} rules
4976 * @param a1
4977 * The first message argument.
4978 * @param a2
4979 * The second message argument.
4980 * @see org.slf4j.Logger#trace(String, Throwable)
4981 */
4982 public void traceException(final Throwable t, final String format, final Object a1, final Object a2) {
4983 if (logger.isTraceEnabled()) {
4984 final LocalizableMessage message = LocalizableMessage.raw(format, a1, a2);
4985 logger.trace(new LocalizedMarker(message), message.toString(), t);
4986 }
4987 }
4988
4989 /**
4990 * Logs a trace message.
4991 *
4992 * @param <T1>
4993 * The type of the first message argument.
4994 * @param <T2>
4995 * The type of the second message argument.
4996 * @param <T3>
4997 * The type of the third message argument.
4998 * @param d
4999 * The message descriptor.
5000 * @param a1
5001 * The first message argument.
5002 * @param a2
5003 * The second message argument.
5004 * @param a3
5005 * The third message argument.
5006 * @see org.slf4j.Logger#trace(String)
5007 */
5008 public <T1, T2, T3> void trace(final Arg3<T1, T2, T3> d, final T1 a1, final T2 a2, final T3 a3) {
5009 if (logger.isTraceEnabled()) {
5010 final LocalizableMessage message = d.get(a1, a2, a3);
5011 logger.trace(new LocalizedMarker(message), message.toString(locale));
5012 }
5013 }
5014
5015 /**
5016 * Logs a trace message.
5017 *
5018 * @param format
5019 * The message format, compatible with
5020 * {@code java.util.Formatter} rules
5021 * @param a1
5022 * The first message argument.
5023 * @param a2
5024 * The second message argument.
5025 * @param a3
5026 * The third message argument.
5027 * @see org.slf4j.Logger#trace(String)
5028 */
5029 public void trace(final String format, final Object a1, final Object a2, final Object a3) {
5030 if (logger.isTraceEnabled()) {
5031 final LocalizableMessage message = LocalizableMessage.raw(format, a1, a2, a3);
5032 logger.trace(new LocalizedMarker(message), message.toString());
5033 }
5034 }
5035
5036 /**
5037 * Logs a trace message with an accompanying exception.
5038 *
5039 * @param <T1>
5040 * The type of the first message argument.
5041 * @param <T2>
5042 * The type of the second message argument.
5043 * @param <T3>
5044 * The type of the third message argument.
5045 * @param d
5046 * The message descriptor.
5047 * @param a1
5048 * The first message argument.
5049 * @param a2
5050 * The second message argument.
5051 * @param a3
5052 * The third message argument.
5053 * @param t
5054 * The throwable to log.
5055 * @see org.slf4j.Logger#trace(String, Throwable)
5056 */
5057 public <T1, T2, T3> void trace(final Arg3<T1, T2, T3> d, final T1 a1, final T2 a2, final T3 a3,
5058 final Throwable t) {
5059 if (logger.isTraceEnabled()) {
5060 final LocalizableMessage message = d.get(a1, a2, a3);
5061 logger.trace(new LocalizedMarker(message), message.toString(locale), t);
5062 }
5063 }
5064
5065 /**
5066 * Logs a trace message with an accompanying exception.
5067 *
5068 * @param t
5069 * The throwable to log.
5070 * @param format
5071 * The message format, compatible with
5072 * {@code java.util.Formatter} rules
5073 * @param a1
5074 * The first message argument.
5075 * @param a2
5076 * The second message argument.
5077 * @param a3
5078 * The third message argument.
5079 * @see org.slf4j.Logger#trace(String, Throwable)
5080 */
5081 public void traceException(final Throwable t, final String format, final Object a1, final Object a2,
5082 final Object a3) {
5083 if (logger.isTraceEnabled()) {
5084 final LocalizableMessage message = LocalizableMessage.raw(format, a1, a2, a3);
5085 logger.trace(new LocalizedMarker(message), message.toString(), t);
5086 }
5087 }
5088
5089 /**
5090 * Logs a trace message.
5091 *
5092 * @param <T1>
5093 * The type of the first message argument.
5094 * @param <T2>
5095 * The type of the second message argument.
5096 * @param <T3>
5097 * The type of the third message argument.
5098 * @param <T4>
5099 * The type of the fourth message argument.
5100 * @param d
5101 * The message descriptor.
5102 * @param a1
5103 * The first message argument.
5104 * @param a2
5105 * The second message argument.
5106 * @param a3
5107 * The third message argument.
5108 * @param a4
5109 * The fourth message argument.
5110 * @see org.slf4j.Logger#trace(String)
5111 */
5112 public <T1, T2, T3, T4> void trace(final Arg4<T1, T2, T3, T4> d, final T1 a1, final T2 a2,
5113 final T3 a3, final T4 a4) {
5114 if (logger.isTraceEnabled()) {
5115 final LocalizableMessage message = d.get(a1, a2, a3, a4);
5116 logger.trace(new LocalizedMarker(message), message.toString(locale));
5117 }
5118 }
5119
5120 /**
5121 * Logs a trace message with an accompanying exception.
5122 *
5123 * @param <T1>
5124 * The type of the first message argument.
5125 * @param <T2>
5126 * The type of the second message argument.
5127 * @param <T3>
5128 * The type of the third message argument.
5129 * @param <T4>
5130 * The type of the fourth message argument.
5131 * @param d
5132 * The message descriptor.
5133 * @param a1
5134 * The first message argument.
5135 * @param a2
5136 * The second message argument.
5137 * @param a3
5138 * The third message argument.
5139 * @param a4
5140 * The fourth message argument.
5141 * @param t
5142 * The throwable to log.
5143 * @see org.slf4j.Logger#trace(String, Throwable)
5144 */
5145 public <T1, T2, T3, T4> void trace(final Arg4<T1, T2, T3, T4> d, final T1 a1, final T2 a2,
5146 final T3 a3, final T4 a4, final Throwable t) {
5147 if (logger.isTraceEnabled()) {
5148 final LocalizableMessage message = d.get(a1, a2, a3, a4);
5149 logger.trace(new LocalizedMarker(message), message.toString(locale), t);
5150 }
5151 }
5152
5153 /**
5154 * Logs a trace message.
5155 *
5156 * @param <T1>
5157 * The type of the first message argument.
5158 * @param <T2>
5159 * The type of the second message argument.
5160 * @param <T3>
5161 * The type of the third message argument.
5162 * @param <T4>
5163 * The type of the fourth message argument.
5164 * @param <T5>
5165 * The type of the fifth message argument.
5166 * @param d
5167 * The message descriptor.
5168 * @param a1
5169 * The first message argument.
5170 * @param a2
5171 * The second message argument.
5172 * @param a3
5173 * The third message argument.
5174 * @param a4
5175 * The fourth message argument.
5176 * @param a5
5177 * The fifth message argument.
5178 * @see org.slf4j.Logger#trace(String)
5179 */
5180 public <T1, T2, T3, T4, T5> void trace(final Arg5<T1, T2, T3, T4, T5> d, final T1 a1,
5181 final T2 a2, final T3 a3, final T4 a4, final T5 a5) {
5182 if (logger.isTraceEnabled()) {
5183 final LocalizableMessage message = d.get(a1, a2, a3, a4, a5);
5184 logger.trace(new LocalizedMarker(message), message.toString(locale));
5185 }
5186 }
5187
5188 /**
5189 * Logs a trace message with an accompanying exception.
5190 *
5191 * @param <T1>
5192 * The type of the first message argument.
5193 * @param <T2>
5194 * The type of the second message argument.
5195 * @param <T3>
5196 * The type of the third message argument.
5197 * @param <T4>
5198 * The type of the fourth message argument.
5199 * @param <T5>
5200 * The type of the fifth message argument.
5201 * @param d
5202 * The message descriptor.
5203 * @param a1
5204 * The first message argument.
5205 * @param a2
5206 * The second message argument.
5207 * @param a3
5208 * The third message argument.
5209 * @param a4
5210 * The fourth message argument.
5211 * @param a5
5212 * The fifth message argument.
5213 * @param t
5214 * The throwable to log.
5215 * @see org.slf4j.Logger#trace(String, Throwable)
5216 */
5217 public <T1, T2, T3, T4, T5> void trace(final Arg5<T1, T2, T3, T4, T5> d, final T1 a1,
5218 final T2 a2, final T3 a3, final T4 a4, final T5 a5, final Throwable t) {
5219 if (logger.isTraceEnabled()) {
5220 final LocalizableMessage message = d.get(a1, a2, a3, a4, a5);
5221 logger.trace(new LocalizedMarker(message), message.toString(locale), t);
5222 }
5223 }
5224
5225 /**
5226 * Logs a trace message.
5227 *
5228 * @param <T1>
5229 * The type of the first message argument.
5230 * @param <T2>
5231 * The type of the second message argument.
5232 * @param <T3>
5233 * The type of the third message argument.
5234 * @param <T4>
5235 * The type of the fourth message argument.
5236 * @param <T5>
5237 * The type of the fifth message argument.
5238 * @param <T6>
5239 * The type of the sixth message argument.
5240 * @param d
5241 * The message descriptor.
5242 * @param a1
5243 * The first message argument.
5244 * @param a2
5245 * The second message argument.
5246 * @param a3
5247 * The third message argument.
5248 * @param a4
5249 * The fourth message argument.
5250 * @param a5
5251 * The fifth message argument.
5252 * @param a6
5253 * The sixth message argument.
5254 * @see org.slf4j.Logger#trace(String)
5255 */
5256 public <T1, T2, T3, T4, T5, T6> void trace(final Arg6<T1, T2, T3, T4, T5, T6> d, final T1 a1,
5257 final T2 a2, final T3 a3, final T4 a4, final T5 a5, final T6 a6) {
5258 if (logger.isTraceEnabled()) {
5259 final LocalizableMessage message = d.get(a1, a2, a3, a4, a5, a6);
5260 logger.trace(new LocalizedMarker(message), message.toString(locale));
5261 }
5262 }
5263
5264 /**
5265 * Logs a trace message with an accompanying exception.
5266 *
5267 * @param <T1>
5268 * The type of the first message argument.
5269 * @param <T2>
5270 * The type of the second message argument.
5271 * @param <T3>
5272 * The type of the third message argument.
5273 * @param <T4>
5274 * The type of the fourth message argument.
5275 * @param <T5>
5276 * The type of the fifth message argument.
5277 * @param <T6>
5278 * The type of the sixth message argument.
5279 * @param d
5280 * The message descriptor.
5281 * @param a1
5282 * The first message argument.
5283 * @param a2
5284 * The second message argument.
5285 * @param a3
5286 * The third message argument.
5287 * @param a4
5288 * The fourth message argument.
5289 * @param a5
5290 * The fifth message argument.
5291 * @param a6
5292 * The sixth message argument.
5293 * @param t
5294 * The throwable to log.
5295 * @see org.slf4j.Logger#trace(String, Throwable)
5296 */
5297 public <T1, T2, T3, T4, T5, T6> void trace(final Arg6<T1, T2, T3, T4, T5, T6> d, final T1 a1,
5298 final T2 a2, final T3 a3, final T4 a4, final T5 a5, final T6 a6, final Throwable t) {
5299 if (logger.isTraceEnabled()) {
5300 final LocalizableMessage message = d.get(a1, a2, a3, a4, a5, a6);
5301 logger.trace(new LocalizedMarker(message), message.toString(locale), t);
5302 }
5303 }
5304
5305 /**
5306 * Logs a trace message.
5307 *
5308 * @param <T1>
5309 * The type of the first message argument.
5310 * @param <T2>
5311 * The type of the second message argument.
5312 * @param <T3>
5313 * The type of the third message argument.
5314 * @param <T4>
5315 * The type of the fourth message argument.
5316 * @param <T5>
5317 * The type of the fifth message argument.
5318 * @param <T6>
5319 * The type of the sixth message argument.
5320 * @param <T7>
5321 * The type of the seventh message argument.
5322 * @param d
5323 * The message descriptor.
5324 * @param a1
5325 * The first message argument.
5326 * @param a2
5327 * The second message argument.
5328 * @param a3
5329 * The third message argument.
5330 * @param a4
5331 * The fourth message argument.
5332 * @param a5
5333 * The fifth message argument.
5334 * @param a6
5335 * The sixth message argument.
5336 * @param a7
5337 * The seventh message argument.
5338 * @see org.slf4j.Logger#trace(String)
5339 */
5340 public <T1, T2, T3, T4, T5, T6, T7> void trace(final Arg7<T1, T2, T3, T4, T5, T6, T7> d,
5341 final T1 a1, final T2 a2, final T3 a3, final T4 a4, final T5 a5, final T6 a6,
5342 final T7 a7) {
5343 if (logger.isTraceEnabled()) {
5344 final LocalizableMessage message = d.get(a1, a2, a3, a4, a5, a6, a7);
5345 logger.trace(new LocalizedMarker(message), message.toString(locale));
5346 }
5347 }
5348
5349 /**
5350 * Logs a trace message with an accompanying exception.
5351 *
5352 * @param <T1>
5353 * The type of the first message argument.
5354 * @param <T2>
5355 * The type of the second message argument.
5356 * @param <T3>
5357 * The type of the third message argument.
5358 * @param <T4>
5359 * The type of the fourth message argument.
5360 * @param <T5>
5361 * The type of the fifth message argument.
5362 * @param <T6>
5363 * The type of the sixth message argument.
5364 * @param <T7>
5365 * The type of the seventh message argument.
5366 * @param d
5367 * The message descriptor.
5368 * @param a1
5369 * The first message argument.
5370 * @param a2
5371 * The second message argument.
5372 * @param a3
5373 * The third message argument.
5374 * @param a4
5375 * The fourth message argument.
5376 * @param a5
5377 * The fifth message argument.
5378 * @param a6
5379 * The sixth message argument.
5380 * @param a7
5381 * The seventh message argument.
5382 * @param t
5383 * The throwable to log.
5384 * @see org.slf4j.Logger#trace(String, Throwable)
5385 */
5386 public <T1, T2, T3, T4, T5, T6, T7> void trace(final Arg7<T1, T2, T3, T4, T5, T6, T7> d,
5387 final T1 a1, final T2 a2, final T3 a3, final T4 a4, final T5 a5, final T6 a6,
5388 final T7 a7, final Throwable t) {
5389 if (logger.isTraceEnabled()) {
5390 final LocalizableMessage message = d.get(a1, a2, a3, a4, a5, a6, a7);
5391 logger.trace(new LocalizedMarker(message), message.toString(locale), t);
5392 }
5393 }
5394
5395 /**
5396 * Logs a trace message.
5397 *
5398 * @param <T1>
5399 * The type of the first message argument.
5400 * @param <T2>
5401 * The type of the second message argument.
5402 * @param <T3>
5403 * The type of the third message argument.
5404 * @param <T4>
5405 * The type of the fourth message argument.
5406 * @param <T5>
5407 * The type of the fifth message argument.
5408 * @param <T6>
5409 * The type of the sixth message argument.
5410 * @param <T7>
5411 * The type of the seventh message argument.
5412 * @param <T8>
5413 * The type of the eighth message argument.
5414 * @param d
5415 * The message descriptor.
5416 * @param a1
5417 * The first message argument.
5418 * @param a2
5419 * The second message argument.
5420 * @param a3
5421 * The third message argument.
5422 * @param a4
5423 * The fourth message argument.
5424 * @param a5
5425 * The fifth message argument.
5426 * @param a6
5427 * The sixth message argument.
5428 * @param a7
5429 * The seventh message argument.
5430 * @param a8
5431 * The eighth message argument.
5432 * @see org.slf4j.Logger#trace(String)
5433 */
5434 public <T1, T2, T3, T4, T5, T6, T7, T8> void trace(
5435 final Arg8<T1, T2, T3, T4, T5, T6, T7, T8> d, final T1 a1, final T2 a2, final T3 a3,
5436 final T4 a4, final T5 a5, final T6 a6, final T7 a7, final T8 a8) {
5437 if (logger.isTraceEnabled()) {
5438 final LocalizableMessage message = d.get(a1, a2, a3, a4, a5, a6, a7, a8);
5439 logger.trace(new LocalizedMarker(message), message.toString(locale));
5440 }
5441 }
5442
5443 /**
5444 * Logs a trace message with an accompanying exception.
5445 *
5446 * @param <T1>
5447 * The type of the first message argument.
5448 * @param <T2>
5449 * The type of the second message argument.
5450 * @param <T3>
5451 * The type of the third message argument.
5452 * @param <T4>
5453 * The type of the fourth message argument.
5454 * @param <T5>
5455 * The type of the fifth message argument.
5456 * @param <T6>
5457 * The type of the sixth message argument.
5458 * @param <T7>
5459 * The type of the seventh message argument.
5460 * @param <T8>
5461 * The type of the eighth message argument.
5462 * @param d
5463 * The message descriptor.
5464 * @param a1
5465 * The first message argument.
5466 * @param a2
5467 * The second message argument.
5468 * @param a3
5469 * The third message argument.
5470 * @param a4
5471 * The fourth message argument.
5472 * @param a5
5473 * The fifth message argument.
5474 * @param a6
5475 * The sixth message argument.
5476 * @param a7
5477 * The seventh message argument.
5478 * @param a8
5479 * The eighth message argument.
5480 * @param t
5481 * The throwable to log.
5482 * @see org.slf4j.Logger#trace(String, Throwable)
5483 */
5484 public <T1, T2, T3, T4, T5, T6, T7, T8> void trace(
5485 final Arg8<T1, T2, T3, T4, T5, T6, T7, T8> d, final T1 a1, final T2 a2, final T3 a3,
5486 final T4 a4, final T5 a5, final T6 a6, final T7 a7, final T8 a8, final Throwable t) {
5487 if (logger.isTraceEnabled()) {
5488 final LocalizableMessage message = d.get(a1, a2, a3, a4, a5, a6, a7, a8);
5489 logger.trace(new LocalizedMarker(message), message.toString(locale), t);
5490 }
5491 }
5492
5493 /**
5494 * Logs a trace message.
5495 *
5496 * @param <T1>
5497 * The type of the first message argument.
5498 * @param <T2>
5499 * The type of the second message argument.
5500 * @param <T3>
5501 * The type of the third message argument.
5502 * @param <T4>
5503 * The type of the fourth message argument.
5504 * @param <T5>
5505 * The type of the fifth message argument.
5506 * @param <T6>
5507 * The type of the sixth message argument.
5508 * @param <T7>
5509 * The type of the seventh message argument.
5510 * @param <T8>
5511 * The type of the eighth message argument.
5512 * @param <T9>
5513 * The type of the ninth message argument.
5514 * @param d
5515 * The message descriptor.
5516 * @param a1
5517 * The first message argument.
5518 * @param a2
5519 * The second message argument.
5520 * @param a3
5521 * The third message argument.
5522 * @param a4
5523 * The fourth message argument.
5524 * @param a5
5525 * The fifth message argument.
5526 * @param a6
5527 * The sixth message argument.
5528 * @param a7
5529 * The seventh message argument.
5530 * @param a8
5531 * The eighth message argument.
5532 * @param a9
5533 * The ninth message argument.
5534 * @see org.slf4j.Logger#trace(String)
5535 */
5536 public <T1, T2, T3, T4, T5, T6, T7, T8, T9> void trace(
5537 final Arg9<T1, T2, T3, T4, T5, T6, T7, T8, T9> d, final T1 a1, final T2 a2,
5538 final T3 a3, final T4 a4, final T5 a5, final T6 a6, final T7 a7, final T8 a8,
5539 final T9 a9) {
5540 if (logger.isTraceEnabled()) {
5541 final LocalizableMessage message = d.get(a1, a2, a3, a4, a5, a6, a7, a8, a9);
5542 logger.trace(new LocalizedMarker(message), message.toString(locale));
5543 }
5544 }
5545
5546 /**
5547 * Logs a trace message with an accompanying exception.
5548 *
5549 * @param <T1>
5550 * The type of the first message argument.
5551 * @param <T2>
5552 * The type of the second message argument.
5553 * @param <T3>
5554 * The type of the third message argument.
5555 * @param <T4>
5556 * The type of the fourth message argument.
5557 * @param <T5>
5558 * The type of the fifth message argument.
5559 * @param <T6>
5560 * The type of the sixth message argument.
5561 * @param <T7>
5562 * The type of the seventh message argument.
5563 * @param <T8>
5564 * The type of the eighth message argument.
5565 * @param <T9>
5566 * The type of the ninth message argument.
5567 * @param d
5568 * The message descriptor.
5569 * @param a1
5570 * The first message argument.
5571 * @param a2
5572 * The second message argument.
5573 * @param a3
5574 * The third message argument.
5575 * @param a4
5576 * The fourth message argument.
5577 * @param a5
5578 * The fifth message argument.
5579 * @param a6
5580 * The sixth message argument.
5581 * @param a7
5582 * The seventh message argument.
5583 * @param a8
5584 * The eighth message argument.
5585 * @param a9
5586 * The ninth message argument.
5587 * @param t
5588 * The throwable to log.
5589 * @see org.slf4j.Logger#trace(String, Throwable)
5590 */
5591 public <T1, T2, T3, T4, T5, T6, T7, T8, T9> void trace(
5592 final Arg9<T1, T2, T3, T4, T5, T6, T7, T8, T9> d, final T1 a1, final T2 a2,
5593 final T3 a3, final T4 a4, final T5 a5, final T6 a6, final T7 a7, final T8 a8,
5594 final T9 a9, final Throwable t) {
5595 if (logger.isTraceEnabled()) {
5596 final LocalizableMessage message = d.get(a1, a2, a3, a4, a5, a6, a7, a8, a9);
5597 logger.trace(new LocalizedMarker(message), message.toString(locale), t);
5598 }
5599 }
5600
5601 /**
5602 * Logs a trace message.
5603 *
5604 * @param d
5605 * The message descriptor.
5606 * @param args
5607 * The message arguments.
5608 * @see org.slf4j.Logger#trace(String)
5609 */
5610 public void trace(final ArgN d, final Object... args) {
5611 if (logger.isTraceEnabled()) {
5612 final LocalizableMessage message = d.get(args);
5613 logger.trace(new LocalizedMarker(message), message.toString(locale));
5614 }
5615 }
5616
5617 /**
5618 * Logs a trace message with an accompanying exception.
5619 *
5620 * @param d
5621 * The message descriptor.
5622 * @param t
5623 * The throwable to log.
5624 * @param args
5625 * The message arguments.
5626 * @see org.slf4j.Logger#trace(String, Throwable)
5627 */
5628 public void trace(final ArgN d, final Throwable t, final Object... args) {
5629 if (logger.isTraceEnabled()) {
5630 final LocalizableMessage message = d.get(args);
5631 logger.trace(new LocalizedMarker(message), message.toString(locale), t);
5632 }
5633 }
5634
5635 /**
5636 * Logs a trace message.
5637 *
5638 * @param format
5639 * The message format, compatible with
5640 * {@code java.util.Formatter} rules
5641 * @param args
5642 * The message arguments.
5643 *
5644 * @see org.slf4j.Logger#trace(Marker, String)
5645 */
5646 public void trace(final String format, final Object...args) {
5647 if (logger.isTraceEnabled()) {
5648 final LocalizableMessage message = LocalizableMessage.raw(format, args);
5649 logger.trace(new LocalizedMarker(message), message.toString());
5650 }
5651 }
5652
5653 /**
5654 * Logs a trace message with an accompanying exception.
5655 *
5656 * @param t
5657 * The throwable to log.
5658 * @param format
5659 * The message format, compatible with
5660 * {@code java.util.Formatter} rules
5661 * @param args
5662 * The message arguments.
5663 * @see org.slf4j.Logger#trace(String, Throwable)
5664 */
5665 public void traceException(final Throwable t, final String format, final Object... args) {
5666 if (logger.isTraceEnabled()) {
5667 final LocalizableMessage message = LocalizableMessage.raw(format, args);
5668 logger.trace(new LocalizedMarker(message), message.toString(), t);
5669 }
5670 }
5671
5672 /**
5673 * Logs a trace message.
5674 *
5675 * @param m
5676 * The pre-formatted message.
5677 * @see org.slf4j.Logger#trace(String)
5678 */
5679 public void trace(final LocalizableMessage m) {
5680 if (logger.isTraceEnabled()) {
5681 logger.trace(new LocalizedMarker(m), m.toString(locale));
5682 }
5683 }
5684
5685 /**
5686 * Logs a trace message with an accompanying exception.
5687 *
5688 * @param m
5689 * The pre-formatted message.
5690 * @param t
5691 * The throwable to log.
5692 * @see org.slf4j.Logger#trace(String, Throwable)
5693 */
5694 public void trace(final LocalizableMessage m, final Throwable t) {
5695 if (logger.isTraceEnabled()) {
5696 logger.trace(new LocalizedMarker(m), m.toString(locale), t);
5697 }
5698 }
5699
5700 /**
5701 * Logs a trace message using the provided {@code Marker}.
5702 *
5703 * @param m
5704 * The marker information associated with this log message.
5705 * @param d
5706 * The message descriptor.
5707 * @see org.slf4j.Logger#trace(org.slf4j.Marker, String)
5708 */
5709 public void trace(final Marker m, final Arg0 d) {
5710 if (logger.isTraceEnabled(m)) {
5711 logger.trace(m, d.get().toString(locale));
5712 }
5713 }
5714
5715 /**
5716 * Logs a trace message using the provided {@code Marker}.
5717 *
5718 * @param m
5719 * The marker tracermation associated with this log message.
5720 * @param d
5721 * The message descriptor.
5722 * @param t
5723 * The throwable to log.
5724 * @see org.slf4j.Logger#trace(org.slf4j.Marker, String)
5725 */
5726 public void trace(final Marker m, final Arg0 d, final Throwable t) {
5727 if (logger.isTraceEnabled(m)) {
5728 logger.trace(m, d.get().toString(locale), t);
5729 }
5730 }
5731
5732 /**
5733 * Logs a trace message.
5734 *
5735 * @param <T1>
5736 * The type of the first message argument.
5737 * @param m
5738 * The marker information associated with this log message.
5739 * @param d
5740 * The message descriptor.
5741 * @param a1
5742 * The first message argument.
5743 * @see org.slf4j.Logger#trace(String)
5744 */
5745 public <T1> void trace(final Marker m, final Arg1<T1> d, final T1 a1) {
5746 if (logger.isTraceEnabled(m)) {
5747 logger.trace(m, d.get(a1).toString(locale));
5748 }
5749 }
5750
5751 /**
5752 * Logs a trace message with an accompanying exception.
5753 *
5754 * @param <T1>
5755 * The type of the first message argument.
5756 * @param m
5757 * The marker tracermation associated with this log message.
5758 * @param d
5759 * The message descriptor.
5760 * @param a1
5761 * The first message argument.
5762 * @param t
5763 * The throwable to log.
5764 * @see org.slf4j.Logger#trace(String, Throwable)
5765 */
5766 public <T1> void trace(final Marker m, final Arg1<T1> d, final T1 a1, final Throwable t) {
5767 if (logger.isTraceEnabled(m)) {
5768 logger.trace(m, d.get(a1).toString(locale), t);
5769 }
5770 }
5771
5772 /**
5773 * Logs a trace message.
5774 *
5775 * @param <T1>
5776 * The type of the first message argument.
5777 * @param <T2>
5778 * The type of the second message argument.
5779 * @param m
5780 * The marker information associated with this log message.
5781 * @param d
5782 * The message descriptor.
5783 * @param a1
5784 * The first message argument.
5785 * @param a2
5786 * The second message argument.
5787 * @see org.slf4j.Logger#trace(String)
5788 */
5789 public <T1, T2> void trace(final Marker m, final Arg2<T1, T2> d, final T1 a1, final T2 a2) {
5790 if (logger.isTraceEnabled(m)) {
5791 logger.trace(m, d.get(a1, a2).toString(locale));
5792 }
5793 }
5794
5795 /**
5796 * Logs a trace message with an accompanying exception.
5797 *
5798 * @param <T1>
5799 * The type of the first message argument.
5800 * @param <T2>
5801 * The type of the second message argument.
5802 * @param m
5803 * The marker tracermation associated with this log message.
5804 * @param d
5805 * The message descriptor.
5806 * @param a1
5807 * The first message argument.
5808 * @param a2
5809 * The second message argument.
5810 * @param t
5811 * The throwable to log.
5812 * @see org.slf4j.Logger#trace(String, Throwable)
5813 */
5814 public <T1, T2> void trace(final Marker m, final Arg2<T1, T2> d, final T1 a1, final T2 a2,
5815 final Throwable t) {
5816 if (logger.isTraceEnabled(m)) {
5817 logger.trace(m, d.get(a1, a2).toString(locale), t);
5818 }
5819 }
5820
5821 /**
5822 * Logs a trace message.
5823 *
5824 * @param <T1>
5825 * The type of the first message argument.
5826 * @param <T2>
5827 * The type of the second message argument.
5828 * @param <T3>
5829 * The type of the third message argument.
5830 * @param m
5831 * The marker information associated with this log message.
5832 * @param d
5833 * The message descriptor.
5834 * @param a1
5835 * The first message argument.
5836 * @param a2
5837 * The second message argument.
5838 * @param a3
5839 * The third message argument.
5840 * @see org.slf4j.Logger#trace(String)
5841 */
5842 public <T1, T2, T3> void trace(final Marker m, final Arg3<T1, T2, T3> d, final T1 a1,
5843 final T2 a2, final T3 a3) {
5844 if (logger.isTraceEnabled(m)) {
5845 logger.trace(m, d.get(a1, a2, a3).toString(locale));
5846 }
5847 }
5848
5849 /**
5850 * Logs a trace message with an accompanying exception.
5851 *
5852 * @param <T1>
5853 * The type of the first message argument.
5854 * @param <T2>
5855 * The type of the second message argument.
5856 * @param <T3>
5857 * The type of the third message argument.
5858 * @param m
5859 * The marker tracermation associated with this log message.
5860 * @param d
5861 * The message descriptor.
5862 * @param a1
5863 * The first message argument.
5864 * @param a2
5865 * The second message argument.
5866 * @param a3
5867 * The third message argument.
5868 * @param t
5869 * The throwable to log.
5870 * @see org.slf4j.Logger#trace(String, Throwable)
5871 */
5872 public <T1, T2, T3> void trace(final Marker m, final Arg3<T1, T2, T3> d, final T1 a1,
5873 final T2 a2, final T3 a3, final Throwable t) {
5874 if (logger.isTraceEnabled(m)) {
5875 logger.trace(m, d.get(a1, a2, a3).toString(locale), t);
5876 }
5877 }
5878
5879 /**
5880 * Logs a trace message.
5881 *
5882 * @param <T1>
5883 * The type of the first message argument.
5884 * @param <T2>
5885 * The type of the second message argument.
5886 * @param <T3>
5887 * The type of the third message argument.
5888 * @param <T4>
5889 * The type of the fourth message argument.
5890 * @param m
5891 * The marker information associated with this log message.
5892 * @param d
5893 * The message descriptor.
5894 * @param a1
5895 * The first message argument.
5896 * @param a2
5897 * The second message argument.
5898 * @param a3
5899 * The third message argument.
5900 * @param a4
5901 * The fourth message argument.
5902 * @see org.slf4j.Logger#trace(String)
5903 */
5904 public <T1, T2, T3, T4> void trace(final Marker m, final Arg4<T1, T2, T3, T4> d, final T1 a1,
5905 final T2 a2, final T3 a3, final T4 a4) {
5906 if (logger.isTraceEnabled(m)) {
5907 logger.trace(m, d.get(a1, a2, a3, a4).toString(locale));
5908 }
5909 }
5910
5911 /**
5912 * Logs a trace message with an accompanying exception.
5913 *
5914 * @param <T1>
5915 * The type of the first message argument.
5916 * @param <T2>
5917 * The type of the second message argument.
5918 * @param <T3>
5919 * The type of the third message argument.
5920 * @param <T4>
5921 * The type of the fourth message argument.
5922 * @param m
5923 * The marker tracermation associated with this log message.
5924 * @param d
5925 * The message descriptor.
5926 * @param a1
5927 * The first message argument.
5928 * @param a2
5929 * The second message argument.
5930 * @param a3
5931 * The third message argument.
5932 * @param a4
5933 * The fourth message argument.
5934 * @param t
5935 * The throwable to log.
5936 * @see org.slf4j.Logger#trace(String, Throwable)
5937 */
5938 public <T1, T2, T3, T4> void trace(final Marker m, final Arg4<T1, T2, T3, T4> d, final T1 a1,
5939 final T2 a2, final T3 a3, final T4 a4, final Throwable t) {
5940 if (logger.isTraceEnabled(m)) {
5941 logger.trace(m, d.get(a1, a2, a3, a4).toString(locale), t);
5942 }
5943 }
5944
5945 /**
5946 * Logs a trace message.
5947 *
5948 * @param <T1>
5949 * The type of the first message argument.
5950 * @param <T2>
5951 * The type of the second message argument.
5952 * @param <T3>
5953 * The type of the third message argument.
5954 * @param <T4>
5955 * The type of the fourth message argument.
5956 * @param <T5>
5957 * The type of the fifth message argument.
5958 * @param m
5959 * The marker information associated with this log message.
5960 * @param d
5961 * The message descriptor.
5962 * @param a1
5963 * The first message argument.
5964 * @param a2
5965 * The second message argument.
5966 * @param a3
5967 * The third message argument.
5968 * @param a4
5969 * The fourth message argument.
5970 * @param a5
5971 * The fifth message argument.
5972 * @see org.slf4j.Logger#trace(String)
5973 */
5974 public <T1, T2, T3, T4, T5> void trace(final Marker m, final Arg5<T1, T2, T3, T4, T5> d,
5975 final T1 a1, final T2 a2, final T3 a3, final T4 a4, final T5 a5) {
5976 if (logger.isTraceEnabled(m)) {
5977 logger.trace(m, d.get(a1, a2, a3, a4, a5).toString(locale));
5978 }
5979 }
5980
5981 /**
5982 * Logs a trace message with an accompanying exception.
5983 *
5984 * @param <T1>
5985 * The type of the first message argument.
5986 * @param <T2>
5987 * The type of the second message argument.
5988 * @param <T3>
5989 * The type of the third message argument.
5990 * @param <T4>
5991 * The type of the fourth message argument.
5992 * @param <T5>
5993 * The type of the fifth message argument.
5994 * @param m
5995 * The marker tracermation associated with this log message.
5996 * @param d
5997 * The message descriptor.
5998 * @param a1
5999 * The first message argument.
6000 * @param a2
6001 * The second message argument.
6002 * @param a3
6003 * The third message argument.
6004 * @param a4
6005 * The fourth message argument.
6006 * @param a5
6007 * The fifth message argument.
6008 * @param t
6009 * The throwable to log.
6010 * @see org.slf4j.Logger#trace(String, Throwable)
6011 */
6012 public <T1, T2, T3, T4, T5> void trace(final Marker m, final Arg5<T1, T2, T3, T4, T5> d,
6013 final T1 a1, final T2 a2, final T3 a3, final T4 a4, final T5 a5, final Throwable t) {
6014 if (logger.isTraceEnabled(m)) {
6015 logger.trace(m, d.get(a1, a2, a3, a4, a5).toString(locale), t);
6016 }
6017 }
6018
6019 /**
6020 * Logs a trace message.
6021 *
6022 * @param <T1>
6023 * The type of the first message argument.
6024 * @param <T2>
6025 * The type of the second message argument.
6026 * @param <T3>
6027 * The type of the third message argument.
6028 * @param <T4>
6029 * The type of the fourth message argument.
6030 * @param <T5>
6031 * The type of the fifth message argument.
6032 * @param <T6>
6033 * The type of the sixth message argument.
6034 * @param m
6035 * The marker information associated with this log message.
6036 * @param d
6037 * The message descriptor.
6038 * @param a1
6039 * The first message argument.
6040 * @param a2
6041 * The second message argument.
6042 * @param a3
6043 * The third message argument.
6044 * @param a4
6045 * The fourth message argument.
6046 * @param a5
6047 * The fifth message argument.
6048 * @param a6
6049 * The sixth message argument.
6050 * @see org.slf4j.Logger#trace(String)
6051 */
6052 public <T1, T2, T3, T4, T5, T6> void trace(final Marker m,
6053 final Arg6<T1, T2, T3, T4, T5, T6> d, final T1 a1, final T2 a2, final T3 a3,
6054 final T4 a4, final T5 a5, final T6 a6) {
6055 if (logger.isTraceEnabled(m)) {
6056 logger.trace(m, d.get(a1, a2, a3, a4, a5, a6).toString(locale));
6057 }
6058 }
6059
6060 /**
6061 * Logs a trace message with an accompanying exception.
6062 *
6063 * @param <T1>
6064 * The type of the first message argument.
6065 * @param <T2>
6066 * The type of the second message argument.
6067 * @param <T3>
6068 * The type of the third message argument.
6069 * @param <T4>
6070 * The type of the fourth message argument.
6071 * @param <T5>
6072 * The type of the fifth message argument.
6073 * @param <T6>
6074 * The type of the sixth message argument.
6075 * @param m
6076 * The marker tracermation associated with this log message.
6077 * @param d
6078 * The message descriptor.
6079 * @param a1
6080 * The first message argument.
6081 * @param a2
6082 * The second message argument.
6083 * @param a3
6084 * The third message argument.
6085 * @param a4
6086 * The fourth message argument.
6087 * @param a5
6088 * The fifth message argument.
6089 * @param a6
6090 * The sixth message argument.
6091 * @param t
6092 * The throwable to log.
6093 * @see org.slf4j.Logger#trace(String, Throwable)
6094 */
6095 public <T1, T2, T3, T4, T5, T6> void trace(final Marker m,
6096 final Arg6<T1, T2, T3, T4, T5, T6> d, final T1 a1, final T2 a2, final T3 a3,
6097 final T4 a4, final T5 a5, final T6 a6, final Throwable t) {
6098 if (logger.isTraceEnabled(m)) {
6099 logger.trace(m, d.get(a1, a2, a3, a4, a5, a6).toString(locale), t);
6100 }
6101 }
6102
6103 /**
6104 * Logs a trace message.
6105 *
6106 * @param <T1>
6107 * The type of the first message argument.
6108 * @param <T2>
6109 * The type of the second message argument.
6110 * @param <T3>
6111 * The type of the third message argument.
6112 * @param <T4>
6113 * The type of the fourth message argument.
6114 * @param <T5>
6115 * The type of the fifth message argument.
6116 * @param <T6>
6117 * The type of the sixth message argument.
6118 * @param <T7>
6119 * The type of the seventh message argument.
6120 * @param m
6121 * The marker information associated with this log message.
6122 * @param d
6123 * The message descriptor.
6124 * @param a1
6125 * The first message argument.
6126 * @param a2
6127 * The second message argument.
6128 * @param a3
6129 * The third message argument.
6130 * @param a4
6131 * The fourth message argument.
6132 * @param a5
6133 * The fifth message argument.
6134 * @param a6
6135 * The sixth message argument.
6136 * @param a7
6137 * The seventh message argument.
6138 * @see org.slf4j.Logger#trace(String)
6139 */
6140 public <T1, T2, T3, T4, T5, T6, T7> void trace(final Marker m,
6141 final Arg7<T1, T2, T3, T4, T5, T6, T7> d, final T1 a1, final T2 a2, final T3 a3,
6142 final T4 a4, final T5 a5, final T6 a6, final T7 a7) {
6143 if (logger.isTraceEnabled(m)) {
6144 logger.trace(m, d.get(a1, a2, a3, a4, a5, a6, a7).toString(locale));
6145 }
6146 }
6147
6148 /**
6149 * Logs a trace message with an accompanying exception.
6150 *
6151 * @param <T1>
6152 * The type of the first message argument.
6153 * @param <T2>
6154 * The type of the second message argument.
6155 * @param <T3>
6156 * The type of the third message argument.
6157 * @param <T4>
6158 * The type of the fourth message argument.
6159 * @param <T5>
6160 * The type of the fifth message argument.
6161 * @param <T6>
6162 * The type of the sixth message argument.
6163 * @param <T7>
6164 * The type of the seventh message argument.
6165 * @param m
6166 * The marker tracermation associated with this log message.
6167 * @param d
6168 * The message descriptor.
6169 * @param a1
6170 * The first message argument.
6171 * @param a2
6172 * The second message argument.
6173 * @param a3
6174 * The third message argument.
6175 * @param a4
6176 * The fourth message argument.
6177 * @param a5
6178 * The fifth message argument.
6179 * @param a6
6180 * The sixth message argument.
6181 * @param a7
6182 * The seventh message argument.
6183 * @param t
6184 * The throwable to log.
6185 * @see org.slf4j.Logger#trace(String, Throwable)
6186 */
6187 public <T1, T2, T3, T4, T5, T6, T7> void trace(final Marker m,
6188 final Arg7<T1, T2, T3, T4, T5, T6, T7> d, final T1 a1, final T2 a2, final T3 a3,
6189 final T4 a4, final T5 a5, final T6 a6, final T7 a7, final Throwable t) {
6190 if (logger.isTraceEnabled(m)) {
6191 logger.trace(m, d.get(a1, a2, a3, a4, a5, a6, a7).toString(locale), t);
6192 }
6193 }
6194
6195 /**
6196 * Logs a trace message.
6197 *
6198 * @param <T1>
6199 * The type of the first message argument.
6200 * @param <T2>
6201 * The type of the second message argument.
6202 * @param <T3>
6203 * The type of the third message argument.
6204 * @param <T4>
6205 * The type of the fourth message argument.
6206 * @param <T5>
6207 * The type of the fifth message argument.
6208 * @param <T6>
6209 * The type of the sixth message argument.
6210 * @param <T7>
6211 * The type of the seventh message argument.
6212 * @param <T8>
6213 * The type of the eighth message argument.
6214 * @param m
6215 * The marker information associated with this log message.
6216 * @param d
6217 * The message descriptor.
6218 * @param a1
6219 * The first message argument.
6220 * @param a2
6221 * The second message argument.
6222 * @param a3
6223 * The third message argument.
6224 * @param a4
6225 * The fourth message argument.
6226 * @param a5
6227 * The fifth message argument.
6228 * @param a6
6229 * The sixth message argument.
6230 * @param a7
6231 * The seventh message argument.
6232 * @param a8
6233 * The eighth message argument.
6234 * @see org.slf4j.Logger#trace(String)
6235 */
6236 public <T1, T2, T3, T4, T5, T6, T7, T8> void trace(final Marker m,
6237 final Arg8<T1, T2, T3, T4, T5, T6, T7, T8> d, final T1 a1, final T2 a2, final T3 a3,
6238 final T4 a4, final T5 a5, final T6 a6, final T7 a7, final T8 a8) {
6239 if (logger.isTraceEnabled(m)) {
6240 logger.trace(m, d.get(a1, a2, a3, a4, a5, a6, a7, a8).toString(locale));
6241 }
6242 }
6243
6244 /**
6245 * Logs a trace message with an accompanying exception.
6246 *
6247 * @param <T1>
6248 * The type of the first message argument.
6249 * @param <T2>
6250 * The type of the second message argument.
6251 * @param <T3>
6252 * The type of the third message argument.
6253 * @param <T4>
6254 * The type of the fourth message argument.
6255 * @param <T5>
6256 * The type of the fifth message argument.
6257 * @param <T6>
6258 * The type of the sixth message argument.
6259 * @param <T7>
6260 * The type of the seventh message argument.
6261 * @param <T8>
6262 * The type of the eighth message argument.
6263 * @param m
6264 * The marker tracermation associated with this log message.
6265 * @param d
6266 * The message descriptor.
6267 * @param a1
6268 * The first message argument.
6269 * @param a2
6270 * The second message argument.
6271 * @param a3
6272 * The third message argument.
6273 * @param a4
6274 * The fourth message argument.
6275 * @param a5
6276 * The fifth message argument.
6277 * @param a6
6278 * The sixth message argument.
6279 * @param a7
6280 * The seventh message argument.
6281 * @param a8
6282 * The eighth message argument.
6283 * @param t
6284 * The throwable to log.
6285 * @see org.slf4j.Logger#trace(String, Throwable)
6286 */
6287 public <T1, T2, T3, T4, T5, T6, T7, T8> void trace(final Marker m,
6288 final Arg8<T1, T2, T3, T4, T5, T6, T7, T8> d, final T1 a1, final T2 a2, final T3 a3,
6289 final T4 a4, final T5 a5, final T6 a6, final T7 a7, final T8 a8, final Throwable t) {
6290 if (logger.isTraceEnabled(m)) {
6291 logger.trace(m, d.get(a1, a2, a3, a4, a5, a6, a7, a8).toString(locale), t);
6292 }
6293 }
6294
6295 /**
6296 * Logs a trace message.
6297 *
6298 * @param <T1>
6299 * The type of the first message argument.
6300 * @param <T2>
6301 * The type of the second message argument.
6302 * @param <T3>
6303 * The type of the third message argument.
6304 * @param <T4>
6305 * The type of the fourth message argument.
6306 * @param <T5>
6307 * The type of the fifth message argument.
6308 * @param <T6>
6309 * The type of the sixth message argument.
6310 * @param <T7>
6311 * The type of the seventh message argument.
6312 * @param <T8>
6313 * The type of the eighth message argument.
6314 * @param <T9>
6315 * The type of the ninth message argument.
6316 * @param m
6317 * The marker information associated with this log message.
6318 * @param d
6319 * The message descriptor.
6320 * @param a1
6321 * The first message argument.
6322 * @param a2
6323 * The second message argument.
6324 * @param a3
6325 * The third message argument.
6326 * @param a4
6327 * The fourth message argument.
6328 * @param a5
6329 * The fifth message argument.
6330 * @param a6
6331 * The sixth message argument.
6332 * @param a7
6333 * The seventh message argument.
6334 * @param a8
6335 * The eighth message argument.
6336 * @param a9
6337 * The ninth message argument.
6338 * @see org.slf4j.Logger#trace(String)
6339 */
6340 public <T1, T2, T3, T4, T5, T6, T7, T8, T9> void trace(final Marker m,
6341 final Arg9<T1, T2, T3, T4, T5, T6, T7, T8, T9> d, final T1 a1, final T2 a2,
6342 final T3 a3, final T4 a4, final T5 a5, final T6 a6, final T7 a7, final T8 a8,
6343 final T9 a9) {
6344 if (logger.isTraceEnabled(m)) {
6345 logger.trace(m, d.get(a1, a2, a3, a4, a5, a6, a7, a8, a9).toString(locale));
6346 }
6347 }
6348
6349 /**
6350 * Logs a trace message with an accompanying exception.
6351 *
6352 * @param <T1>
6353 * The type of the first message argument.
6354 * @param <T2>
6355 * The type of the second message argument.
6356 * @param <T3>
6357 * The type of the third message argument.
6358 * @param <T4>
6359 * The type of the fourth message argument.
6360 * @param <T5>
6361 * The type of the fifth message argument.
6362 * @param <T6>
6363 * The type of the sixth message argument.
6364 * @param <T7>
6365 * The type of the seventh message argument.
6366 * @param <T8>
6367 * The type of the eighth message argument.
6368 * @param <T9>
6369 * The type of the ninth message argument.
6370 * @param m
6371 * The marker tracermation associated with this log message.
6372 * @param d
6373 * The message descriptor.
6374 * @param a1
6375 * The first message argument.
6376 * @param a2
6377 * The second message argument.
6378 * @param a3
6379 * The third message argument.
6380 * @param a4
6381 * The fourth message argument.
6382 * @param a5
6383 * The fifth message argument.
6384 * @param a6
6385 * The sixth message argument.
6386 * @param a7
6387 * The seventh message argument.
6388 * @param a8
6389 * The eighth message argument.
6390 * @param a9
6391 * The ninth message argument.
6392 * @param t
6393 * The throwable to log.
6394 * @see org.slf4j.Logger#trace(String, Throwable)
6395 */
6396 public <T1, T2, T3, T4, T5, T6, T7, T8, T9> void trace(final Marker m,
6397 final Arg9<T1, T2, T3, T4, T5, T6, T7, T8, T9> d, final T1 a1, final T2 a2,
6398 final T3 a3, final T4 a4, final T5 a5, final T6 a6, final T7 a7, final T8 a8,
6399 final T9 a9, final Throwable t) {
6400 if (logger.isTraceEnabled(m)) {
6401 logger.trace(m, d.get(a1, a2, a3, a4, a5, a6, a7, a8, a9).toString(locale), t);
6402 }
6403 }
6404
6405 /**
6406 * Logs a trace message.
6407 *
6408 * @param m
6409 * The marker information associated with this log message.
6410 * @param d
6411 * The message descriptor.
6412 * @param args
6413 * The message arguments.
6414 * @see org.slf4j.Logger#trace(String)
6415 */
6416 public void trace(final Marker m, final ArgN d, final Object... args) {
6417 if (logger.isTraceEnabled(m)) {
6418 logger.trace(m, d.get(args).toString(locale));
6419 }
6420 }
6421
6422 /**
6423 * Logs a trace message with an accompanying exception.
6424 *
6425 * @param m
6426 * The marker tracermation associated with this log message.
6427 * @param d
6428 * The message descriptor.
6429 * @param t
6430 * The throwable to log.
6431 * @param args
6432 * The message arguments.
6433 * @see org.slf4j.Logger#trace(String, Throwable)
6434 */
6435 public void trace(final Marker m, final ArgN d, final Throwable t, final Object... args) {
6436 if (logger.isTraceEnabled(m)) {
6437 logger.trace(m, d.get(args).toString(locale), t);
6438 }
6439 }
6440
6441 /**
6442 * Logs a warning message.
6443 *
6444 * @param d
6445 * The message descriptor.
6446 * @see org.slf4j.Logger#warn(String)
6447 */
6448 public void warn(final Arg0 d) {
6449 if (logger.isWarnEnabled()) {
6450 final LocalizableMessage message = d.get();
6451 logger.warn(new LocalizedMarker(message), message.toString(locale));
6452 }
6453 }
6454
6455 /**
6456 * Logs a warning message with an accompanying exception.
6457 *
6458 * @param d
6459 * The message descriptor.
6460 * @param t
6461 * The throwable to log.
6462 * @see org.slf4j.Logger#warn(String, Throwable)
6463 */
6464 public void warn(final Arg0 d, final Throwable t) {
6465 if (logger.isWarnEnabled()) {
6466 final LocalizableMessage message = d.get();
6467 logger.warn(new LocalizedMarker(message), message.toString(locale), t);
6468 }
6469 }
6470
6471 /**
6472 * Logs a warning message.
6473 *
6474 * @param <T1>
6475 * The type of the first message argument.
6476 * @param d
6477 * The message descriptor.
6478 * @param a1
6479 * The first message argument.
6480 * @see org.slf4j.Logger#warn(String)
6481 */
6482 public <T1> void warn(final Arg1<T1> d, final T1 a1) {
6483 if (logger.isWarnEnabled()) {
6484 final LocalizableMessage message = d.get(a1);
6485 logger.warn(new LocalizedMarker(message), message.toString(locale));
6486 }
6487 }
6488
6489 /**
6490 * Logs a warning message with an accompanying exception.
6491 *
6492 * @param <T1>
6493 * The type of the first message argument.
6494 * @param d
6495 * The message descriptor.
6496 * @param a1
6497 * The first message argument.
6498 * @param t
6499 * The throwable to log.
6500 * @see org.slf4j.Logger#warn(String, Throwable)
6501 */
6502 public <T1> void warn(final Arg1<T1> d, final T1 a1, final Throwable t) {
6503 if (logger.isWarnEnabled()) {
6504 final LocalizableMessage message = d.get(a1);
6505 logger.warn(new LocalizedMarker(message), message.toString(locale), t);
6506 }
6507 }
6508
6509 /**
6510 * Logs a warning message.
6511 *
6512 * @param <T1>
6513 * The type of the first message argument.
6514 * @param <T2>
6515 * The type of the second message argument.
6516 * @param d
6517 * The message descriptor.
6518 * @param a1
6519 * The first message argument.
6520 * @param a2
6521 * The second message argument.
6522 * @see org.slf4j.Logger#warn(String)
6523 */
6524 public <T1, T2> void warn(final Arg2<T1, T2> d, final T1 a1, final T2 a2) {
6525 if (logger.isWarnEnabled()) {
6526 final LocalizableMessage message = d.get(a1, a2);
6527 logger.warn(new LocalizedMarker(message), message.toString(locale));
6528 }
6529 }
6530
6531 /**
6532 * Logs a warning message with an accompanying exception.
6533 *
6534 * @param <T1>
6535 * The type of the first message argument.
6536 * @param <T2>
6537 * The type of the second message argument.
6538 * @param d
6539 * The message descriptor.
6540 * @param a1
6541 * The first message argument.
6542 * @param a2
6543 * The second message argument.
6544 * @param t
6545 * The throwable to log.
6546 * @see org.slf4j.Logger#warn(String, Throwable)
6547 */
6548 public <T1, T2> void warn(final Arg2<T1, T2> d, final T1 a1, final T2 a2, final Throwable t) {
6549 if (logger.isWarnEnabled()) {
6550 final LocalizableMessage message = d.get(a1, a2);
6551 logger.warn(new LocalizedMarker(message), message.toString(locale), t);
6552 }
6553 }
6554
6555 /**
6556 * Logs a warning message.
6557 *
6558 * @param <T1>
6559 * The type of the first message argument.
6560 * @param <T2>
6561 * The type of the second message argument.
6562 * @param <T3>
6563 * The type of the third message argument.
6564 * @param d
6565 * The message descriptor.
6566 * @param a1
6567 * The first message argument.
6568 * @param a2
6569 * The second message argument.
6570 * @param a3
6571 * The third message argument.
6572 * @see org.slf4j.Logger#warn(String)
6573 */
6574 public <T1, T2, T3> void warn(final Arg3<T1, T2, T3> d, final T1 a1, final T2 a2, final T3 a3) {
6575 if (logger.isWarnEnabled()) {
6576 final LocalizableMessage message = d.get(a1, a2, a3);
6577 logger.warn(new LocalizedMarker(message), message.toString(locale));
6578 }
6579 }
6580
6581 /**
6582 * Logs a warning message with an accompanying exception.
6583 *
6584 * @param <T1>
6585 * The type of the first message argument.
6586 * @param <T2>
6587 * The type of the second message argument.
6588 * @param <T3>
6589 * The type of the third message argument.
6590 * @param d
6591 * The message descriptor.
6592 * @param a1
6593 * The first message argument.
6594 * @param a2
6595 * The second message argument.
6596 * @param a3
6597 * The third message argument.
6598 * @param t
6599 * The throwable to log.
6600 * @see org.slf4j.Logger#warn(String, Throwable)
6601 */
6602 public <T1, T2, T3> void warn(final Arg3<T1, T2, T3> d, final T1 a1, final T2 a2, final T3 a3,
6603 final Throwable t) {
6604 if (logger.isWarnEnabled()) {
6605 final LocalizableMessage message = d.get(a1, a2, a3);
6606 logger.warn(new LocalizedMarker(message), message.toString(locale), t);
6607 }
6608 }
6609
6610 /**
6611 * Logs a warning message.
6612 *
6613 * @param <T1>
6614 * The type of the first message argument.
6615 * @param <T2>
6616 * The type of the second message argument.
6617 * @param <T3>
6618 * The type of the third message argument.
6619 * @param <T4>
6620 * The type of the fourth message argument.
6621 * @param d
6622 * The message descriptor.
6623 * @param a1
6624 * The first message argument.
6625 * @param a2
6626 * The second message argument.
6627 * @param a3
6628 * The third message argument.
6629 * @param a4
6630 * The fourth message argument.
6631 * @see org.slf4j.Logger#warn(String)
6632 */
6633 public <T1, T2, T3, T4> void warn(final Arg4<T1, T2, T3, T4> d, final T1 a1, final T2 a2,
6634 final T3 a3, final T4 a4) {
6635 if (logger.isWarnEnabled()) {
6636 final LocalizableMessage message = d.get(a1, a2, a3, a4);
6637 logger.warn(new LocalizedMarker(message), message.toString(locale));
6638 }
6639 }
6640
6641 /**
6642 * Logs a warning message with an accompanying exception.
6643 *
6644 * @param <T1>
6645 * The type of the first message argument.
6646 * @param <T2>
6647 * The type of the second message argument.
6648 * @param <T3>
6649 * The type of the third message argument.
6650 * @param <T4>
6651 * The type of the fourth message argument.
6652 * @param d
6653 * The message descriptor.
6654 * @param a1
6655 * The first message argument.
6656 * @param a2
6657 * The second message argument.
6658 * @param a3
6659 * The third message argument.
6660 * @param a4
6661 * The fourth message argument.
6662 * @param t
6663 * The throwable to log.
6664 * @see org.slf4j.Logger#warn(String, Throwable)
6665 */
6666 public <T1, T2, T3, T4> void warn(final Arg4<T1, T2, T3, T4> d, final T1 a1, final T2 a2,
6667 final T3 a3, final T4 a4, final Throwable t) {
6668 if (logger.isWarnEnabled()) {
6669 final LocalizableMessage message = d.get(a1, a2, a3, a4);
6670 logger.warn(new LocalizedMarker(message), message.toString(locale), t);
6671 }
6672 }
6673
6674 /**
6675 * Logs a warning message.
6676 *
6677 * @param <T1>
6678 * The type of the first message argument.
6679 * @param <T2>
6680 * The type of the second message argument.
6681 * @param <T3>
6682 * The type of the third message argument.
6683 * @param <T4>
6684 * The type of the fourth message argument.
6685 * @param <T5>
6686 * The type of the fifth message argument.
6687 * @param d
6688 * The message descriptor.
6689 * @param a1
6690 * The first message argument.
6691 * @param a2
6692 * The second message argument.
6693 * @param a3
6694 * The third message argument.
6695 * @param a4
6696 * The fourth message argument.
6697 * @param a5
6698 * The fifth message argument.
6699 * @see org.slf4j.Logger#warn(String)
6700 */
6701 public <T1, T2, T3, T4, T5> void warn(final Arg5<T1, T2, T3, T4, T5> d, final T1 a1,
6702 final T2 a2, final T3 a3, final T4 a4, final T5 a5) {
6703 if (logger.isWarnEnabled()) {
6704 final LocalizableMessage message = d.get(a1, a2, a3, a4, a5);
6705 logger.warn(new LocalizedMarker(message), message.toString(locale));
6706 }
6707 }
6708
6709 /**
6710 * Logs a warning message with an accompanying exception.
6711 *
6712 * @param <T1>
6713 * The type of the first message argument.
6714 * @param <T2>
6715 * The type of the second message argument.
6716 * @param <T3>
6717 * The type of the third message argument.
6718 * @param <T4>
6719 * The type of the fourth message argument.
6720 * @param <T5>
6721 * The type of the fifth message argument.
6722 * @param d
6723 * The message descriptor.
6724 * @param a1
6725 * The first message argument.
6726 * @param a2
6727 * The second message argument.
6728 * @param a3
6729 * The third message argument.
6730 * @param a4
6731 * The fourth message argument.
6732 * @param a5
6733 * The fifth message argument.
6734 * @param t
6735 * The throwable to log.
6736 * @see org.slf4j.Logger#warn(String, Throwable)
6737 */
6738 public <T1, T2, T3, T4, T5> void warn(final Arg5<T1, T2, T3, T4, T5> d, final T1 a1,
6739 final T2 a2, final T3 a3, final T4 a4, final T5 a5, final Throwable t) {
6740 if (logger.isWarnEnabled()) {
6741 final LocalizableMessage message = d.get(a1, a2, a3, a4, a5);
6742 logger.warn(new LocalizedMarker(message), message.toString(locale), t);
6743 }
6744 }
6745
6746 /**
6747 * Logs a warning message.
6748 *
6749 * @param <T1>
6750 * The type of the first message argument.
6751 * @param <T2>
6752 * The type of the second message argument.
6753 * @param <T3>
6754 * The type of the third message argument.
6755 * @param <T4>
6756 * The type of the fourth message argument.
6757 * @param <T5>
6758 * The type of the fifth message argument.
6759 * @param <T6>
6760 * The type of the sixth message argument.
6761 * @param d
6762 * The message descriptor.
6763 * @param a1
6764 * The first message argument.
6765 * @param a2
6766 * The second message argument.
6767 * @param a3
6768 * The third message argument.
6769 * @param a4
6770 * The fourth message argument.
6771 * @param a5
6772 * The fifth message argument.
6773 * @param a6
6774 * The sixth message argument.
6775 * @see org.slf4j.Logger#warn(String)
6776 */
6777 public <T1, T2, T3, T4, T5, T6> void warn(final Arg6<T1, T2, T3, T4, T5, T6> d, final T1 a1,
6778 final T2 a2, final T3 a3, final T4 a4, final T5 a5, final T6 a6) {
6779 if (logger.isWarnEnabled()) {
6780 final LocalizableMessage message = d.get(a1, a2, a3, a4, a5, a6);
6781 logger.warn(new LocalizedMarker(message), message.toString(locale));
6782 }
6783 }
6784
6785 /**
6786 * Logs a warning message with an accompanying exception.
6787 *
6788 * @param <T1>
6789 * The type of the first message argument.
6790 * @param <T2>
6791 * The type of the second message argument.
6792 * @param <T3>
6793 * The type of the third message argument.
6794 * @param <T4>
6795 * The type of the fourth message argument.
6796 * @param <T5>
6797 * The type of the fifth message argument.
6798 * @param <T6>
6799 * The type of the sixth message argument.
6800 * @param d
6801 * The message descriptor.
6802 * @param a1
6803 * The first message argument.
6804 * @param a2
6805 * The second message argument.
6806 * @param a3
6807 * The third message argument.
6808 * @param a4
6809 * The fourth message argument.
6810 * @param a5
6811 * The fifth message argument.
6812 * @param a6
6813 * The sixth message argument.
6814 * @param t
6815 * The throwable to log.
6816 * @see org.slf4j.Logger#warn(String, Throwable)
6817 */
6818 public <T1, T2, T3, T4, T5, T6> void warn(final Arg6<T1, T2, T3, T4, T5, T6> d, final T1 a1,
6819 final T2 a2, final T3 a3, final T4 a4, final T5 a5, final T6 a6, final Throwable t) {
6820 if (logger.isWarnEnabled()) {
6821 final LocalizableMessage message = d.get(a1, a2, a3, a4, a5, a6);
6822 logger.warn(new LocalizedMarker(message), message.toString(locale), t);
6823 }
6824 }
6825
6826 /**
6827 * Logs a warning message.
6828 *
6829 * @param <T1>
6830 * The type of the first message argument.
6831 * @param <T2>
6832 * The type of the second message argument.
6833 * @param <T3>
6834 * The type of the third message argument.
6835 * @param <T4>
6836 * The type of the fourth message argument.
6837 * @param <T5>
6838 * The type of the fifth message argument.
6839 * @param <T6>
6840 * The type of the sixth message argument.
6841 * @param <T7>
6842 * The type of the seventh message argument.
6843 * @param d
6844 * The message descriptor.
6845 * @param a1
6846 * The first message argument.
6847 * @param a2
6848 * The second message argument.
6849 * @param a3
6850 * The third message argument.
6851 * @param a4
6852 * The fourth message argument.
6853 * @param a5
6854 * The fifth message argument.
6855 * @param a6
6856 * The sixth message argument.
6857 * @param a7
6858 * The seventh message argument.
6859 * @see org.slf4j.Logger#warn(String)
6860 */
6861 public <T1, T2, T3, T4, T5, T6, T7> void warn(final Arg7<T1, T2, T3, T4, T5, T6, T7> d,
6862 final T1 a1, final T2 a2, final T3 a3, final T4 a4, final T5 a5, final T6 a6,
6863 final T7 a7) {
6864 if (logger.isWarnEnabled()) {
6865 final LocalizableMessage message = d.get(a1, a2, a3, a4, a5, a6, a7);
6866 logger.warn(new LocalizedMarker(message), message.toString(locale));
6867 }
6868 }
6869
6870 /**
6871 * Logs a warning message with an accompanying exception.
6872 *
6873 * @param <T1>
6874 * The type of the first message argument.
6875 * @param <T2>
6876 * The type of the second message argument.
6877 * @param <T3>
6878 * The type of the third message argument.
6879 * @param <T4>
6880 * The type of the fourth message argument.
6881 * @param <T5>
6882 * The type of the fifth message argument.
6883 * @param <T6>
6884 * The type of the sixth message argument.
6885 * @param <T7>
6886 * The type of the seventh message argument.
6887 * @param d
6888 * The message descriptor.
6889 * @param a1
6890 * The first message argument.
6891 * @param a2
6892 * The second message argument.
6893 * @param a3
6894 * The third message argument.
6895 * @param a4
6896 * The fourth message argument.
6897 * @param a5
6898 * The fifth message argument.
6899 * @param a6
6900 * The sixth message argument.
6901 * @param a7
6902 * The seventh message argument.
6903 * @param t
6904 * The throwable to log.
6905 * @see org.slf4j.Logger#warn(String, Throwable)
6906 */
6907 public <T1, T2, T3, T4, T5, T6, T7> void warn(final Arg7<T1, T2, T3, T4, T5, T6, T7> d,
6908 final T1 a1, final T2 a2, final T3 a3, final T4 a4, final T5 a5, final T6 a6,
6909 final T7 a7, final Throwable t) {
6910 if (logger.isWarnEnabled()) {
6911 final LocalizableMessage message = d.get(a1, a2, a3, a4, a5, a6, a7);
6912 logger.warn(new LocalizedMarker(message), message.toString(locale), t);
6913 }
6914 }
6915
6916 /**
6917 * Logs a warning message.
6918 *
6919 * @param <T1>
6920 * The type of the first message argument.
6921 * @param <T2>
6922 * The type of the second message argument.
6923 * @param <T3>
6924 * The type of the third message argument.
6925 * @param <T4>
6926 * The type of the fourth message argument.
6927 * @param <T5>
6928 * The type of the fifth message argument.
6929 * @param <T6>
6930 * The type of the sixth message argument.
6931 * @param <T7>
6932 * The type of the seventh message argument.
6933 * @param <T8>
6934 * The type of the eighth message argument.
6935 * @param d
6936 * The message descriptor.
6937 * @param a1
6938 * The first message argument.
6939 * @param a2
6940 * The second message argument.
6941 * @param a3
6942 * The third message argument.
6943 * @param a4
6944 * The fourth message argument.
6945 * @param a5
6946 * The fifth message argument.
6947 * @param a6
6948 * The sixth message argument.
6949 * @param a7
6950 * The seventh message argument.
6951 * @param a8
6952 * The eighth message argument.
6953 * @see org.slf4j.Logger#warn(String)
6954 */
6955 public <T1, T2, T3, T4, T5, T6, T7, T8> void warn(final Arg8<T1, T2, T3, T4, T5, T6, T7, T8> d,
6956 final T1 a1, final T2 a2, final T3 a3, final T4 a4, final T5 a5, final T6 a6,
6957 final T7 a7, final T8 a8) {
6958 if (logger.isWarnEnabled()) {
6959 final LocalizableMessage message = d.get(a1, a2, a3, a4, a5, a6, a7, a8);
6960 logger.warn(new LocalizedMarker(message), message.toString(locale));
6961 }
6962 }
6963
6964 /**
6965 * Logs a warning message with an accompanying exception.
6966 *
6967 * @param <T1>
6968 * The type of the first message argument.
6969 * @param <T2>
6970 * The type of the second message argument.
6971 * @param <T3>
6972 * The type of the third message argument.
6973 * @param <T4>
6974 * The type of the fourth message argument.
6975 * @param <T5>
6976 * The type of the fifth message argument.
6977 * @param <T6>
6978 * The type of the sixth message argument.
6979 * @param <T7>
6980 * The type of the seventh message argument.
6981 * @param <T8>
6982 * The type of the eighth message argument.
6983 * @param d
6984 * The message descriptor.
6985 * @param a1
6986 * The first message argument.
6987 * @param a2
6988 * The second message argument.
6989 * @param a3
6990 * The third message argument.
6991 * @param a4
6992 * The fourth message argument.
6993 * @param a5
6994 * The fifth message argument.
6995 * @param a6
6996 * The sixth message argument.
6997 * @param a7
6998 * The seventh message argument.
6999 * @param a8
7000 * The eighth message argument.
7001 * @param t
7002 * The throwable to log.
7003 * @see org.slf4j.Logger#warn(String, Throwable)
7004 */
7005 public <T1, T2, T3, T4, T5, T6, T7, T8> void warn(final Arg8<T1, T2, T3, T4, T5, T6, T7, T8> d,
7006 final T1 a1, final T2 a2, final T3 a3, final T4 a4, final T5 a5, final T6 a6,
7007 final T7 a7, final T8 a8, final Throwable t) {
7008 if (logger.isWarnEnabled()) {
7009 final LocalizableMessage message = d.get(a1, a2, a3, a4, a5, a6, a7, a8);
7010 logger.warn(new LocalizedMarker(message), message.toString(locale), t);
7011 }
7012 }
7013
7014 /**
7015 * Logs a warning message.
7016 *
7017 * @param <T1>
7018 * The type of the first message argument.
7019 * @param <T2>
7020 * The type of the second message argument.
7021 * @param <T3>
7022 * The type of the third message argument.
7023 * @param <T4>
7024 * The type of the fourth message argument.
7025 * @param <T5>
7026 * The type of the fifth message argument.
7027 * @param <T6>
7028 * The type of the sixth message argument.
7029 * @param <T7>
7030 * The type of the seventh message argument.
7031 * @param <T8>
7032 * The type of the eighth message argument.
7033 * @param <T9>
7034 * The type of the ninth message argument.
7035 * @param d
7036 * The message descriptor.
7037 * @param a1
7038 * The first message argument.
7039 * @param a2
7040 * The second message argument.
7041 * @param a3
7042 * The third message argument.
7043 * @param a4
7044 * The fourth message argument.
7045 * @param a5
7046 * The fifth message argument.
7047 * @param a6
7048 * The sixth message argument.
7049 * @param a7
7050 * The seventh message argument.
7051 * @param a8
7052 * The eighth message argument.
7053 * @param a9
7054 * The ninth message argument.
7055 * @see org.slf4j.Logger#warn(String)
7056 */
7057 public <T1, T2, T3, T4, T5, T6, T7, T8, T9> void warn(
7058 final Arg9<T1, T2, T3, T4, T5, T6, T7, T8, T9> d, final T1 a1, final T2 a2,
7059 final T3 a3, final T4 a4, final T5 a5, final T6 a6, final T7 a7, final T8 a8,
7060 final T9 a9) {
7061 if (logger.isWarnEnabled()) {
7062 final LocalizableMessage message = d.get(a1, a2, a3, a4, a5, a6, a7, a8, a9);
7063 logger.warn(new LocalizedMarker(message), message.toString(locale));
7064 }
7065 }
7066
7067 /**
7068 * Logs a warning message with an accompanying exception.
7069 *
7070 * @param <T1>
7071 * The type of the first message argument.
7072 * @param <T2>
7073 * The type of the second message argument.
7074 * @param <T3>
7075 * The type of the third message argument.
7076 * @param <T4>
7077 * The type of the fourth message argument.
7078 * @param <T5>
7079 * The type of the fifth message argument.
7080 * @param <T6>
7081 * The type of the sixth message argument.
7082 * @param <T7>
7083 * The type of the seventh message argument.
7084 * @param <T8>
7085 * The type of the eighth message argument.
7086 * @param <T9>
7087 * The type of the ninth message argument.
7088 * @param d
7089 * The message descriptor.
7090 * @param a1
7091 * The first message argument.
7092 * @param a2
7093 * The second message argument.
7094 * @param a3
7095 * The third message argument.
7096 * @param a4
7097 * The fourth message argument.
7098 * @param a5
7099 * The fifth message argument.
7100 * @param a6
7101 * The sixth message argument.
7102 * @param a7
7103 * The seventh message argument.
7104 * @param a8
7105 * The eighth message argument.
7106 * @param a9
7107 * The ninth message argument.
7108 * @param t
7109 * The throwable to log.
7110 * @see org.slf4j.Logger#warn(String, Throwable)
7111 */
7112 public <T1, T2, T3, T4, T5, T6, T7, T8, T9> void warn(
7113 final Arg9<T1, T2, T3, T4, T5, T6, T7, T8, T9> d, final T1 a1, final T2 a2,
7114 final T3 a3, final T4 a4, final T5 a5, final T6 a6, final T7 a7, final T8 a8,
7115 final T9 a9, final Throwable t) {
7116 if (logger.isWarnEnabled()) {
7117 final LocalizableMessage message = d.get(a1, a2, a3, a4, a5, a6, a7, a8, a9);
7118 logger.warn(new LocalizedMarker(message), message.toString(locale), t);
7119 }
7120 }
7121
7122 /**
7123 * Logs a warning message.
7124 *
7125 * @param d
7126 * The message descriptor.
7127 * @param args
7128 * The message arguments.
7129 * @see org.slf4j.Logger#warn(String)
7130 */
7131 public void warn(final ArgN d, final Object... args) {
7132 if (logger.isWarnEnabled()) {
7133 final LocalizableMessage message = d.get(args);
7134 logger.warn(new LocalizedMarker(message), message.toString(locale));
7135 }
7136 }
7137
7138 /**
7139 * Logs a warning message with an accompanying exception.
7140 *
7141 * @param d
7142 * The message descriptor.
7143 * @param t
7144 * The throwable to log.
7145 * @param args
7146 * The message arguments.
7147 * @see org.slf4j.Logger#warn(String, Throwable)
7148 */
7149 public void warn(final ArgN d, final Throwable t, final Object... args) {
7150 if (logger.isWarnEnabled()) {
7151 final LocalizableMessage message = d.get(args);
7152 logger.warn(new LocalizedMarker(message), message.toString(locale), t);
7153 }
7154 }
7155
7156 /**
7157 * Logs a warning message.
7158 *
7159 * @param m
7160 * The pre-formatted message.
7161 * @see org.slf4j.Logger#warn(String)
7162 */
7163 public void warn(final LocalizableMessage m) {
7164 if (logger.isWarnEnabled()) {
7165 logger.warn(new LocalizedMarker(m), m.toString(locale));
7166 }
7167 }
7168
7169 /**
7170 * Logs a warning message with an accompanying exception.
7171 *
7172 * @param m
7173 * The pre-formatted message.
7174 * @param t
7175 * The throwable to log.
7176 * @see org.slf4j.Logger#warn(String, Throwable)
7177 */
7178 public void warn(final LocalizableMessage m, final Throwable t) {
7179 if (logger.isWarnEnabled()) {
7180 logger.warn(new LocalizedMarker(m), m.toString(locale), t);
7181 }
7182 }
7183
7184 /**
7185 * Logs a warning message using the provided {@code Marker}.
7186 *
7187 * @param m
7188 * The marker information associated with this log message.
7189 * @param d
7190 * The message descriptor.
7191 * @see org.slf4j.Logger#warn(org.slf4j.Marker, String)
7192 */
7193 public void warn(final Marker m, final Arg0 d) {
7194 if (logger.isWarnEnabled(m)) {
7195 logger.warn(m, d.get().toString(locale));
7196 }
7197 }
7198
7199 /**
7200 * Logs a warning message using the provided {@code Marker}.
7201 *
7202 * @param m
7203 * The marker warnrmation associated with this log message.
7204 * @param d
7205 * The message descriptor.
7206 * @param t
7207 * The throwable to log.
7208 * @see org.slf4j.Logger#warn(org.slf4j.Marker, String)
7209 */
7210 public void warn(final Marker m, final Arg0 d, final Throwable t) {
7211 if (logger.isWarnEnabled(m)) {
7212 logger.warn(m, d.get().toString(locale), t);
7213 }
7214 }
7215
7216 /**
7217 * Logs a warning message.
7218 *
7219 * @param <T1>
7220 * The type of the first message argument.
7221 * @param m
7222 * The marker information associated with this log message.
7223 * @param d
7224 * The message descriptor.
7225 * @param a1
7226 * The first message argument.
7227 * @see org.slf4j.Logger#warn(String)
7228 */
7229 public <T1> void warn(final Marker m, final Arg1<T1> d, final T1 a1) {
7230 if (logger.isWarnEnabled(m)) {
7231 logger.warn(m, d.get(a1).toString(locale));
7232 }
7233 }
7234
7235 /**
7236 * Logs a warning message with an accompanying exception.
7237 *
7238 * @param <T1>
7239 * The type of the first message argument.
7240 * @param m
7241 * The marker warnrmation associated with this log message.
7242 * @param d
7243 * The message descriptor.
7244 * @param a1
7245 * The first message argument.
7246 * @param t
7247 * The throwable to log.
7248 * @see org.slf4j.Logger#warn(String, Throwable)
7249 */
7250 public <T1> void warn(final Marker m, final Arg1<T1> d, final T1 a1, final Throwable t) {
7251 if (logger.isWarnEnabled(m)) {
7252 logger.warn(m, d.get(a1).toString(locale), t);
7253 }
7254 }
7255
7256 /**
7257 * Logs a warning message.
7258 *
7259 * @param <T1>
7260 * The type of the first message argument.
7261 * @param <T2>
7262 * The type of the second message argument.
7263 * @param m
7264 * The marker information associated with this log message.
7265 * @param d
7266 * The message descriptor.
7267 * @param a1
7268 * The first message argument.
7269 * @param a2
7270 * The second message argument.
7271 * @see org.slf4j.Logger#warn(String)
7272 */
7273 public <T1, T2> void warn(final Marker m, final Arg2<T1, T2> d, final T1 a1, final T2 a2) {
7274 if (logger.isWarnEnabled(m)) {
7275 logger.warn(m, d.get(a1, a2).toString(locale));
7276 }
7277 }
7278
7279 /**
7280 * Logs a warning message with an accompanying exception.
7281 *
7282 * @param <T1>
7283 * The type of the first message argument.
7284 * @param <T2>
7285 * The type of the second message argument.
7286 * @param m
7287 * The marker warnrmation associated with this log message.
7288 * @param d
7289 * The message descriptor.
7290 * @param a1
7291 * The first message argument.
7292 * @param a2
7293 * The second message argument.
7294 * @param t
7295 * The throwable to log.
7296 * @see org.slf4j.Logger#warn(String, Throwable)
7297 */
7298 public <T1, T2> void warn(final Marker m, final Arg2<T1, T2> d, final T1 a1, final T2 a2,
7299 final Throwable t) {
7300 if (logger.isWarnEnabled(m)) {
7301 logger.warn(m, d.get(a1, a2).toString(locale), t);
7302 }
7303 }
7304
7305 /**
7306 * Logs a warning message.
7307 *
7308 * @param <T1>
7309 * The type of the first message argument.
7310 * @param <T2>
7311 * The type of the second message argument.
7312 * @param <T3>
7313 * The type of the third message argument.
7314 * @param m
7315 * The marker information associated with this log message.
7316 * @param d
7317 * The message descriptor.
7318 * @param a1
7319 * The first message argument.
7320 * @param a2
7321 * The second message argument.
7322 * @param a3
7323 * The third message argument.
7324 * @see org.slf4j.Logger#warn(String)
7325 */
7326 public <T1, T2, T3> void warn(final Marker m, final Arg3<T1, T2, T3> d, final T1 a1,
7327 final T2 a2, final T3 a3) {
7328 if (logger.isWarnEnabled(m)) {
7329 logger.warn(m, d.get(a1, a2, a3).toString(locale));
7330 }
7331 }
7332
7333 /**
7334 * Logs a warning message with an accompanying exception.
7335 *
7336 * @param <T1>
7337 * The type of the first message argument.
7338 * @param <T2>
7339 * The type of the second message argument.
7340 * @param <T3>
7341 * The type of the third message argument.
7342 * @param m
7343 * The marker warnrmation associated with this log message.
7344 * @param d
7345 * The message descriptor.
7346 * @param a1
7347 * The first message argument.
7348 * @param a2
7349 * The second message argument.
7350 * @param a3
7351 * The third message argument.
7352 * @param t
7353 * The throwable to log.
7354 * @see org.slf4j.Logger#warn(String, Throwable)
7355 */
7356 public <T1, T2, T3> void warn(final Marker m, final Arg3<T1, T2, T3> d, final T1 a1,
7357 final T2 a2, final T3 a3, final Throwable t) {
7358 if (logger.isWarnEnabled(m)) {
7359 logger.warn(m, d.get(a1, a2, a3).toString(locale), t);
7360 }
7361 }
7362
7363 /**
7364 * Logs a warning message.
7365 *
7366 * @param <T1>
7367 * The type of the first message argument.
7368 * @param <T2>
7369 * The type of the second message argument.
7370 * @param <T3>
7371 * The type of the third message argument.
7372 * @param <T4>
7373 * The type of the fourth message argument.
7374 * @param m
7375 * The marker information associated with this log message.
7376 * @param d
7377 * The message descriptor.
7378 * @param a1
7379 * The first message argument.
7380 * @param a2
7381 * The second message argument.
7382 * @param a3
7383 * The third message argument.
7384 * @param a4
7385 * The fourth message argument.
7386 * @see org.slf4j.Logger#warn(String)
7387 */
7388 public <T1, T2, T3, T4> void warn(final Marker m, final Arg4<T1, T2, T3, T4> d, final T1 a1,
7389 final T2 a2, final T3 a3, final T4 a4) {
7390 if (logger.isWarnEnabled(m)) {
7391 logger.warn(m, d.get(a1, a2, a3, a4).toString(locale));
7392 }
7393 }
7394
7395 /**
7396 * Logs a warning message with an accompanying exception.
7397 *
7398 * @param <T1>
7399 * The type of the first message argument.
7400 * @param <T2>
7401 * The type of the second message argument.
7402 * @param <T3>
7403 * The type of the third message argument.
7404 * @param <T4>
7405 * The type of the fourth message argument.
7406 * @param m
7407 * The marker warnrmation associated with this log message.
7408 * @param d
7409 * The message descriptor.
7410 * @param a1
7411 * The first message argument.
7412 * @param a2
7413 * The second message argument.
7414 * @param a3
7415 * The third message argument.
7416 * @param a4
7417 * The fourth message argument.
7418 * @param t
7419 * The throwable to log.
7420 * @see org.slf4j.Logger#warn(String, Throwable)
7421 */
7422 public <T1, T2, T3, T4> void warn(final Marker m, final Arg4<T1, T2, T3, T4> d, final T1 a1,
7423 final T2 a2, final T3 a3, final T4 a4, final Throwable t) {
7424 if (logger.isWarnEnabled(m)) {
7425 logger.warn(m, d.get(a1, a2, a3, a4).toString(locale), t);
7426 }
7427 }
7428
7429 /**
7430 * Logs a warning message.
7431 *
7432 * @param <T1>
7433 * The type of the first message argument.
7434 * @param <T2>
7435 * The type of the second message argument.
7436 * @param <T3>
7437 * The type of the third message argument.
7438 * @param <T4>
7439 * The type of the fourth message argument.
7440 * @param <T5>
7441 * The type of the fifth message argument.
7442 * @param m
7443 * The marker information associated with this log message.
7444 * @param d
7445 * The message descriptor.
7446 * @param a1
7447 * The first message argument.
7448 * @param a2
7449 * The second message argument.
7450 * @param a3
7451 * The third message argument.
7452 * @param a4
7453 * The fourth message argument.
7454 * @param a5
7455 * The fifth message argument.
7456 * @see org.slf4j.Logger#warn(String)
7457 */
7458 public <T1, T2, T3, T4, T5> void warn(final Marker m, final Arg5<T1, T2, T3, T4, T5> d,
7459 final T1 a1, final T2 a2, final T3 a3, final T4 a4, final T5 a5) {
7460 if (logger.isWarnEnabled(m)) {
7461 logger.warn(m, d.get(a1, a2, a3, a4, a5).toString(locale));
7462 }
7463 }
7464
7465 /**
7466 * Logs a warning message with an accompanying exception.
7467 *
7468 * @param <T1>
7469 * The type of the first message argument.
7470 * @param <T2>
7471 * The type of the second message argument.
7472 * @param <T3>
7473 * The type of the third message argument.
7474 * @param <T4>
7475 * The type of the fourth message argument.
7476 * @param <T5>
7477 * The type of the fifth message argument.
7478 * @param m
7479 * The marker warnrmation associated with this log message.
7480 * @param d
7481 * The message descriptor.
7482 * @param a1
7483 * The first message argument.
7484 * @param a2
7485 * The second message argument.
7486 * @param a3
7487 * The third message argument.
7488 * @param a4
7489 * The fourth message argument.
7490 * @param a5
7491 * The fifth message argument.
7492 * @param t
7493 * The throwable to log.
7494 * @see org.slf4j.Logger#warn(String, Throwable)
7495 */
7496 public <T1, T2, T3, T4, T5> void warn(final Marker m, final Arg5<T1, T2, T3, T4, T5> d,
7497 final T1 a1, final T2 a2, final T3 a3, final T4 a4, final T5 a5, final Throwable t) {
7498 if (logger.isWarnEnabled(m)) {
7499 logger.warn(m, d.get(a1, a2, a3, a4, a5).toString(locale), t);
7500 }
7501 }
7502
7503 /**
7504 * Logs a warning message.
7505 *
7506 * @param <T1>
7507 * The type of the first message argument.
7508 * @param <T2>
7509 * The type of the second message argument.
7510 * @param <T3>
7511 * The type of the third message argument.
7512 * @param <T4>
7513 * The type of the fourth message argument.
7514 * @param <T5>
7515 * The type of the fifth message argument.
7516 * @param <T6>
7517 * The type of the sixth message argument.
7518 * @param m
7519 * The marker information associated with this log message.
7520 * @param d
7521 * The message descriptor.
7522 * @param a1
7523 * The first message argument.
7524 * @param a2
7525 * The second message argument.
7526 * @param a3
7527 * The third message argument.
7528 * @param a4
7529 * The fourth message argument.
7530 * @param a5
7531 * The fifth message argument.
7532 * @param a6
7533 * The sixth message argument.
7534 * @see org.slf4j.Logger#warn(String)
7535 */
7536 public <T1, T2, T3, T4, T5, T6> void warn(final Marker m, final Arg6<T1, T2, T3, T4, T5, T6> d,
7537 final T1 a1, final T2 a2, final T3 a3, final T4 a4, final T5 a5, final T6 a6) {
7538 if (logger.isWarnEnabled(m)) {
7539 logger.warn(m, d.get(a1, a2, a3, a4, a5, a6).toString(locale));
7540 }
7541 }
7542
7543 /**
7544 * Logs a warning message with an accompanying exception.
7545 *
7546 * @param <T1>
7547 * The type of the first message argument.
7548 * @param <T2>
7549 * The type of the second message argument.
7550 * @param <T3>
7551 * The type of the third message argument.
7552 * @param <T4>
7553 * The type of the fourth message argument.
7554 * @param <T5>
7555 * The type of the fifth message argument.
7556 * @param <T6>
7557 * The type of the sixth message argument.
7558 * @param m
7559 * The marker warnrmation associated with this log message.
7560 * @param d
7561 * The message descriptor.
7562 * @param a1
7563 * The first message argument.
7564 * @param a2
7565 * The second message argument.
7566 * @param a3
7567 * The third message argument.
7568 * @param a4
7569 * The fourth message argument.
7570 * @param a5
7571 * The fifth message argument.
7572 * @param a6
7573 * The sixth message argument.
7574 * @param t
7575 * The throwable to log.
7576 * @see org.slf4j.Logger#warn(String, Throwable)
7577 */
7578 public <T1, T2, T3, T4, T5, T6> void warn(final Marker m, final Arg6<T1, T2, T3, T4, T5, T6> d,
7579 final T1 a1, final T2 a2, final T3 a3, final T4 a4, final T5 a5, final T6 a6,
7580 final Throwable t) {
7581 if (logger.isWarnEnabled(m)) {
7582 logger.warn(m, d.get(a1, a2, a3, a4, a5, a6).toString(locale), t);
7583 }
7584 }
7585
7586 /**
7587 * Logs a warning message.
7588 *
7589 * @param <T1>
7590 * The type of the first message argument.
7591 * @param <T2>
7592 * The type of the second message argument.
7593 * @param <T3>
7594 * The type of the third message argument.
7595 * @param <T4>
7596 * The type of the fourth message argument.
7597 * @param <T5>
7598 * The type of the fifth message argument.
7599 * @param <T6>
7600 * The type of the sixth message argument.
7601 * @param <T7>
7602 * The type of the seventh message argument.
7603 * @param m
7604 * The marker information associated with this log message.
7605 * @param d
7606 * The message descriptor.
7607 * @param a1
7608 * The first message argument.
7609 * @param a2
7610 * The second message argument.
7611 * @param a3
7612 * The third message argument.
7613 * @param a4
7614 * The fourth message argument.
7615 * @param a5
7616 * The fifth message argument.
7617 * @param a6
7618 * The sixth message argument.
7619 * @param a7
7620 * The seventh message argument.
7621 * @see org.slf4j.Logger#warn(String)
7622 */
7623 public <T1, T2, T3, T4, T5, T6, T7> void warn(final Marker m,
7624 final Arg7<T1, T2, T3, T4, T5, T6, T7> d, final T1 a1, final T2 a2, final T3 a3,
7625 final T4 a4, final T5 a5, final T6 a6, final T7 a7) {
7626 if (logger.isWarnEnabled(m)) {
7627 logger.warn(m, d.get(a1, a2, a3, a4, a5, a6, a7).toString(locale));
7628 }
7629 }
7630
7631 /**
7632 * Logs a warning message with an accompanying exception.
7633 *
7634 * @param <T1>
7635 * The type of the first message argument.
7636 * @param <T2>
7637 * The type of the second message argument.
7638 * @param <T3>
7639 * The type of the third message argument.
7640 * @param <T4>
7641 * The type of the fourth message argument.
7642 * @param <T5>
7643 * The type of the fifth message argument.
7644 * @param <T6>
7645 * The type of the sixth message argument.
7646 * @param <T7>
7647 * The type of the seventh message argument.
7648 * @param m
7649 * The marker warnrmation associated with this log message.
7650 * @param d
7651 * The message descriptor.
7652 * @param a1
7653 * The first message argument.
7654 * @param a2
7655 * The second message argument.
7656 * @param a3
7657 * The third message argument.
7658 * @param a4
7659 * The fourth message argument.
7660 * @param a5
7661 * The fifth message argument.
7662 * @param a6
7663 * The sixth message argument.
7664 * @param a7
7665 * The seventh message argument.
7666 * @param t
7667 * The throwable to log.
7668 * @see org.slf4j.Logger#warn(String, Throwable)
7669 */
7670 public <T1, T2, T3, T4, T5, T6, T7> void warn(final Marker m,
7671 final Arg7<T1, T2, T3, T4, T5, T6, T7> d, final T1 a1, final T2 a2, final T3 a3,
7672 final T4 a4, final T5 a5, final T6 a6, final T7 a7, final Throwable t) {
7673 if (logger.isWarnEnabled(m)) {
7674 logger.warn(m, d.get(a1, a2, a3, a4, a5, a6, a7).toString(locale), t);
7675 }
7676 }
7677
7678 /**
7679 * Logs a warning message.
7680 *
7681 * @param <T1>
7682 * The type of the first message argument.
7683 * @param <T2>
7684 * The type of the second message argument.
7685 * @param <T3>
7686 * The type of the third message argument.
7687 * @param <T4>
7688 * The type of the fourth message argument.
7689 * @param <T5>
7690 * The type of the fifth message argument.
7691 * @param <T6>
7692 * The type of the sixth message argument.
7693 * @param <T7>
7694 * The type of the seventh message argument.
7695 * @param <T8>
7696 * The type of the eighth message argument.
7697 * @param m
7698 * The marker information associated with this log message.
7699 * @param d
7700 * The message descriptor.
7701 * @param a1
7702 * The first message argument.
7703 * @param a2
7704 * The second message argument.
7705 * @param a3
7706 * The third message argument.
7707 * @param a4
7708 * The fourth message argument.
7709 * @param a5
7710 * The fifth message argument.
7711 * @param a6
7712 * The sixth message argument.
7713 * @param a7
7714 * The seventh message argument.
7715 * @param a8
7716 * The eighth message argument.
7717 * @see org.slf4j.Logger#warn(String)
7718 */
7719 public <T1, T2, T3, T4, T5, T6, T7, T8> void warn(final Marker m,
7720 final Arg8<T1, T2, T3, T4, T5, T6, T7, T8> d, final T1 a1, final T2 a2, final T3 a3,
7721 final T4 a4, final T5 a5, final T6 a6, final T7 a7, final T8 a8) {
7722 if (logger.isWarnEnabled(m)) {
7723 logger.warn(m, d.get(a1, a2, a3, a4, a5, a6, a7, a8).toString(locale));
7724 }
7725 }
7726
7727 /**
7728 * Logs a warning message with an accompanying exception.
7729 *
7730 * @param <T1>
7731 * The type of the first message argument.
7732 * @param <T2>
7733 * The type of the second message argument.
7734 * @param <T3>
7735 * The type of the third message argument.
7736 * @param <T4>
7737 * The type of the fourth message argument.
7738 * @param <T5>
7739 * The type of the fifth message argument.
7740 * @param <T6>
7741 * The type of the sixth message argument.
7742 * @param <T7>
7743 * The type of the seventh message argument.
7744 * @param <T8>
7745 * The type of the eighth message argument.
7746 * @param m
7747 * The marker warnrmation associated with this log message.
7748 * @param d
7749 * The message descriptor.
7750 * @param a1
7751 * The first message argument.
7752 * @param a2
7753 * The second message argument.
7754 * @param a3
7755 * The third message argument.
7756 * @param a4
7757 * The fourth message argument.
7758 * @param a5
7759 * The fifth message argument.
7760 * @param a6
7761 * The sixth message argument.
7762 * @param a7
7763 * The seventh message argument.
7764 * @param a8
7765 * The eighth message argument.
7766 * @param t
7767 * The throwable to log.
7768 * @see org.slf4j.Logger#warn(String, Throwable)
7769 */
7770 public <T1, T2, T3, T4, T5, T6, T7, T8> void warn(final Marker m,
7771 final Arg8<T1, T2, T3, T4, T5, T6, T7, T8> d, final T1 a1, final T2 a2, final T3 a3,
7772 final T4 a4, final T5 a5, final T6 a6, final T7 a7, final T8 a8, final Throwable t) {
7773 if (logger.isWarnEnabled(m)) {
7774 logger.warn(m, d.get(a1, a2, a3, a4, a5, a6, a7, a8).toString(locale), t);
7775 }
7776 }
7777
7778 /**
7779 * Logs a warning message.
7780 *
7781 * @param <T1>
7782 * The type of the first message argument.
7783 * @param <T2>
7784 * The type of the second message argument.
7785 * @param <T3>
7786 * The type of the third message argument.
7787 * @param <T4>
7788 * The type of the fourth message argument.
7789 * @param <T5>
7790 * The type of the fifth message argument.
7791 * @param <T6>
7792 * The type of the sixth message argument.
7793 * @param <T7>
7794 * The type of the seventh message argument.
7795 * @param <T8>
7796 * The type of the eighth message argument.
7797 * @param <T9>
7798 * The type of the ninth message argument.
7799 * @param m
7800 * The marker information associated with this log message.
7801 * @param d
7802 * The message descriptor.
7803 * @param a1
7804 * The first message argument.
7805 * @param a2
7806 * The second message argument.
7807 * @param a3
7808 * The third message argument.
7809 * @param a4
7810 * The fourth message argument.
7811 * @param a5
7812 * The fifth message argument.
7813 * @param a6
7814 * The sixth message argument.
7815 * @param a7
7816 * The seventh message argument.
7817 * @param a8
7818 * The eighth message argument.
7819 * @param a9
7820 * The ninth message argument.
7821 * @see org.slf4j.Logger#warn(String)
7822 */
7823 public <T1, T2, T3, T4, T5, T6, T7, T8, T9> void warn(final Marker m,
7824 final Arg9<T1, T2, T3, T4, T5, T6, T7, T8, T9> d, final T1 a1, final T2 a2,
7825 final T3 a3, final T4 a4, final T5 a5, final T6 a6, final T7 a7, final T8 a8,
7826 final T9 a9) {
7827 if (logger.isWarnEnabled(m)) {
7828 logger.warn(m, d.get(a1, a2, a3, a4, a5, a6, a7, a8, a9).toString(locale));
7829 }
7830 }
7831
7832 /**
7833 * Logs a warning message with an accompanying exception.
7834 *
7835 * @param <T1>
7836 * The type of the first message argument.
7837 * @param <T2>
7838 * The type of the second message argument.
7839 * @param <T3>
7840 * The type of the third message argument.
7841 * @param <T4>
7842 * The type of the fourth message argument.
7843 * @param <T5>
7844 * The type of the fifth message argument.
7845 * @param <T6>
7846 * The type of the sixth message argument.
7847 * @param <T7>
7848 * The type of the seventh message argument.
7849 * @param <T8>
7850 * The type of the eighth message argument.
7851 * @param <T9>
7852 * The type of the ninth message argument.
7853 * @param m
7854 * The marker warnrmation associated with this log message.
7855 * @param d
7856 * The message descriptor.
7857 * @param a1
7858 * The first message argument.
7859 * @param a2
7860 * The second message argument.
7861 * @param a3
7862 * The third message argument.
7863 * @param a4
7864 * The fourth message argument.
7865 * @param a5
7866 * The fifth message argument.
7867 * @param a6
7868 * The sixth message argument.
7869 * @param a7
7870 * The seventh message argument.
7871 * @param a8
7872 * The eighth message argument.
7873 * @param a9
7874 * The ninth message argument.
7875 * @param t
7876 * The throwable to log.
7877 * @see org.slf4j.Logger#warn(String, Throwable)
7878 */
7879 public <T1, T2, T3, T4, T5, T6, T7, T8, T9> void warn(final Marker m,
7880 final Arg9<T1, T2, T3, T4, T5, T6, T7, T8, T9> d, final T1 a1, final T2 a2,
7881 final T3 a3, final T4 a4, final T5 a5, final T6 a6, final T7 a7, final T8 a8,
7882 final T9 a9, final Throwable t) {
7883 if (logger.isWarnEnabled(m)) {
7884 logger.warn(m, d.get(a1, a2, a3, a4, a5, a6, a7, a8, a9).toString(locale), t);
7885 }
7886 }
7887
7888 /**
7889 * Logs a warning message.
7890 *
7891 * @param m
7892 * The marker information associated with this log message.
7893 * @param d
7894 * The message descriptor.
7895 * @param args
7896 * The message arguments.
7897 * @see org.slf4j.Logger#warn(String)
7898 */
7899 public void warn(final Marker m, final ArgN d, final Object... args) {
7900 if (logger.isWarnEnabled(m)) {
7901 logger.warn(m, d.get(args).toString(locale));
7902 }
7903 }
7904
7905 /**
7906 * Logs a warning message with an accompanying exception.
7907 *
7908 * @param m
7909 * The marker warnrmation associated with this log message.
7910 * @param d
7911 * The message descriptor.
7912 * @param t
7913 * The throwable to log.
7914 * @param args
7915 * The message arguments.
7916 * @see org.slf4j.Logger#warn(String, Throwable)
7917 */
7918 public void warn(final Marker m, final ArgN d, final Throwable t, final Object... args) {
7919 if (logger.isWarnEnabled(m)) {
7920 logger.warn(m, d.get(args).toString(locale), t);
7921 }
7922 }
7923
7924 }