1 /* 2 * Licensed to the Apache Software Foundation (ASF) under one or more 3 * contributor license agreements. See the NOTICE file distributed with 4 * this work for additional information regarding copyright ownership. 5 * The ASF licenses this file to You under the Apache License, Version 2.0 6 * (the "License"); you may not use this file except in compliance with 7 * the License. You may obtain a copy of the License at 8 * 9 * http://www.apache.org/licenses/LICENSE-2.0 10 * 11 * Unless required by applicable law or agreed to in writing, software 12 * distributed under the License is distributed on an "AS IS" BASIS, 13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 14 * See the License for the specific language governing permissions and 15 * limitations under the License. 16 */ 17 package org.apache.log4j; 18 19 import org.apache.log4j.spi.LoggingEvent; 20 21 import java.util.ResourceBundle; 22 23 24 /** 25 * This class provides parameterized logging services 26 * using the SLF4J pattern syntax. 27 * <p> 28 * Message formatting is only performed when the 29 * request exceeds the threshold level of the logger. 30 * 31 * @since 1.2.16 32 * 33 */ 34 public final class LogSF extends LogXF { 35 /** 36 * private constructor. 37 * 38 */ LogSF()39 private LogSF() { 40 } 41 42 43 44 45 /** 46 * Formats arguments using SLF4J-like formatter. 47 * @param pattern pattern, may be malformed. 48 * @param arguments arguments. 49 * @return Message string 50 */ format(final String pattern, final Object[] arguments)51 private static String format(final String pattern, 52 final Object[] arguments) { 53 if (pattern != null) { 54 String retval = ""; 55 int count = 0; 56 int prev = 0; 57 int pos = pattern.indexOf("{"); 58 while(pos >= 0) { 59 if (pos == 0 || pattern.charAt(pos-1) != '\\') { 60 retval += pattern.substring(prev, pos); 61 if (pos + 1 < pattern.length() && pattern.charAt(pos+1) == '}') { 62 if(arguments != null && count < arguments.length) { 63 retval += arguments[count++]; 64 } else { 65 retval += "{}"; 66 } 67 prev = pos + 2; 68 } else { 69 retval += "{"; 70 prev = pos + 1; 71 } 72 } else { 73 retval += pattern.substring(prev, pos - 1) + "{"; 74 prev = pos + 1; 75 } 76 pos = pattern.indexOf("{", prev); 77 } 78 return retval + pattern.substring(prev); 79 } 80 return null; 81 } 82 83 /** 84 * Formats arguments using MessageFormat. 85 * @param pattern pattern, may be malformed. 86 * @param arg0 argument, may be null or mismatched. 87 * @return Message string 88 */ format(final String pattern, final Object arg0)89 private static String format(final String pattern, final Object arg0) { 90 if (pattern != null) { 91 // 92 // if there is an escaped brace, delegate to multi-param formatter 93 if (pattern.indexOf("\\{") >= 0) { 94 return format(pattern, new Object[] { arg0 }); 95 } 96 int pos = pattern.indexOf("{}"); 97 if (pos >= 0) { 98 return pattern.substring(0, pos) + arg0 + pattern.substring(pos+2); 99 } 100 } 101 return pattern; 102 } 103 104 /** 105 * Formats arguments using MessageFormat using a pattern from 106 * a resource bundle. 107 * @param resourceBundleName name of resource bundle, may be null. 108 * @param key key for pattern in resource bundle, may be null. 109 * @param arguments arguments, may be null or mismatched. 110 * @return Message string or null 111 */ format( final String resourceBundleName, final String key, final Object[] arguments)112 private static String format( 113 final String resourceBundleName, 114 final String key, 115 final Object[] arguments) { 116 String pattern; 117 if (resourceBundleName != null) { 118 try { 119 ResourceBundle bundle = 120 ResourceBundle.getBundle(resourceBundleName); 121 pattern = bundle.getString(key); 122 } catch (Exception ex) { 123 pattern = key; 124 } 125 } else { 126 pattern = key; 127 } 128 return format(pattern, arguments); 129 } 130 131 132 /** 133 * Fully Qualified Class Name of this class. 134 */ 135 private static final String FQCN = LogSF.class.getName(); 136 137 /** 138 * Equivalent of Logger.forcedLog. 139 * 140 * @param logger logger, may not be null. 141 * @param level level, may not be null. 142 * @param msg message, may be null. 143 */ forcedLog(final Logger logger, final Level level, final String msg)144 private static void forcedLog(final Logger logger, 145 final Level level, 146 final String msg) { 147 logger.callAppenders(new LoggingEvent(FQCN, logger, level, msg, null)); 148 } 149 150 /** 151 * Equivalent of Logger.forcedLog. 152 * 153 * @param logger logger, may not be null. 154 * @param level level, may not be null. 155 * @param msg message, may be null. 156 * @param t throwable. 157 */ forcedLog(final Logger logger, final Level level, final String msg, final Throwable t)158 private static void forcedLog(final Logger logger, 159 final Level level, 160 final String msg, 161 final Throwable t) { 162 logger.callAppenders(new LoggingEvent(FQCN, logger, level, msg, t)); 163 } 164 /** 165 * Log a parameterized message at trace level. 166 * @param logger logger, may not be null. 167 * @param pattern pattern, may be null. 168 * @param arguments an array of arguments to be 169 * formatted and substituted. 170 */ trace(final Logger logger, final String pattern, final Object[] arguments)171 public static void trace(final Logger logger, final String pattern, 172 final Object[] arguments) { 173 if (logger.isEnabledFor(TRACE)) { 174 forcedLog(logger, TRACE, format(pattern, arguments)); 175 } 176 } 177 178 /** 179 * Log a parameterized message at debug level. 180 * @param logger logger, may not be null. 181 * @param pattern pattern, may be null. 182 * @param arguments an array of arguments to be formatted and substituted. 183 */ debug(final Logger logger, final String pattern, final Object[] arguments)184 public static void debug(final Logger logger, final String pattern, 185 final Object[] arguments) { 186 if (logger.isDebugEnabled()) { 187 forcedLog(logger, Level.DEBUG, format(pattern, arguments)); 188 } 189 } 190 191 /** 192 * Log a parameterized message at info level. 193 * @param logger logger, may not be null. 194 * @param pattern pattern, may be null. 195 * @param arguments an array of arguments to be formatted and substituted. 196 */ info(final Logger logger, final String pattern, final Object[] arguments)197 public static void info(final Logger logger, final String pattern, 198 final Object[] arguments) { 199 if (logger.isInfoEnabled()) { 200 forcedLog(logger, Level.INFO, format(pattern, arguments)); 201 } 202 } 203 204 /** 205 * Log a parameterized message at warn level. 206 * @param logger logger, may not be null. 207 * @param pattern pattern, may be null. 208 * @param arguments an array of arguments to be formatted and substituted. 209 */ warn(final Logger logger, final String pattern, final Object[] arguments)210 public static void warn(final Logger logger, final String pattern, 211 final Object[] arguments) { 212 if (logger.isEnabledFor(Level.WARN)) { 213 forcedLog(logger, Level.WARN, format(pattern, arguments)); 214 } 215 } 216 217 /** 218 * Log a parameterized message at error level. 219 * @param logger logger, may not be null. 220 * @param pattern pattern, may be null. 221 * @param arguments an array of arguments to be formatted and substituted. 222 */ error(final Logger logger, final String pattern, final Object[] arguments)223 public static void error(final Logger logger, final String pattern, 224 final Object[] arguments) { 225 if (logger.isEnabledFor(Level.ERROR)) { 226 forcedLog(logger, Level.ERROR, format(pattern, arguments)); 227 } 228 } 229 230 /** 231 * Log a parameterized message at fatal level. 232 * @param logger logger, may not be null. 233 * @param pattern pattern, may be null. 234 * @param arguments an array of arguments to be formatted and substituted. 235 */ fatal(final Logger logger, final String pattern, final Object[] arguments)236 public static void fatal(final Logger logger, final String pattern, 237 final Object[] arguments) { 238 if (logger.isEnabledFor(Level.FATAL)) { 239 forcedLog(logger, Level.FATAL, format(pattern, arguments)); 240 } 241 } 242 243 /** 244 * Log a parameterized message at trace level. 245 * @param logger logger, may not be null. 246 * @param t throwable, may be null. 247 * @param pattern pattern, may be null. 248 * @param arguments an array of arguments to be 249 * formatted and substituted. 250 */ trace(final Logger logger, final Throwable t, final String pattern, final Object[] arguments)251 public static void trace(final Logger logger, 252 final Throwable t, 253 final String pattern, 254 final Object[] arguments) { 255 if (logger.isEnabledFor(TRACE)) { 256 forcedLog(logger, TRACE, format(pattern, arguments), t); 257 } 258 } 259 260 /** 261 * Log a parameterized message at debug level. 262 * @param logger logger, may not be null. 263 * @param t throwable, may be null. 264 * @param pattern pattern, may be null. 265 * @param arguments an array of arguments to be formatted and substituted. 266 */ debug(final Logger logger, final Throwable t, final String pattern, final Object[] arguments)267 public static void debug(final Logger logger, 268 final Throwable t, 269 final String pattern, 270 final Object[] arguments) { 271 if (logger.isDebugEnabled()) { 272 forcedLog(logger, Level.DEBUG, format(pattern, arguments), t); 273 } 274 } 275 276 /** 277 * Log a parameterized message at info level. 278 * @param logger logger, may not be null. 279 * @param t throwable, may be null. 280 * @param pattern pattern, may be null. 281 * @param arguments an array of arguments to be formatted and substituted. 282 */ info(final Logger logger, final Throwable t, final String pattern, final Object[] arguments)283 public static void info(final Logger logger, 284 final Throwable t, 285 final String pattern, 286 final Object[] arguments) { 287 if (logger.isInfoEnabled()) { 288 forcedLog(logger, Level.INFO, format(pattern, arguments), t); 289 } 290 } 291 292 /** 293 * Log a parameterized message at warn level. 294 * @param logger logger, may not be null. 295 * @param t throwable, may be null. 296 * @param pattern pattern, may be null. 297 * @param arguments an array of arguments to be formatted and substituted. 298 */ warn(final Logger logger, final Throwable t, final String pattern, final Object[] arguments)299 public static void warn(final Logger logger, 300 final Throwable t, 301 final String pattern, 302 final Object[] arguments) { 303 if (logger.isEnabledFor(Level.WARN)) { 304 forcedLog(logger, Level.WARN, format(pattern, arguments), t); 305 } 306 } 307 308 /** 309 * Log a parameterized message at error level. 310 * @param logger logger, may not be null. 311 * @param t throwable, may be null. 312 * @param pattern pattern, may be null. 313 * @param arguments an array of arguments to be formatted and substituted. 314 */ error(final Logger logger, final Throwable t, final String pattern, final Object[] arguments)315 public static void error(final Logger logger, 316 final Throwable t, 317 final String pattern, 318 final Object[] arguments) { 319 if (logger.isEnabledFor(Level.ERROR)) { 320 forcedLog(logger, Level.ERROR, format(pattern, arguments), t); 321 } 322 } 323 324 /** 325 * Log a parameterized message at fatal level. 326 * @param logger logger, may not be null. 327 * @param t throwable, may be null. 328 * @param pattern pattern, may be null. 329 * @param arguments an array of arguments to be formatted and substituted. 330 */ fatal(final Logger logger, final Throwable t, final String pattern, final Object[] arguments)331 public static void fatal(final Logger logger, 332 final Throwable t, 333 final String pattern, 334 final Object[] arguments) { 335 if (logger.isEnabledFor(Level.FATAL)) { 336 forcedLog(logger, Level.FATAL, format(pattern, arguments), t); 337 } 338 } 339 340 341 342 /** 343 * Log a parameterized message at trace level. 344 * @param logger logger, may not be null. 345 * @param pattern pattern, may be null. 346 * @param argument a value to be formatted and substituted. 347 */ trace(final Logger logger, final String pattern, final boolean argument)348 public static void trace(final Logger logger, final String pattern, 349 final boolean argument) { 350 if (logger.isEnabledFor(TRACE)) { 351 forcedLog(logger, TRACE, format(pattern, valueOf(argument))); 352 } 353 } 354 355 /** 356 * Log a parameterized message at trace level. 357 * @param logger logger, may not be null. 358 * @param pattern pattern, may be null. 359 * @param argument a value to be formatted and substituted. 360 */ trace(final Logger logger, final String pattern, final char argument)361 public static void trace(final Logger logger, final String pattern, 362 final char argument) { 363 if (logger.isEnabledFor(TRACE)) { 364 forcedLog(logger, TRACE, format(pattern, valueOf(argument))); 365 } 366 } 367 368 /** 369 * Log a parameterized message at trace level. 370 * @param logger logger, may not be null. 371 * @param pattern pattern, may be null. 372 * @param argument a value to be formatted and substituted. 373 */ trace(final Logger logger, final String pattern, final byte argument)374 public static void trace(final Logger logger, final String pattern, 375 final byte argument) { 376 if (logger.isEnabledFor(TRACE)) { 377 forcedLog(logger, TRACE, format(pattern, valueOf(argument))); 378 } 379 } 380 381 /** 382 * Log a parameterized message at trace level. 383 * @param logger logger, may not be null. 384 * @param pattern pattern, may be null. 385 * @param argument a value to be formatted and substituted. 386 */ trace(final Logger logger, final String pattern, final short argument)387 public static void trace(final Logger logger, final String pattern, 388 final short argument) { 389 if (logger.isEnabledFor(TRACE)) { 390 forcedLog(logger, TRACE, format(pattern, valueOf(argument))); 391 } 392 } 393 394 /** 395 * Log a parameterized message at trace level. 396 * @param logger logger, may not be null. 397 * @param pattern pattern, may be null. 398 * @param argument a value to be formatted and substituted. 399 */ trace(final Logger logger, final String pattern, final int argument)400 public static void trace(final Logger logger, final String pattern, 401 final int argument) { 402 if (logger.isEnabledFor(TRACE)) { 403 forcedLog(logger, TRACE, format(pattern, valueOf(argument))); 404 } 405 } 406 407 /** 408 * Log a parameterized message at trace level. 409 * @param logger logger, may not be null. 410 * @param pattern pattern, may be null. 411 * @param argument a value to be formatted and substituted. 412 */ trace(final Logger logger, final String pattern, final long argument)413 public static void trace(final Logger logger, final String pattern, 414 final long argument) { 415 if (logger.isEnabledFor(TRACE)) { 416 forcedLog(logger, TRACE, format(pattern, valueOf(argument))); 417 } 418 } 419 420 /** 421 * Log a parameterized message at trace level. 422 * @param logger logger, may not be null. 423 * @param pattern pattern, may be null. 424 * @param argument a value to be formatted and substituted. 425 */ trace(final Logger logger, final String pattern, final float argument)426 public static void trace(final Logger logger, final String pattern, 427 final float argument) { 428 if (logger.isEnabledFor(TRACE)) { 429 forcedLog(logger, TRACE, format(pattern, valueOf(argument))); 430 } 431 } 432 433 /** 434 * Log a parameterized message at trace level. 435 * @param logger logger, may not be null. 436 * @param pattern pattern, may be null. 437 * @param argument a value to be formatted and substituted. 438 */ trace(final Logger logger, final String pattern, final double argument)439 public static void trace(final Logger logger, final String pattern, 440 final double argument) { 441 if (logger.isEnabledFor(TRACE)) { 442 forcedLog(logger, TRACE, format(pattern, valueOf(argument))); 443 } 444 } 445 446 /** 447 * Log a parameterized message at trace level. 448 * @param logger logger, may not be null. 449 * @param pattern pattern, may be null. 450 * @param argument a value to be formatted and substituted. 451 */ trace(final Logger logger, final String pattern, final Object argument)452 public static void trace(final Logger logger, final String pattern, 453 final Object argument) { 454 if (logger.isEnabledFor(TRACE)) { 455 forcedLog(logger, TRACE, format(pattern, argument)); 456 } 457 } 458 459 /** 460 * Log a parameterized message at trace level. 461 * @param logger logger, may not be null. 462 * @param pattern pattern, may be null. 463 * @param arg0 a value to be formatted and substituted. 464 * @param arg1 a value to be formatted and substituted. 465 */ trace(final Logger logger, final String pattern, final Object arg0, final Object arg1)466 public static void trace(final Logger logger, final String pattern, 467 final Object arg0, final Object arg1) { 468 if (logger.isEnabledFor(TRACE)) { 469 forcedLog(logger, TRACE, 470 format(pattern, toArray(arg0, arg1))); 471 } 472 } 473 474 /** 475 * Log a parameterized message at trace level. 476 * @param logger logger, may not be null. 477 * @param pattern pattern, may be null. 478 * @param arg0 a value to be formatted and substituted. 479 * @param arg1 a value to be formatted and substituted. 480 * @param arg2 a value to be formatted and substituted. 481 */ trace(final Logger logger, final String pattern, final Object arg0, final Object arg1, final Object arg2)482 public static void trace(final Logger logger, final String pattern, 483 final Object arg0, final Object arg1, final Object arg2) { 484 if (logger.isEnabledFor(TRACE)) { 485 forcedLog(logger, TRACE, 486 format(pattern, toArray(arg0, arg1, arg2))); 487 } 488 } 489 490 /** 491 * Log a parameterized message at trace level. 492 * @param logger logger, may not be null. 493 * @param pattern pattern, may be null. 494 * @param arg0 a value to be formatted and substituted. 495 * @param arg1 a value to be formatted and substituted. 496 * @param arg2 a value to be formatted and substituted. 497 * @param arg3 a value to be formatted and substituted. 498 */ trace(final Logger logger, final String pattern, final Object arg0, final Object arg1, final Object arg2, final Object arg3)499 public static void trace(final Logger logger, final String pattern, 500 final Object arg0, final Object arg1, final Object arg2, 501 final Object arg3) { 502 if (logger.isEnabledFor(TRACE)) { 503 forcedLog(logger, TRACE, 504 format(pattern, toArray(arg0, arg1, arg2, arg3))); 505 } 506 } 507 508 /** 509 * Log a parameterized message at debug level. 510 * @param logger logger, may not be null. 511 * @param pattern pattern, may be null. 512 * @param argument a value to be formatted and substituted. 513 */ debug(final Logger logger, final String pattern, final boolean argument)514 public static void debug(final Logger logger, final String pattern, 515 final boolean argument) { 516 if (logger.isDebugEnabled()) { 517 forcedLog(logger, Level.DEBUG, format(pattern, valueOf(argument))); 518 } 519 } 520 521 /** 522 * Log a parameterized message at debug level. 523 * @param logger logger, may not be null. 524 * @param pattern pattern, may be null. 525 * @param argument a value to be formatted and substituted. 526 */ debug(final Logger logger, final String pattern, final char argument)527 public static void debug(final Logger logger, final String pattern, 528 final char argument) { 529 if (logger.isDebugEnabled()) { 530 forcedLog(logger, Level.DEBUG, format(pattern, valueOf(argument))); 531 } 532 } 533 534 /** 535 * Log a parameterized message at debug level. 536 * @param logger logger, may not be null. 537 * @param pattern pattern, may be null. 538 * @param argument a value to be formatted and substituted. 539 */ debug(final Logger logger, final String pattern, final byte argument)540 public static void debug(final Logger logger, final String pattern, 541 final byte argument) { 542 if (logger.isDebugEnabled()) { 543 forcedLog(logger, Level.DEBUG, format(pattern, valueOf(argument))); 544 } 545 } 546 547 /** 548 * Log a parameterized message at debug level. 549 * @param logger logger, may not be null. 550 * @param pattern pattern, may be null. 551 * @param argument a value to be formatted and substituted. 552 */ debug(final Logger logger, final String pattern, final short argument)553 public static void debug(final Logger logger, final String pattern, 554 final short argument) { 555 if (logger.isDebugEnabled()) { 556 forcedLog(logger, Level.DEBUG, format(pattern, valueOf(argument))); 557 } 558 } 559 560 /** 561 * Log a parameterized message at debug level. 562 * @param logger logger, may not be null. 563 * @param pattern pattern, may be null. 564 * @param argument a value to be formatted and substituted. 565 */ debug(final Logger logger, final String pattern, final int argument)566 public static void debug(final Logger logger, final String pattern, 567 final int argument) { 568 if (logger.isDebugEnabled()) { 569 forcedLog(logger, Level.DEBUG, format(pattern, valueOf(argument))); 570 } 571 } 572 573 /** 574 * Log a parameterized message at debug level. 575 * @param logger logger, may not be null. 576 * @param pattern pattern, may be null. 577 * @param argument a value to be formatted and substituted. 578 */ debug(final Logger logger, final String pattern, final long argument)579 public static void debug(final Logger logger, final String pattern, 580 final long argument) { 581 if (logger.isDebugEnabled()) { 582 forcedLog(logger, Level.DEBUG, format(pattern, valueOf(argument))); 583 } 584 } 585 586 /** 587 * Log a parameterized message at debug level. 588 * @param logger logger, may not be null. 589 * @param pattern pattern, may be null. 590 * @param argument a value to be formatted and substituted. 591 */ debug(final Logger logger, final String pattern, final float argument)592 public static void debug(final Logger logger, final String pattern, 593 final float argument) { 594 if (logger.isDebugEnabled()) { 595 forcedLog(logger, Level.DEBUG, format(pattern, valueOf(argument))); 596 } 597 } 598 599 /** 600 * Log a parameterized message at debug level. 601 * @param logger logger, may not be null. 602 * @param pattern pattern, may be null. 603 * @param argument a value to be formatted and substituted. 604 */ debug(final Logger logger, final String pattern, final double argument)605 public static void debug(final Logger logger, final String pattern, 606 final double argument) { 607 if (logger.isDebugEnabled()) { 608 forcedLog(logger, Level.DEBUG, format(pattern, valueOf(argument))); 609 } 610 } 611 612 /** 613 * Log a parameterized message at debug level. 614 * @param logger logger, may not be null. 615 * @param pattern pattern, may be null. 616 * @param argument a value to be formatted and substituted. 617 */ debug(final Logger logger, final String pattern, final Object argument)618 public static void debug(final Logger logger, final String pattern, 619 final Object argument) { 620 if (logger.isDebugEnabled()) { 621 forcedLog(logger, Level.DEBUG, format(pattern, argument)); 622 } 623 } 624 625 /** 626 * Log a parameterized message at debug level. 627 * @param logger logger, may not be null. 628 * @param pattern pattern, may be null. 629 * @param arg0 a value to be formatted and substituted. 630 * @param arg1 a value to be formatted and substituted. 631 */ debug(final Logger logger, final String pattern, final Object arg0, final Object arg1)632 public static void debug(final Logger logger, final String pattern, 633 final Object arg0, final Object arg1) { 634 if (logger.isDebugEnabled()) { 635 forcedLog(logger, Level.DEBUG, 636 format(pattern, toArray(arg0, arg1))); 637 } 638 } 639 640 /** 641 * Log a parameterized message at debug level. 642 * @param logger logger, may not be null. 643 * @param pattern pattern, may be null. 644 * @param arg0 a value to be formatted and substituted. 645 * @param arg1 a value to be formatted and substituted. 646 * @param arg2 a value to be formatted and substituted. 647 */ debug(final Logger logger, final String pattern, final Object arg0, final Object arg1, final Object arg2)648 public static void debug(final Logger logger, final String pattern, 649 final Object arg0, final Object arg1, final Object arg2) { 650 if (logger.isDebugEnabled()) { 651 forcedLog(logger, Level.DEBUG, 652 format(pattern, toArray(arg0, arg1, arg2))); 653 } 654 } 655 656 /** 657 * Log a parameterized message at debug level. 658 * @param logger logger, may not be null. 659 * @param pattern pattern, may be null. 660 * @param arg0 a value to be formatted and substituted. 661 * @param arg1 a value to be formatted and substituted. 662 * @param arg2 a value to be formatted and substituted. 663 * @param arg3 a value to be formatted and substituted. 664 */ debug(final Logger logger, final String pattern, final Object arg0, final Object arg1, final Object arg2, final Object arg3)665 public static void debug(final Logger logger, final String pattern, 666 final Object arg0, final Object arg1, final Object arg2, 667 final Object arg3) { 668 if (logger.isDebugEnabled()) { 669 forcedLog(logger, Level.DEBUG, 670 format(pattern, toArray(arg0, arg1, arg2, arg3))); 671 } 672 } 673 674 /** 675 * Log a parameterized message at info level. 676 * @param logger logger, may not be null. 677 * @param pattern pattern, may be null. 678 * @param argument a value to be formatted and substituted. 679 */ info(final Logger logger, final String pattern, final boolean argument)680 public static void info(final Logger logger, final String pattern, 681 final boolean argument) { 682 if (logger.isInfoEnabled()) { 683 forcedLog(logger, Level.INFO, format(pattern, valueOf(argument))); 684 } 685 } 686 687 /** 688 * Log a parameterized message at info level. 689 * @param logger logger, may not be null. 690 * @param pattern pattern, may be null. 691 * @param argument a value to be formatted and substituted. 692 */ info(final Logger logger, final String pattern, final char argument)693 public static void info(final Logger logger, final String pattern, 694 final char argument) { 695 if (logger.isInfoEnabled()) { 696 forcedLog(logger, Level.INFO, format(pattern, valueOf(argument))); 697 } 698 } 699 700 /** 701 * Log a parameterized message at info level. 702 * @param logger logger, may not be null. 703 * @param pattern pattern, may be null. 704 * @param argument a value to be formatted and substituted. 705 */ info(final Logger logger, final String pattern, final byte argument)706 public static void info(final Logger logger, final String pattern, 707 final byte argument) { 708 if (logger.isInfoEnabled()) { 709 forcedLog(logger, Level.INFO, format(pattern, valueOf(argument))); 710 } 711 } 712 713 /** 714 * Log a parameterized message at info level. 715 * @param logger logger, may not be null. 716 * @param pattern pattern, may be null. 717 * @param argument a value to be formatted and substituted. 718 */ info(final Logger logger, final String pattern, final short argument)719 public static void info(final Logger logger, final String pattern, 720 final short argument) { 721 if (logger.isInfoEnabled()) { 722 forcedLog(logger, Level.INFO, format(pattern, valueOf(argument))); 723 } 724 } 725 726 /** 727 * Log a parameterized message at info level. 728 * @param logger logger, may not be null. 729 * @param pattern pattern, may be null. 730 * @param argument a value to be formatted and substituted. 731 */ info(final Logger logger, final String pattern, final int argument)732 public static void info(final Logger logger, final String pattern, 733 final int argument) { 734 if (logger.isInfoEnabled()) { 735 forcedLog(logger, Level.INFO, format(pattern, valueOf(argument))); 736 } 737 } 738 739 /** 740 * Log a parameterized message at info level. 741 * @param logger logger, may not be null. 742 * @param pattern pattern, may be null. 743 * @param argument a value to be formatted and substituted. 744 */ info(final Logger logger, final String pattern, final long argument)745 public static void info(final Logger logger, final String pattern, 746 final long argument) { 747 if (logger.isInfoEnabled()) { 748 forcedLog(logger, Level.INFO, format(pattern, valueOf(argument))); 749 } 750 } 751 752 /** 753 * Log a parameterized message at info level. 754 * @param logger logger, may not be null. 755 * @param pattern pattern, may be null. 756 * @param argument a value to be formatted and substituted. 757 */ info(final Logger logger, final String pattern, final float argument)758 public static void info(final Logger logger, final String pattern, 759 final float argument) { 760 if (logger.isInfoEnabled()) { 761 forcedLog(logger, Level.INFO, format(pattern, valueOf(argument))); 762 } 763 } 764 765 /** 766 * Log a parameterized message at info level. 767 * @param logger logger, may not be null. 768 * @param pattern pattern, may be null. 769 * @param argument a value to be formatted and substituted. 770 */ info(final Logger logger, final String pattern, final double argument)771 public static void info(final Logger logger, final String pattern, 772 final double argument) { 773 if (logger.isInfoEnabled()) { 774 forcedLog(logger, Level.INFO, format(pattern, valueOf(argument))); 775 } 776 } 777 778 /** 779 * Log a parameterized message at info level. 780 * @param logger logger, may not be null. 781 * @param pattern pattern, may be null. 782 * @param argument a value to be formatted and substituted. 783 */ info(final Logger logger, final String pattern, final Object argument)784 public static void info(final Logger logger, final String pattern, 785 final Object argument) { 786 if (logger.isInfoEnabled()) { 787 forcedLog(logger, Level.INFO, format(pattern, argument)); 788 } 789 } 790 791 /** 792 * Log a parameterized message at info level. 793 * @param logger logger, may not be null. 794 * @param pattern pattern, may be null. 795 * @param arg0 a value to be formatted and substituted. 796 * @param arg1 a value to be formatted and substituted. 797 */ info(final Logger logger, final String pattern, final Object arg0, final Object arg1)798 public static void info(final Logger logger, final String pattern, 799 final Object arg0, final Object arg1) { 800 if (logger.isInfoEnabled()) { 801 forcedLog(logger, Level.INFO, format(pattern, toArray(arg0, arg1))); 802 } 803 } 804 805 /** 806 * Log a parameterized message at info level. 807 * @param logger logger, may not be null. 808 * @param pattern pattern, may be null. 809 * @param arg0 a value to be formatted and substituted. 810 * @param arg1 a value to be formatted and substituted. 811 * @param arg2 a value to be formatted and substituted. 812 */ info(final Logger logger, final String pattern, final Object arg0, final Object arg1, final Object arg2)813 public static void info(final Logger logger, final String pattern, 814 final Object arg0, final Object arg1, final Object arg2) { 815 if (logger.isInfoEnabled()) { 816 forcedLog(logger, Level.INFO, format(pattern, 817 toArray(arg0, arg1, arg2))); 818 } 819 } 820 821 /** 822 * Log a parameterized message at info level. 823 * @param logger logger, may not be null. 824 * @param pattern pattern, may be null. 825 * @param arg0 a value to be formatted and substituted. 826 * @param arg1 a value to be formatted and substituted. 827 * @param arg2 a value to be formatted and substituted. 828 * @param arg3 a value to be formatted and substituted. 829 */ info(final Logger logger, final String pattern, final Object arg0, final Object arg1, final Object arg2, final Object arg3)830 public static void info(final Logger logger, final String pattern, 831 final Object arg0, final Object arg1, final Object arg2, 832 final Object arg3) { 833 if (logger.isInfoEnabled()) { 834 forcedLog(logger, Level.INFO, format(pattern, 835 toArray(arg0, arg1, arg2, arg3))); 836 } 837 } 838 839 /** 840 * Log a parameterized message at warn level. 841 * @param logger logger, may not be null. 842 * @param pattern pattern, may be null. 843 * @param argument a value to be formatted and substituted. 844 */ warn(final Logger logger, final String pattern, final boolean argument)845 public static void warn(final Logger logger, final String pattern, 846 final boolean argument) { 847 if (logger.isEnabledFor(Level.WARN)) { 848 forcedLog(logger, Level.WARN, format(pattern, valueOf(argument))); 849 } 850 } 851 852 /** 853 * Log a parameterized message at warn level. 854 * @param logger logger, may not be null. 855 * @param pattern pattern, may be null. 856 * @param argument a value to be formatted and substituted. 857 */ warn(final Logger logger, final String pattern, final char argument)858 public static void warn(final Logger logger, final String pattern, 859 final char argument) { 860 if (logger.isEnabledFor(Level.WARN)) { 861 forcedLog(logger, Level.WARN, format(pattern, valueOf(argument))); 862 } 863 } 864 865 /** 866 * Log a parameterized message at warn level. 867 * @param logger logger, may not be null. 868 * @param pattern pattern, may be null. 869 * @param argument a value to be formatted and substituted. 870 */ warn(final Logger logger, final String pattern, final byte argument)871 public static void warn(final Logger logger, final String pattern, 872 final byte argument) { 873 if (logger.isEnabledFor(Level.WARN)) { 874 forcedLog(logger, Level.WARN, format(pattern, valueOf(argument))); 875 } 876 } 877 878 /** 879 * Log a parameterized message at warn level. 880 * @param logger logger, may not be null. 881 * @param pattern pattern, may be null. 882 * @param argument a value to be formatted and substituted. 883 */ warn(final Logger logger, final String pattern, final short argument)884 public static void warn(final Logger logger, final String pattern, 885 final short argument) { 886 if (logger.isEnabledFor(Level.WARN)) { 887 forcedLog(logger, Level.WARN, format(pattern, valueOf(argument))); 888 } 889 } 890 891 /** 892 * Log a parameterized message at warn level. 893 * @param logger logger, may not be null. 894 * @param pattern pattern, may be null. 895 * @param argument a value to be formatted and substituted. 896 */ warn(final Logger logger, final String pattern, final int argument)897 public static void warn(final Logger logger, final String pattern, 898 final int argument) { 899 if (logger.isEnabledFor(Level.WARN)) { 900 forcedLog(logger, Level.WARN, format(pattern, valueOf(argument))); 901 } 902 } 903 904 /** 905 * Log a parameterized message at warn level. 906 * @param logger logger, may not be null. 907 * @param pattern pattern, may be null. 908 * @param argument a value to be formatted and substituted. 909 */ warn(final Logger logger, final String pattern, final long argument)910 public static void warn(final Logger logger, final String pattern, 911 final long argument) { 912 if (logger.isEnabledFor(Level.WARN)) { 913 forcedLog(logger, Level.WARN, format(pattern, valueOf(argument))); 914 } 915 } 916 917 /** 918 * Log a parameterized message at warn level. 919 * @param logger logger, may not be null. 920 * @param pattern pattern, may be null. 921 * @param argument a value to be formatted and substituted. 922 */ warn(final Logger logger, final String pattern, final float argument)923 public static void warn(final Logger logger, final String pattern, 924 final float argument) { 925 if (logger.isEnabledFor(Level.WARN)) { 926 forcedLog(logger, Level.WARN, format(pattern, valueOf(argument))); 927 } 928 } 929 930 /** 931 * Log a parameterized message at warn level. 932 * @param logger logger, may not be null. 933 * @param pattern pattern, may be null. 934 * @param argument a value to be formatted and substituted. 935 */ warn(final Logger logger, final String pattern, final double argument)936 public static void warn(final Logger logger, final String pattern, 937 final double argument) { 938 if (logger.isEnabledFor(Level.WARN)) { 939 forcedLog(logger, Level.WARN, format(pattern, valueOf(argument))); 940 } 941 } 942 943 /** 944 * Log a parameterized message at warn level. 945 * @param logger logger, may not be null. 946 * @param pattern pattern, may be null. 947 * @param argument a value to be formatted and substituted. 948 */ warn(final Logger logger, final String pattern, final Object argument)949 public static void warn(final Logger logger, final String pattern, 950 final Object argument) { 951 if (logger.isEnabledFor(Level.WARN)) { 952 forcedLog(logger, Level.WARN, format(pattern, argument)); 953 } 954 } 955 956 /** 957 * Log a parameterized message at warn level. 958 * @param logger logger, may not be null. 959 * @param pattern pattern, may be null. 960 * @param arg0 a value to be formatted and substituted. 961 * @param arg1 a value to be formatted and substituted. 962 */ warn(final Logger logger, final String pattern, final Object arg0, final Object arg1)963 public static void warn(final Logger logger, final String pattern, 964 final Object arg0, final Object arg1) { 965 if (logger.isEnabledFor(Level.WARN)) { 966 forcedLog(logger, Level.WARN, 967 format(pattern, toArray(arg0, arg1))); 968 } 969 } 970 971 /** 972 * Log a parameterized message at warn level. 973 * @param logger logger, may not be null. 974 * @param pattern pattern, may be null. 975 * @param arg0 a value to be formatted and substituted. 976 * @param arg1 a value to be formatted and substituted. 977 * @param arg2 a value to be formatted and substituted. 978 */ warn(final Logger logger, final String pattern, final Object arg0, final Object arg1, final Object arg2)979 public static void warn(final Logger logger, final String pattern, 980 final Object arg0, final Object arg1, final Object arg2) { 981 if (logger.isEnabledFor(Level.WARN)) { 982 forcedLog(logger, Level.WARN, 983 format(pattern, toArray(arg0, arg1, arg2))); 984 } 985 } 986 987 /** 988 * Log a parameterized message at warn level. 989 * @param logger logger, may not be null. 990 * @param pattern pattern, may be null. 991 * @param arg0 a value to be formatted and substituted. 992 * @param arg1 a value to be formatted and substituted. 993 * @param arg2 a value to be formatted and substituted. 994 * @param arg3 a value to be formatted and substituted. 995 */ warn(final Logger logger, final String pattern, final Object arg0, final Object arg1, final Object arg2, final Object arg3)996 public static void warn(final Logger logger, final String pattern, 997 final Object arg0, final Object arg1, final Object arg2, 998 final Object arg3) { 999 if (logger.isEnabledFor(Level.WARN)) { 1000 forcedLog(logger, Level.WARN, format(pattern, 1001 toArray(arg0, arg1, arg2, arg3))); 1002 } 1003 } 1004 1005 /** 1006 * Log a parameterized message at specified level. 1007 * @param logger logger, may not be null. 1008 * @param level level, may not be null. 1009 * @param pattern pattern, may be null. 1010 * @param parameters parameters to the log message. 1011 */ log(final Logger logger, final Level level, final String pattern, final Object[] parameters)1012 public static void log(final Logger logger, 1013 final Level level, 1014 final String pattern, 1015 final Object[] parameters) { 1016 if (logger.isEnabledFor(level)) { 1017 forcedLog(logger, level, 1018 format(pattern, parameters)); 1019 } 1020 } 1021 1022 /** 1023 * Log a parameterized message at specified level. 1024 * @param logger logger, may not be null. 1025 * @param level level, may not be null. 1026 * @param t throwable, may be null. 1027 * @param pattern pattern, may be null. 1028 * @param parameters parameters to the log message. 1029 */ log(final Logger logger, final Level level, final Throwable t, final String pattern, final Object[] parameters)1030 public static void log(final Logger logger, 1031 final Level level, 1032 final Throwable t, 1033 final String pattern, 1034 final Object[] parameters) { 1035 if (logger.isEnabledFor(level)) { 1036 forcedLog(logger, level, 1037 format(pattern, parameters), t); 1038 } 1039 } 1040 1041 /** 1042 * Log a parameterized message at specified level. 1043 * @param logger logger, may not be null. 1044 * @param level level, may not be null. 1045 * @param pattern pattern, may be null. 1046 * @param param1 parameter to the log message. 1047 */ log(final Logger logger, final Level level, final String pattern, final Object param1)1048 public static void log(final Logger logger, 1049 final Level level, 1050 final String pattern, 1051 final Object param1) { 1052 if (logger.isEnabledFor(level)) { 1053 forcedLog(logger, level, 1054 format(pattern, toArray(param1))); 1055 } 1056 } 1057 1058 /** 1059 * Log a parameterized message at specified level. 1060 * @param logger logger, may not be null. 1061 * @param level level, may not be null. 1062 * @param pattern pattern, may be null. 1063 * @param param1 parameter to the log message. 1064 */ log(final Logger logger, final Level level, final String pattern, final boolean param1)1065 public static void log(final Logger logger, 1066 final Level level, 1067 final String pattern, 1068 final boolean param1) { 1069 if (logger.isEnabledFor(level)) { 1070 forcedLog(logger, level, 1071 format(pattern, toArray(valueOf(param1)))); 1072 } 1073 } 1074 1075 1076 /** 1077 * Log a parameterized message at specified level. 1078 * @param logger logger, may not be null. 1079 * @param level level, may not be null. 1080 * @param pattern pattern, may be null. 1081 * @param param1 parameter to the log message. 1082 */ log(final Logger logger, final Level level, final String pattern, final byte param1)1083 public static void log(final Logger logger, 1084 final Level level, 1085 final String pattern, 1086 final byte param1) { 1087 if (logger.isEnabledFor(level)) { 1088 forcedLog(logger, level, 1089 format(pattern, toArray(valueOf(param1)))); 1090 } 1091 } 1092 1093 1094 /** 1095 * Log a parameterized message at specified level. 1096 * @param logger logger, may not be null. 1097 * @param level level, may not be null. 1098 * @param pattern pattern, may be null. 1099 * @param param1 parameter to the log message. 1100 */ log(final Logger logger, final Level level, final String pattern, final char param1)1101 public static void log(final Logger logger, 1102 final Level level, 1103 final String pattern, 1104 final char param1) { 1105 if (logger.isEnabledFor(level)) { 1106 forcedLog(logger, level, 1107 format(pattern, toArray(valueOf(param1)))); 1108 } 1109 } 1110 1111 /** 1112 * Log a parameterized message at specified level. 1113 * @param logger logger, may not be null. 1114 * @param level level, may not be null. 1115 * @param pattern pattern, may be null. 1116 * @param param1 parameter to the log message. 1117 */ log(final Logger logger, final Level level, final String pattern, final short param1)1118 public static void log(final Logger logger, 1119 final Level level, 1120 final String pattern, 1121 final short param1) { 1122 if (logger.isEnabledFor(level)) { 1123 forcedLog(logger, level, 1124 format(pattern, toArray(valueOf(param1)))); 1125 } 1126 } 1127 1128 /** 1129 * Log a parameterized message at specified level. 1130 * @param logger logger, may not be null. 1131 * @param level level, may not be null. 1132 * @param pattern pattern, may be null. 1133 * @param param1 parameter to the log message. 1134 */ log(final Logger logger, final Level level, final String pattern, final int param1)1135 public static void log(final Logger logger, 1136 final Level level, 1137 final String pattern, 1138 final int param1) { 1139 if (logger.isEnabledFor(level)) { 1140 forcedLog(logger, level, 1141 format(pattern, toArray(valueOf(param1)))); 1142 } 1143 } 1144 1145 1146 /** 1147 * Log a parameterized message at specified level. 1148 * @param logger logger, may not be null. 1149 * @param level level, may not be null. 1150 * @param pattern pattern, may be null. 1151 * @param param1 parameter to the log message. 1152 */ log(final Logger logger, final Level level, final String pattern, final long param1)1153 public static void log(final Logger logger, 1154 final Level level, 1155 final String pattern, 1156 final long param1) { 1157 if (logger.isEnabledFor(level)) { 1158 forcedLog(logger, level, 1159 format(pattern, toArray(valueOf(param1)))); 1160 } 1161 } 1162 1163 1164 /** 1165 * Log a parameterized message at specified level. 1166 * @param logger logger, may not be null. 1167 * @param level level, may not be null. 1168 * @param pattern pattern, may be null. 1169 * @param param1 parameter to the log message. 1170 */ log(final Logger logger, final Level level, final String pattern, final float param1)1171 public static void log(final Logger logger, 1172 final Level level, 1173 final String pattern, 1174 final float param1) { 1175 if (logger.isEnabledFor(level)) { 1176 forcedLog(logger, level, 1177 format(pattern, toArray(valueOf(param1)))); 1178 } 1179 } 1180 1181 1182 /** 1183 * Log a parameterized message at specified level. 1184 * @param logger logger, may not be null. 1185 * @param level level, may not be null. 1186 * @param pattern pattern, may be null. 1187 * @param param1 parameter to the log message. 1188 */ log(final Logger logger, final Level level, final String pattern, final double param1)1189 public static void log(final Logger logger, 1190 final Level level, 1191 final String pattern, 1192 final double param1) { 1193 if (logger.isEnabledFor(level)) { 1194 forcedLog(logger, level, 1195 format(pattern, toArray(valueOf(param1)))); 1196 } 1197 } 1198 1199 1200 /** 1201 * Log a parameterized message at specified level. 1202 * @param logger logger, may not be null. 1203 * @param level level, may not be null. 1204 * @param pattern pattern, may be null. 1205 * @param arg0 a value to be formatted and substituted. 1206 * @param arg1 a value to be formatted and substituted. 1207 */ log(final Logger logger, final Level level, final String pattern, final Object arg0, final Object arg1)1208 public static void log(final Logger logger, 1209 final Level level, 1210 final String pattern, 1211 final Object arg0, final Object arg1) { 1212 if (logger.isEnabledFor(level)) { 1213 forcedLog(logger, level, 1214 format(pattern, toArray(arg0, arg1))); 1215 } 1216 } 1217 1218 /** 1219 * Log a parameterized message at specifed level. 1220 * @param logger logger, may not be null. 1221 * @param level level, may not be null. 1222 * @param pattern pattern, may be null. 1223 * @param arg0 a value to be formatted and substituted. 1224 * @param arg1 a value to be formatted and substituted. 1225 * @param arg2 a value to be formatted and substituted. 1226 */ log(final Logger logger, final Level level, final String pattern, final Object arg0, final Object arg1, final Object arg2)1227 public static void log(final Logger logger, 1228 final Level level, 1229 final String pattern, 1230 final Object arg0, final Object arg1, final Object arg2) { 1231 if (logger.isEnabledFor(level)) { 1232 forcedLog(logger, level, 1233 format(pattern, toArray(arg0, arg1, arg2))); 1234 } 1235 } 1236 1237 /** 1238 * Log a parameterized message at specified level. 1239 * @param logger logger, may not be null. 1240 * @param pattern pattern, may be null. 1241 * @param level level, may not be null. 1242 * @param arg0 a value to be formatted and substituted. 1243 * @param arg1 a value to be formatted and substituted. 1244 * @param arg2 a value to be formatted and substituted. 1245 * @param arg3 a value to be formatted and substituted. 1246 */ log(final Logger logger, final Level level, final String pattern, final Object arg0, final Object arg1, final Object arg2, final Object arg3)1247 public static void log(final Logger logger, 1248 final Level level, 1249 final String pattern, 1250 final Object arg0, final Object arg1, final Object arg2, 1251 final Object arg3) { 1252 if (logger.isEnabledFor(level)) { 1253 forcedLog(logger, level, format(pattern, 1254 toArray(arg0, arg1, arg2, arg3))); 1255 } 1256 } 1257 1258 1259 /** 1260 * Log a parameterized message using a pattern from a resource bundle. 1261 * @param logger logger, may not be null. 1262 * @param level level, may not be null. 1263 * @param bundleName resource bundle name, may be null. 1264 * @param key key, may be null. 1265 * @param parameters parameters to the log message. 1266 */ logrb(final Logger logger, final Level level, final String bundleName, final String key, final Object[] parameters)1267 public static void logrb(final Logger logger, 1268 final Level level, 1269 final String bundleName, 1270 final String key, 1271 final Object[] parameters) { 1272 if (logger.isEnabledFor(level)) { 1273 forcedLog(logger, level, 1274 format(bundleName, key, parameters)); 1275 } 1276 } 1277 1278 /** 1279 * Log a parameterized message using a pattern from a resource bundle. 1280 * @param logger logger, may not be null. 1281 * @param level level, may not be null. 1282 * @param t throwable, may be null. 1283 * @param bundleName resource bundle name, may be null. 1284 * @param key key, may be null. 1285 * @param parameters parameters to the log message. 1286 */ logrb(final Logger logger, final Level level, final Throwable t, final String bundleName, final String key, final Object[] parameters)1287 public static void logrb(final Logger logger, 1288 final Level level, 1289 final Throwable t, 1290 final String bundleName, 1291 final String key, 1292 final Object[] parameters) { 1293 if (logger.isEnabledFor(level)) { 1294 forcedLog(logger, level, 1295 format(bundleName, key, parameters), t); 1296 } 1297 } 1298 1299 /** 1300 * Log a parameterized message using a pattern from a resource bundle. 1301 * @param logger logger, may not be null. 1302 * @param level level, may not be null. 1303 * @param bundleName resource bundle name, may be null. 1304 * @param key key, may be null. 1305 * @param param1 Parameter to the log message. 1306 */ logrb(final Logger logger, final Level level, final String bundleName, final String key, final Object param1)1307 public static void logrb(final Logger logger, 1308 final Level level, 1309 final String bundleName, 1310 final String key, 1311 final Object param1) { 1312 if (logger.isEnabledFor(level)) { 1313 forcedLog(logger, level, 1314 format(bundleName, key, toArray(param1))); 1315 } 1316 } 1317 1318 /** 1319 * Log a parameterized message using a pattern from a resource bundle. 1320 * @param logger logger, may not be null. 1321 * @param level level, may not be null. 1322 * @param bundleName resource bundle name, may be null. 1323 * @param key key, may be null. 1324 * @param param1 Parameter to the log message. 1325 */ logrb(final Logger logger, final Level level, final String bundleName, final String key, final boolean param1)1326 public static void logrb(final Logger logger, 1327 final Level level, 1328 final String bundleName, 1329 final String key, 1330 final boolean param1) { 1331 if (logger.isEnabledFor(level)) { 1332 forcedLog(logger, level, 1333 format(bundleName, key, toArray(valueOf(param1)))); 1334 } 1335 } 1336 1337 /** 1338 * Log a parameterized message using a pattern from a resource bundle. 1339 * @param logger logger, may not be null. 1340 * @param level level, may not be null. 1341 * @param bundleName resource bundle name, may be null. 1342 * @param key key, may be null. 1343 * @param param1 Parameter to the log message. 1344 */ logrb(final Logger logger, final Level level, final String bundleName, final String key, final char param1)1345 public static void logrb(final Logger logger, 1346 final Level level, 1347 final String bundleName, 1348 final String key, 1349 final char param1) { 1350 if (logger.isEnabledFor(level)) { 1351 forcedLog(logger, level, 1352 format(bundleName, key, toArray(valueOf(param1)))); 1353 } 1354 } 1355 1356 /** 1357 * Log a parameterized message using a pattern from a resource bundle. 1358 * @param logger logger, may not be null. 1359 * @param level level, may not be null. 1360 * @param bundleName resource bundle name, may be null. 1361 * @param key key, may be null. 1362 * @param param1 Parameter to the log message. 1363 */ logrb(final Logger logger, final Level level, final String bundleName, final String key, final byte param1)1364 public static void logrb(final Logger logger, 1365 final Level level, 1366 final String bundleName, 1367 final String key, 1368 final byte param1) { 1369 if (logger.isEnabledFor(level)) { 1370 forcedLog(logger, level, 1371 format(bundleName, key, toArray(valueOf(param1)))); 1372 } 1373 } 1374 1375 /** 1376 * Log a parameterized message using a pattern from a resource bundle. 1377 * @param logger logger, may not be null. 1378 * @param level level, may not be null. 1379 * @param bundleName resource bundle name, may be null. 1380 * @param key key, may be null. 1381 * @param param1 Parameter to the log message. 1382 */ logrb(final Logger logger, final Level level, final String bundleName, final String key, final short param1)1383 public static void logrb(final Logger logger, 1384 final Level level, 1385 final String bundleName, 1386 final String key, 1387 final short param1) { 1388 if (logger.isEnabledFor(level)) { 1389 forcedLog(logger, level, 1390 format(bundleName, key, toArray(valueOf(param1)))); 1391 } 1392 } 1393 1394 /** 1395 * Log a parameterized message using a pattern from a resource bundle. 1396 * @param logger logger, may not be null. 1397 * @param level level, may not be null. 1398 * @param bundleName resource bundle name, may be null. 1399 * @param key key, may be null. 1400 * @param param1 Parameter to the log message. 1401 */ logrb(final Logger logger, final Level level, final String bundleName, final String key, final int param1)1402 public static void logrb(final Logger logger, 1403 final Level level, 1404 final String bundleName, 1405 final String key, 1406 final int param1) { 1407 if (logger.isEnabledFor(level)) { 1408 forcedLog(logger, level, 1409 format(bundleName, key, toArray(valueOf(param1)))); 1410 } 1411 } 1412 1413 /** 1414 * Log a parameterized message using a pattern from a resource bundle. 1415 * @param logger logger, may not be null. 1416 * @param level level, may not be null. 1417 * @param bundleName resource bundle name, may be null. 1418 * @param key key, may be null. 1419 * @param param1 Parameter to the log message. 1420 */ logrb(final Logger logger, final Level level, final String bundleName, final String key, final long param1)1421 public static void logrb(final Logger logger, 1422 final Level level, 1423 final String bundleName, 1424 final String key, 1425 final long param1) { 1426 if (logger.isEnabledFor(level)) { 1427 forcedLog(logger, level, 1428 format(bundleName, key, toArray(valueOf(param1)))); 1429 } 1430 } 1431 /** 1432 * Log a parameterized message using a pattern from a resource bundle. 1433 * @param logger logger, may not be null. 1434 * @param level level, may not be null. 1435 * @param bundleName resource bundle name, may be null. 1436 * @param key key, may be null. 1437 * @param param1 Parameter to the log message. 1438 */ logrb(final Logger logger, final Level level, final String bundleName, final String key, final float param1)1439 public static void logrb(final Logger logger, 1440 final Level level, 1441 final String bundleName, 1442 final String key, 1443 final float param1) { 1444 if (logger.isEnabledFor(level)) { 1445 forcedLog(logger, level, 1446 format(bundleName, key, toArray(valueOf(param1)))); 1447 } 1448 } 1449 1450 1451 /** 1452 * Log a parameterized message using a pattern from a resource bundle. 1453 * @param logger logger, may not be null. 1454 * @param level level, may not be null. 1455 * @param bundleName resource bundle name, may be null. 1456 * @param key key, may be null. 1457 * @param param1 Parameter to the log message. 1458 */ logrb(final Logger logger, final Level level, final String bundleName, final String key, final double param1)1459 public static void logrb(final Logger logger, 1460 final Level level, 1461 final String bundleName, 1462 final String key, 1463 final double param1) { 1464 if (logger.isEnabledFor(level)) { 1465 forcedLog(logger, level, 1466 format(bundleName, key, toArray(valueOf(param1)))); 1467 } 1468 } 1469 1470 /** 1471 * Log a parameterized message using a pattern from a resource bundle. 1472 * @param logger logger, may not be null. 1473 * @param level level, may not be null. 1474 * @param bundleName resource bundle name, may be null. 1475 * @param key key, may be null. 1476 * @param param0 Parameter to the log message. 1477 * @param param1 Parameter to the log message. 1478 */ logrb(final Logger logger, final Level level, final String bundleName, final String key, final Object param0, final Object param1)1479 public static void logrb(final Logger logger, 1480 final Level level, 1481 final String bundleName, 1482 final String key, 1483 final Object param0, 1484 final Object param1) { 1485 if (logger.isEnabledFor(level)) { 1486 forcedLog(logger, level, 1487 format(bundleName, key, toArray(param0, param1))); 1488 } 1489 } 1490 1491 1492 /** 1493 * Log a parameterized message using a pattern from a resource bundle. 1494 * @param logger logger, may not be null. 1495 * @param level level, may not be null. 1496 * @param bundleName resource bundle name, may be null. 1497 * @param key key, may be null. 1498 * @param param0 Parameter to the log message. 1499 * @param param1 Parameter to the log message. 1500 * @param param2 Parameter to the log message. 1501 */ logrb(final Logger logger, final Level level, final String bundleName, final String key, final Object param0, final Object param1, final Object param2)1502 public static void logrb(final Logger logger, 1503 final Level level, 1504 final String bundleName, 1505 final String key, 1506 final Object param0, 1507 final Object param1, 1508 final Object param2) { 1509 if (logger.isEnabledFor(level)) { 1510 forcedLog(logger, level, 1511 format(bundleName, key, toArray(param0, param1, param2))); 1512 } 1513 } 1514 1515 1516 /** 1517 * Log a parameterized message using a pattern from a resource bundle. 1518 * @param logger logger, may not be null. 1519 * @param level level, may not be null. 1520 * @param bundleName resource bundle name, may be null. 1521 * @param key key, may be null. 1522 * @param param0 Parameter to the log message. 1523 * @param param1 Parameter to the log message. 1524 * @param param2 Parameter to the log message. 1525 * @param param3 Parameter to the log message. 1526 */ logrb(final Logger logger, final Level level, final String bundleName, final String key, final Object param0, final Object param1, final Object param2, final Object param3)1527 public static void logrb(final Logger logger, 1528 final Level level, 1529 final String bundleName, 1530 final String key, 1531 final Object param0, 1532 final Object param1, 1533 final Object param2, 1534 final Object param3) { 1535 if (logger.isEnabledFor(level)) { 1536 forcedLog(logger, level, 1537 format(bundleName, key, 1538 toArray(param0, param1, param2, param3))); 1539 } 1540 } 1541 } 1542