001/* 002 * The contents of this file are subject to the terms of the Common Development and 003 * Distribution License (the License). You may not use this file except in compliance with the 004 * License. 005 * 006 * You can obtain a copy of the License at legal/CDDLv1.0.txt. See the License for the 007 * specific language governing permission and limitations under the License. 008 * 009 * When distributing Covered Software, include this CDDL Header Notice in each file and include 010 * the License file at legal/CDDLv1.0.txt. If applicable, add the following below the CDDL 011 * Header, with the fields enclosed by brackets [] replaced by your own identifying 012 * information: "Portions Copyrighted [year] [name of copyright owner]". 013 * 014 * Copyright 2011-2014 ForgeRock AS 015 */ 016 017package org.forgerock.i18n.slf4j; 018 019import java.util.Locale; 020 021import org.forgerock.i18n.LocalizableMessage; 022import org.forgerock.i18n.LocalizableMessageDescriptor.Arg0; 023import org.forgerock.i18n.LocalizableMessageDescriptor.Arg1; 024import org.forgerock.i18n.LocalizableMessageDescriptor.Arg2; 025import org.forgerock.i18n.LocalizableMessageDescriptor.Arg3; 026import org.forgerock.i18n.LocalizableMessageDescriptor.Arg4; 027import org.forgerock.i18n.LocalizableMessageDescriptor.Arg5; 028import org.forgerock.i18n.LocalizableMessageDescriptor.Arg6; 029import org.forgerock.i18n.LocalizableMessageDescriptor.Arg7; 030import org.forgerock.i18n.LocalizableMessageDescriptor.Arg8; 031import org.forgerock.i18n.LocalizableMessageDescriptor.Arg9; 032import org.forgerock.i18n.LocalizableMessageDescriptor.ArgN; 033import org.slf4j.Logger; 034import org.slf4j.LoggerFactory; 035import org.slf4j.Marker; 036 037/** 038 * A logger implementation which formats and localizes messages before 039 * forwarding them to an underlying SLF4J {@link Logger}. For performance 040 * reasons this implementation will only localize and format messages if logging 041 * has been enabled for the associated log level and marker (if present). 042 * <p> 043 * If no marker is provided, a {@code LocalizedMarker} is automatically constructed 044 * with the corresponding {@code LocalizedMessage} to be logged and passed to the 045 * underlying SLF4J {@link Logger}. This allow a custom implementation of SLF4J 046 * logger adapter to retrieve the complete localizable message when logging. 047 */ 048public final class LocalizedLogger { 049 050 private static final String LOCALIZED_LOGGER_CLASSNAME = LocalizedLogger.class.getName(); 051 052 private static final String THREAD_CLASS_NAME = Thread.class.getName(); 053 054 /** 055 * Returns a localized logger which will forward log messages to an SLF4J 056 * {@code Logger} obtained by calling {@link LoggerFactory#getLogger(Class)} 057 * . The messages will be localized using the default locale. 058 * 059 * @param clazz 060 * The name of the wrapped SLF4J {@code Logger}. 061 * @return The localized logger. 062 * @see LoggerFactory#getLogger(Class) 063 */ 064 public static LocalizedLogger getLocalizedLogger(final Class<?> clazz) { 065 final Logger logger = LoggerFactory.getLogger(clazz); 066 return new LocalizedLogger(logger, Locale.getDefault()); 067 } 068 069 /** 070 * Returns a localized logger which will forward log messages to the 071 * provided SLF4J {@code Logger}. The messages will be localized using the 072 * default locale. 073 * 074 * @param logger 075 * The wrapped SLF4J {@code Logger}. 076 * @return The localized logger. 077 * @see LoggerFactory#getLogger(String) 078 */ 079 public static LocalizedLogger getLocalizedLogger(final Logger logger) { 080 return new LocalizedLogger(logger, Locale.getDefault()); 081 } 082 083 /** 084 * Returns a localized logger which will forward log messages to an SLF4J 085 * {@code Logger} obtained by calling 086 * {@link LoggerFactory#getLogger(String)}. The messages will be localized 087 * using the default locale. 088 * 089 * @param name 090 * The name of the wrapped SLF4J {@code Logger}. 091 * @return The localized logger. 092 * @see LoggerFactory#getLogger(String) 093 */ 094 public static LocalizedLogger getLocalizedLogger(final String name) { 095 final Logger logger = LoggerFactory.getLogger(name); 096 return new LocalizedLogger(logger, Locale.getDefault()); 097 } 098 099 /** 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}