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