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