View Javadoc

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  
27  
28  /***
29   * This class provides static methods to
30   * format log messages using java.text.MessageFormat.
31   *
32   */
33  public final class LogMF {
34      /***
35       * Trace level.
36       */
37      private static final Level TRACE = new Level(5000, "TRACE", 7);
38      /***
39       * private constructor.
40       *
41       */
42      private LogMF() {
43      }
44  
45  
46      /***
47       * Returns a Boolean instance representing the specified boolean.
48       * Boolean.valueOf was added in JDK 1.4.
49       * @param b a boolean value.
50       * @return a Boolean instance representing b.
51       */
52      private static Boolean valueOf(final boolean b) {
53          if (b) {
54              return Boolean.TRUE;
55          }
56          return Boolean.FALSE;
57      }
58  
59      /***
60       * Returns a Character instance representing the specified char.
61       * Character.valueOf was added in JDK 1.5.
62       * @param c a character value.
63       * @return a Character instance representing c.
64       */
65      private static Character valueOf(final char c) {
66          return new Character(c);
67      }
68  
69      /***
70       * Returns a Byte instance representing the specified byte.
71       * Byte.valueOf was added in JDK 1.5.
72       * @param b a byte value.
73       * @return a Byte instance representing b.
74       */
75      private static Byte valueOf(final byte b) {
76          return new Byte(b);
77      }
78  
79      /***
80       * Returns a Short instance representing the specified short.
81       * Short.valueOf was added in JDK 1.5.
82       * @param b a short value.
83       * @return a Byte instance representing b.
84       */
85      private static Short valueOf(final short b) {
86          return new Short(b);
87      }
88  
89      /***
90       * Returns an Integer instance representing the specified int.
91       * Integer.valueOf was added in JDK 1.5.
92       * @param b an int value.
93       * @return an Integer instance representing b.
94       */
95      private static Integer valueOf(final int b) {
96          return new Integer(b);
97      }
98  
99      /***
100      * Returns a Long instance representing the specified long.
101      * Long.valueOf was added in JDK 1.5.
102      * @param b a long value.
103      * @return a Long instance representing b.
104      */
105     private static Long valueOf(final long b) {
106         return new Long(b);
107     }
108 
109     /***
110      * Returns a Float instance representing the specified float.
111      * Float.valueOf was added in JDK 1.5.
112      * @param b a float value.
113      * @return a Float instance representing b.
114      */
115     private static Float valueOf(final float b) {
116         return new Float(b);
117     }
118 
119     /***
120      * Returns a Double instance representing the specified double.
121      * Double.valueOf was added in JDK 1.5.
122      * @param b a double value.
123      * @return a Byte instance representing b.
124      */
125     private static Double valueOf(final double b) {
126         return new Double(b);
127     }
128 
129 
130 
131     /***
132      * Create new array.
133      * @param param1 parameter 1.
134      * @return  new array.
135      */
136     private static Object[] toArray(final Object param1) {
137         return new Object[] {
138                 param1
139         };
140     }
141 
142     /***
143      * Create new array.
144      * @param param1 parameter 1.
145      * @param param2 parameter 2.
146      * @return  new array.
147      */
148     private static Object[] toArray(final Object param1,
149                              final Object param2) {
150         return new Object[] {
151                 param1, param2
152         };
153     }
154 
155     /***
156      * Create new array.
157      * @param param1 parameter 1.
158      * @param param2 parameter 2.
159      * @param param3 parameter 3.
160      * @return  new array.
161      */
162     private static Object[] toArray(final Object param1,
163                              final Object param2,
164                              final Object param3) {
165         return new Object[] {
166                 param1, param2, param3
167         };
168     }
169 
170     /***
171      * Create new array.
172      * @param param1 parameter 1.
173      * @param param2 parameter 2.
174      * @param param3 parameter 3.
175      * @param param4 parameter 4.
176      * @return  new array.
177      */
178     private static Object[] toArray(final Object param1,
179                              final Object param2,
180                              final Object param3,
181                              final Object param4) {
182         return new Object[] {
183                 param1, param2, param3, param4
184         };
185     }
186 
187     /***
188      * Formats arguments using a minimal subset
189      * of MessageFormat syntax.
190      * @param pattern pattern, may not be null.
191      * @param arg0 argument, may be null.
192      * @return Message string or null if pattern
193      * is not supported.
194      */
195     private static String subsetFormat(final String pattern,
196                                        final Object arg0) {
197         if (pattern != null) {
198             //
199             //  find position of first brace
200             //    if none then format is a literal
201             int bracePos = pattern.indexOf("{");
202 
203             //
204             //  if the first format is {0}
205             //    and there are no other format specifiers
206             //    and no quotes then substitute for {0}
207             if (bracePos != -1) {
208                 if ((pattern.indexOf("{0}", bracePos) == bracePos)
209                         && (pattern.indexOf("{", bracePos + 1) == -1)
210                         && (pattern.indexOf("'") == -1)) {
211                     String replacement;
212 
213                     if (arg0 instanceof String) {
214                         replacement = arg0.toString();
215                     } else if (arg0 instanceof Number) {
216                         replacement = NumberFormat.getInstance().format(arg0);
217                     } else if (arg0 instanceof Date) {
218                         replacement = DateFormat.getDateTimeInstance(
219                                 DateFormat.SHORT,
220                                 DateFormat.SHORT).format(arg0);
221                     } else {
222                         replacement = String.valueOf(arg0);
223                     }
224 
225                     final StringBuffer buf = new StringBuffer(pattern);
226                     buf.replace(bracePos,
227                             bracePos + "{0}".length(), replacement);
228 
229                     return buf.toString();
230                 }
231             } else {
232                 //
233                 //   pattern is a literal with no braces
234                 //    and not quotes, return pattern.
235                 if (pattern.indexOf("'") == -1) {
236                     return pattern;
237                 }
238             }
239         }
240 
241         return null;
242     }
243 
244     /***
245      * Formats arguments using MessageFormat.
246      * @param pattern pattern, may be malformed or null.
247      * @param arguments arguments, may be null or mismatched.
248      * @return Message string or null
249      */
250     private static String format(final String pattern,
251                                  final Object[] arguments) {
252         if (pattern == null) {
253             return null;
254         }
255         try {
256             return MessageFormat.format(pattern, arguments);
257         } catch (IllegalArgumentException ex) {
258             return pattern;
259         }
260     }
261 
262     /***
263      * Formats arguments using MessageFormat.
264      * @param pattern pattern, may be malformed.
265      * @param arg0 argument, may be null or mismatched.
266      * @return Message string
267      */
268     private static String format(final String pattern, final Object arg0) {
269         String msg = subsetFormat(pattern, arg0);
270 
271         if (msg == null) {
272             msg = format(pattern, toArray(arg0));
273         }
274 
275         return msg;
276     }
277 
278     /***
279      * Formats arguments using MessageFormat using a pattern from
280      * a resource bundle.
281      * @param resourceBundleName name of resource bundle, may be null.
282      * @param key key for pattern in resource bundle, may be null.
283      * @param arguments arguments, may be null or mismatched.
284      * @return Message string or null
285      */
286     private static String format(
287             final String resourceBundleName,
288             final String key,
289             final Object[] arguments) {
290         String pattern;
291         if (resourceBundleName != null) {
292             try {
293                 ResourceBundle bundle =
294                         ResourceBundle.getBundle(resourceBundleName);
295                 pattern = bundle.getString(key);
296             } catch (Exception ex) {
297                 pattern = key;
298             }
299         } else {
300             pattern = key;
301         }
302         return format(pattern, arguments);
303     }
304 
305 
306     /***
307      * Fully Qualified Class Name of this class.
308      */
309     private static final String FQCN = LogMF.class.getName();
310 
311     /***
312      * Equivalent of Logger.forcedLog.
313      *
314      * @param logger logger, may not be null.
315      * @param level level, may not be null.
316      * @param msg message, may be null.
317      */
318     private static void forcedLog(final Logger logger,
319                                   final Level level,
320                                   final String msg) {
321         logger.callAppenders(new LoggingEvent(FQCN, logger, level, msg, null));
322     }
323 
324     /***
325      * Equivalent of Logger.forcedLog.
326      *
327      * @param logger logger, may not be null.
328      * @param level level, may not be null.
329      * @param msg message, may be null.
330      * @param t throwable.
331      */
332     private static void forcedLog(final Logger logger,
333                                   final Level level,
334                                   final String msg,
335                                   final Throwable t) {
336         logger.callAppenders(new LoggingEvent(FQCN, logger, level, msg, t));
337     }
338     /***
339          * Log a parameterized message at trace level.
340          * @param logger logger, may not be null.
341          * @param pattern pattern, may be null.
342          * @param arguments an array of arguments to be
343          *          formatted and substituted.
344          */
345     public static void trace(final Logger logger, final String pattern,
346         final Object[] arguments) {
347         if (logger.isEnabledFor(TRACE)) {
348             forcedLog(logger, TRACE, format(pattern, arguments));
349         }
350     }
351 
352     /***
353      * Log a parameterized message at debug 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 debug(final Logger logger, final String pattern,
359         final Object[] arguments) {
360         if (logger.isDebugEnabled()) {
361             forcedLog(logger, Level.DEBUG, format(pattern, arguments));
362         }
363     }
364 
365     /***
366      * Log a parameterized message at info 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 info(final Logger logger, final String pattern,
372         final Object[] arguments) {
373         if (logger.isInfoEnabled()) {
374             forcedLog(logger, Level.INFO, format(pattern, arguments));
375         }
376     }
377 
378     /***
379      * Log a parameterized message at warn level.
380      * @param logger logger, may not be null.
381      * @param pattern pattern, may be null.
382      * @param arguments an array of arguments to be formatted and substituted.
383      */
384     public static void warn(final Logger logger, final String pattern,
385         final Object[] arguments) {
386         if (logger.isEnabledFor(Level.WARN)) {
387             forcedLog(logger, Level.WARN, format(pattern, arguments));
388         }
389     }
390 
391     /***
392      * Log a parameterized message at error level.
393      * @param logger logger, may not be null.
394      * @param pattern pattern, may be null.
395      * @param arguments an array of arguments to be formatted and substituted.
396      */
397     public static void error(final Logger logger, final String pattern,
398         final Object[] arguments) {
399         if (logger.isEnabledFor(Level.ERROR)) {
400             forcedLog(logger, Level.ERROR, format(pattern, arguments));
401         }
402     }
403 
404     /***
405      * Log a parameterized message at fatal level.
406      * @param logger logger, may not be null.
407      * @param pattern pattern, may be null.
408      * @param arguments an array of arguments to be formatted and substituted.
409      */
410     public static void fatal(final Logger logger, final String pattern,
411         final Object[] arguments) {
412         if (logger.isEnabledFor(Level.FATAL)) {
413             forcedLog(logger, Level.FATAL, format(pattern, arguments));
414         }
415     }
416 
417     /***
418          * Log a parameterized message at trace level.
419          * @param logger logger, may not be null.
420          * @param t throwable, may be null.
421          * @param pattern pattern, may be null.
422          * @param arguments an array of arguments to be
423          *          formatted and substituted.
424          */
425     public static void trace(final Logger logger,
426                              final Throwable t,
427                              final String pattern,
428         final Object[] arguments) {
429         if (logger.isEnabledFor(TRACE)) {
430             forcedLog(logger, TRACE, format(pattern, arguments), t);
431         }
432     }
433 
434     /***
435      * Log a parameterized message at debug level.
436      * @param logger logger, may not be null.
437      * @param t throwable, may be null.
438      * @param pattern pattern, may be null.
439      * @param arguments an array of arguments to be formatted and substituted.
440      */
441     public static void debug(final Logger logger,
442                              final Throwable t,
443                              final String pattern,
444         final Object[] arguments) {
445         if (logger.isDebugEnabled()) {
446             forcedLog(logger, Level.DEBUG, format(pattern, arguments), t);
447         }
448     }
449 
450     /***
451      * Log a parameterized message at info level.
452      * @param logger logger, may not be null.
453      * @param t throwable, may be null.
454      * @param pattern pattern, may be null.
455      * @param arguments an array of arguments to be formatted and substituted.
456      */
457     public static void info(final Logger logger,
458                             final Throwable t,
459                             final String pattern,
460         final Object[] arguments) {
461         if (logger.isInfoEnabled()) {
462             forcedLog(logger, Level.INFO, format(pattern, arguments), t);
463         }
464     }
465 
466     /***
467      * Log a parameterized message at warn level.
468      * @param logger logger, may not be null.
469      * @param t throwable, may be null.
470      * @param pattern pattern, may be null.
471      * @param arguments an array of arguments to be formatted and substituted.
472      */
473     public static void warn(final Logger logger,
474                             final Throwable t,
475                             final String pattern,
476         final Object[] arguments) {
477         if (logger.isEnabledFor(Level.WARN)) {
478             forcedLog(logger, Level.WARN, format(pattern, arguments), t);
479         }
480     }
481 
482     /***
483      * Log a parameterized message at error level.
484      * @param logger logger, may not be null.
485      * @param t throwable, may be null.
486      * @param pattern pattern, may be null.
487      * @param arguments an array of arguments to be formatted and substituted.
488      */
489     public static void error(final Logger logger,
490                              final Throwable t,
491                              final String pattern,
492         final Object[] arguments) {
493         if (logger.isEnabledFor(Level.ERROR)) {
494             forcedLog(logger, Level.ERROR, format(pattern, arguments), t);
495         }
496     }
497 
498     /***
499      * Log a parameterized message at fatal level.
500      * @param logger logger, may not be null.
501      * @param t throwable, may be null.
502      * @param pattern pattern, may be null.
503      * @param arguments an array of arguments to be formatted and substituted.
504      */
505     public static void fatal(final Logger logger,
506                              final Throwable t,
507                              final String pattern,
508         final Object[] arguments) {
509         if (logger.isEnabledFor(Level.FATAL)) {
510             forcedLog(logger, Level.FATAL, format(pattern, arguments), t);
511         }
512     }
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 boolean 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 char 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 byte 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 short 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 int 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 long argument) {
589         if (logger.isEnabledFor(TRACE)) {
590             forcedLog(logger, TRACE, format(pattern, valueOf(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 argument a value to be formatted and substituted.
599      */
600     public static void trace(final Logger logger, final String pattern,
601         final float argument) {
602         if (logger.isEnabledFor(TRACE)) {
603             forcedLog(logger, TRACE, format(pattern, valueOf(argument)));
604         }
605     }
606 
607     /***
608      * Log a parameterized message at trace level.
609      * @param logger logger, may not be null.
610      * @param pattern pattern, may be null.
611      * @param argument a value to be formatted and substituted.
612      */
613     public static void trace(final Logger logger, final String pattern,
614         final double argument) {
615         if (logger.isEnabledFor(TRACE)) {
616             forcedLog(logger, TRACE, format(pattern, valueOf(argument)));
617         }
618     }
619 
620     /***
621      * Log a parameterized message at trace level.
622      * @param logger logger, may not be null.
623      * @param pattern pattern, may be null.
624      * @param argument a value to be formatted and substituted.
625      */
626     public static void trace(final Logger logger, final String pattern,
627         final Object argument) {
628         if (logger.isEnabledFor(TRACE)) {
629             forcedLog(logger, TRACE, format(pattern, argument));
630         }
631     }
632 
633     /***
634      * Log a parameterized message at trace level.
635      * @param logger logger, may not be null.
636      * @param pattern pattern, may be null.
637      * @param arg0 a value to be formatted and substituted.
638      * @param arg1 a value to be formatted and substituted.
639      */
640     public static void trace(final Logger logger, final String pattern,
641         final Object arg0, final Object arg1) {
642         if (logger.isEnabledFor(TRACE)) {
643             forcedLog(logger, TRACE,
644                     format(pattern, toArray(arg0, arg1)));
645         }
646     }
647 
648     /***
649      * Log a parameterized message at trace level.
650      * @param logger logger, may not be null.
651      * @param pattern pattern, may be null.
652      * @param arg0 a value to be formatted and substituted.
653      * @param arg1 a value to be formatted and substituted.
654      * @param arg2 a value to be formatted and substituted.
655      */
656     public static void trace(final Logger logger, final String pattern,
657         final Object arg0, final Object arg1, final Object arg2) {
658         if (logger.isEnabledFor(TRACE)) {
659             forcedLog(logger, TRACE,
660                     format(pattern, toArray(arg0, arg1, arg2)));
661         }
662     }
663 
664     /***
665      * Log a parameterized message at trace level.
666      * @param logger logger, may not be null.
667      * @param pattern pattern, may be null.
668      * @param arg0 a value to be formatted and substituted.
669      * @param arg1 a value to be formatted and substituted.
670      * @param arg2 a value to be formatted and substituted.
671      * @param arg3 a value to be formatted and substituted.
672      */
673     public static void trace(final Logger logger, final String pattern,
674         final Object arg0, final Object arg1, final Object arg2,
675         final Object arg3) {
676         if (logger.isEnabledFor(TRACE)) {
677             forcedLog(logger, TRACE,
678                     format(pattern, toArray(arg0, arg1, arg2, arg3)));
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 boolean 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 char 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 byte 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 short 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 int 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 long argument) {
755         if (logger.isDebugEnabled()) {
756             forcedLog(logger, Level.DEBUG, format(pattern, valueOf(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 argument a value to be formatted and substituted.
765      */
766     public static void debug(final Logger logger, final String pattern,
767         final float argument) {
768         if (logger.isDebugEnabled()) {
769             forcedLog(logger, Level.DEBUG, format(pattern, valueOf(argument)));
770         }
771     }
772 
773     /***
774      * Log a parameterized message at debug level.
775      * @param logger logger, may not be null.
776      * @param pattern pattern, may be null.
777      * @param argument a value to be formatted and substituted.
778      */
779     public static void debug(final Logger logger, final String pattern,
780         final double argument) {
781         if (logger.isDebugEnabled()) {
782             forcedLog(logger, Level.DEBUG, format(pattern, valueOf(argument)));
783         }
784     }
785 
786     /***
787      * Log a parameterized message at debug level.
788      * @param logger logger, may not be null.
789      * @param pattern pattern, may be null.
790      * @param argument a value to be formatted and substituted.
791      */
792     public static void debug(final Logger logger, final String pattern,
793         final Object argument) {
794         if (logger.isDebugEnabled()) {
795             forcedLog(logger, Level.DEBUG, format(pattern, argument));
796         }
797     }
798 
799     /***
800      * Log a parameterized message at debug level.
801      * @param logger logger, may not be null.
802      * @param pattern pattern, may be null.
803      * @param arg0 a value to be formatted and substituted.
804      * @param arg1 a value to be formatted and substituted.
805      */
806     public static void debug(final Logger logger, final String pattern,
807         final Object arg0, final Object arg1) {
808         if (logger.isDebugEnabled()) {
809             forcedLog(logger, Level.DEBUG,
810                     format(pattern, toArray(arg0, arg1)));
811         }
812     }
813 
814     /***
815      * Log a parameterized message at debug level.
816      * @param logger logger, may not be null.
817      * @param pattern pattern, may be null.
818      * @param arg0 a value to be formatted and substituted.
819      * @param arg1 a value to be formatted and substituted.
820      * @param arg2 a value to be formatted and substituted.
821      */
822     public static void debug(final Logger logger, final String pattern,
823         final Object arg0, final Object arg1, final Object arg2) {
824         if (logger.isDebugEnabled()) {
825             forcedLog(logger, Level.DEBUG,
826                     format(pattern, toArray(arg0, arg1, arg2)));
827         }
828     }
829 
830     /***
831      * Log a parameterized message at debug level.
832      * @param logger logger, may not be null.
833      * @param pattern pattern, may be null.
834      * @param arg0 a value to be formatted and substituted.
835      * @param arg1 a value to be formatted and substituted.
836      * @param arg2 a value to be formatted and substituted.
837      * @param arg3 a value to be formatted and substituted.
838      */
839     public static void debug(final Logger logger, final String pattern,
840         final Object arg0, final Object arg1, final Object arg2,
841         final Object arg3) {
842         if (logger.isDebugEnabled()) {
843             forcedLog(logger, Level.DEBUG,
844                     format(pattern, toArray(arg0, arg1, arg2, arg3)));
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 boolean 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 char 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 byte 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 short 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 int 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 long argument) {
921         if (logger.isInfoEnabled()) {
922             forcedLog(logger, Level.INFO, format(pattern, valueOf(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 argument a value to be formatted and substituted.
931      */
932     public static void info(final Logger logger, final String pattern,
933         final float argument) {
934         if (logger.isInfoEnabled()) {
935             forcedLog(logger, Level.INFO, format(pattern, valueOf(argument)));
936         }
937     }
938 
939     /***
940      * Log a parameterized message at info level.
941      * @param logger logger, may not be null.
942      * @param pattern pattern, may be null.
943      * @param argument a value to be formatted and substituted.
944      */
945     public static void info(final Logger logger, final String pattern,
946         final double argument) {
947         if (logger.isInfoEnabled()) {
948             forcedLog(logger, Level.INFO, format(pattern, valueOf(argument)));
949         }
950     }
951 
952     /***
953      * Log a parameterized message at info level.
954      * @param logger logger, may not be null.
955      * @param pattern pattern, may be null.
956      * @param argument a value to be formatted and substituted.
957      */
958     public static void info(final Logger logger, final String pattern,
959         final Object argument) {
960         if (logger.isInfoEnabled()) {
961             forcedLog(logger, Level.INFO, format(pattern, argument));
962         }
963     }
964 
965     /***
966      * Log a parameterized message at info level.
967      * @param logger logger, may not be null.
968      * @param pattern pattern, may be null.
969      * @param arg0 a value to be formatted and substituted.
970      * @param arg1 a value to be formatted and substituted.
971      */
972     public static void info(final Logger logger, final String pattern,
973         final Object arg0, final Object arg1) {
974         if (logger.isInfoEnabled()) {
975             forcedLog(logger, Level.INFO, format(pattern, toArray(arg0, arg1)));
976         }
977     }
978 
979     /***
980      * Log a parameterized message at info level.
981      * @param logger logger, may not be null.
982      * @param pattern pattern, may be null.
983      * @param arg0 a value to be formatted and substituted.
984      * @param arg1 a value to be formatted and substituted.
985      * @param arg2 a value to be formatted and substituted.
986      */
987     public static void info(final Logger logger, final String pattern,
988         final Object arg0, final Object arg1, final Object arg2) {
989         if (logger.isInfoEnabled()) {
990             forcedLog(logger, Level.INFO, format(pattern,
991                     toArray(arg0, arg1, arg2)));
992         }
993     }
994 
995     /***
996      * Log a parameterized message at info level.
997      * @param logger logger, may not be null.
998      * @param pattern pattern, may be null.
999      * @param arg0 a value to be formatted and substituted.
1000      * @param arg1 a value to be formatted and substituted.
1001      * @param arg2 a value to be formatted and substituted.
1002      * @param arg3 a value to be formatted and substituted.
1003      */
1004     public static void info(final Logger logger, final String pattern,
1005         final Object arg0, final Object arg1, final Object arg2,
1006         final Object arg3) {
1007         if (logger.isInfoEnabled()) {
1008             forcedLog(logger, Level.INFO, format(pattern,
1009                     toArray(arg0, arg1, arg2, arg3)));
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 boolean 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 char 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 byte 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 short 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 int 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 long argument) {
1086         if (logger.isEnabledFor(Level.WARN)) {
1087             forcedLog(logger, Level.WARN, format(pattern, valueOf(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 argument a value to be formatted and substituted.
1096      */
1097     public static void warn(final Logger logger, final String pattern,
1098         final float argument) {
1099         if (logger.isEnabledFor(Level.WARN)) {
1100             forcedLog(logger, Level.WARN, format(pattern, valueOf(argument)));
1101         }
1102     }
1103 
1104     /***
1105      * Log a parameterized message at warn level.
1106      * @param logger logger, may not be null.
1107      * @param pattern pattern, may be null.
1108      * @param argument a value to be formatted and substituted.
1109      */
1110     public static void warn(final Logger logger, final String pattern,
1111         final double argument) {
1112         if (logger.isEnabledFor(Level.WARN)) {
1113             forcedLog(logger, Level.WARN, format(pattern, valueOf(argument)));
1114         }
1115     }
1116 
1117     /***
1118      * Log a parameterized message at warn level.
1119      * @param logger logger, may not be null.
1120      * @param pattern pattern, may be null.
1121      * @param argument a value to be formatted and substituted.
1122      */
1123     public static void warn(final Logger logger, final String pattern,
1124         final Object argument) {
1125         if (logger.isEnabledFor(Level.WARN)) {
1126             forcedLog(logger, Level.WARN, format(pattern, argument));
1127         }
1128     }
1129 
1130     /***
1131      * Log a parameterized message at warn level.
1132      * @param logger logger, may not be null.
1133      * @param pattern pattern, may be null.
1134      * @param arg0 a value to be formatted and substituted.
1135      * @param arg1 a value to be formatted and substituted.
1136      */
1137     public static void warn(final Logger logger, final String pattern,
1138         final Object arg0, final Object arg1) {
1139         if (logger.isEnabledFor(Level.WARN)) {
1140             forcedLog(logger, Level.WARN,
1141                     format(pattern, toArray(arg0, arg1)));
1142         }
1143     }
1144 
1145     /***
1146      * Log a parameterized message at warn level.
1147      * @param logger logger, may not be null.
1148      * @param pattern pattern, may be null.
1149      * @param arg0 a value to be formatted and substituted.
1150      * @param arg1 a value to be formatted and substituted.
1151      * @param arg2 a value to be formatted and substituted.
1152      */
1153     public static void warn(final Logger logger, final String pattern,
1154         final Object arg0, final Object arg1, final Object arg2) {
1155         if (logger.isEnabledFor(Level.WARN)) {
1156             forcedLog(logger, Level.WARN,
1157                     format(pattern, toArray(arg0, arg1, arg2)));
1158         }
1159     }
1160 
1161     /***
1162      * Log a parameterized message at warn level.
1163      * @param logger logger, may not be null.
1164      * @param pattern pattern, may be null.
1165      * @param arg0 a value to be formatted and substituted.
1166      * @param arg1 a value to be formatted and substituted.
1167      * @param arg2 a value to be formatted and substituted.
1168      * @param arg3 a value to be formatted and substituted.
1169      */
1170     public static void warn(final Logger logger, final String pattern,
1171         final Object arg0, final Object arg1, final Object arg2,
1172         final Object arg3) {
1173         if (logger.isEnabledFor(Level.WARN)) {
1174             forcedLog(logger, Level.WARN, format(pattern,
1175                     toArray(arg0, arg1, arg2, arg3)));
1176         }
1177     }
1178 
1179     /***
1180       * Log a parameterized message at specified level.
1181       * @param logger logger, may not be null.
1182       * @param level level, may not be null.
1183       * @param pattern pattern, may be null.
1184      * @param parameters parameters to the log message.
1185       */
1186     public static void log(final Logger logger,
1187                              final Level level,
1188                              final String pattern,
1189                              final Object[] parameters) {
1190         if (logger.isEnabledFor(level)) {
1191             forcedLog(logger, level,
1192                     format(pattern, parameters));
1193         }
1194     }
1195 
1196     /***
1197       * Log a parameterized message at specified level.
1198       * @param logger logger, may not be null.
1199       * @param level level, may not be null.
1200      * @param t throwable, may be null.
1201       * @param pattern pattern, may be null.
1202      * @param parameters parameters to the log message.
1203       */
1204     public static void log(final Logger logger,
1205                              final Level level,
1206                              final Throwable t,
1207                              final String pattern,
1208                              final Object[] parameters) {
1209         if (logger.isEnabledFor(level)) {
1210             forcedLog(logger, level,
1211                     format(pattern, parameters), t);
1212         }
1213     }
1214 
1215     /***
1216       * Log a parameterized message at specified level.
1217       * @param logger logger, may not be null.
1218       * @param level level, may not be null.
1219       * @param pattern pattern, may be null.
1220      * @param param1 parameter to the log message.
1221       */
1222     public static void log(final Logger logger,
1223                              final Level level,
1224                              final String pattern,
1225                              final Object param1) {
1226         if (logger.isEnabledFor(level)) {
1227             forcedLog(logger, level,
1228                     format(pattern, toArray(param1)));
1229         }
1230     }
1231 
1232     /***
1233       * Log a parameterized message at specified level.
1234       * @param logger logger, may not be null.
1235       * @param level level, may not be null.
1236       * @param pattern pattern, may be null.
1237      * @param param1 parameter to the log message.
1238       */
1239     public static void log(final Logger logger,
1240                              final Level level,
1241                              final String pattern,
1242                              final boolean param1) {
1243         if (logger.isEnabledFor(level)) {
1244             forcedLog(logger, level,
1245                     format(pattern, toArray(valueOf(param1))));
1246         }
1247     }
1248 
1249 
1250     /***
1251       * Log a parameterized message at specified level.
1252       * @param logger logger, may not be null.
1253       * @param level level, may not be null.
1254       * @param pattern pattern, may be null.
1255      * @param param1 parameter to the log message.
1256       */
1257     public static void log(final Logger logger,
1258                              final Level level,
1259                              final String pattern,
1260                              final byte param1) {
1261         if (logger.isEnabledFor(level)) {
1262             forcedLog(logger, level,
1263                     format(pattern, toArray(valueOf(param1))));
1264         }
1265     }
1266 
1267 
1268     /***
1269       * Log a parameterized message at specified level.
1270       * @param logger logger, may not be null.
1271       * @param level level, may not be null.
1272       * @param pattern pattern, may be null.
1273      * @param param1 parameter to the log message.
1274       */
1275     public static void log(final Logger logger,
1276                              final Level level,
1277                              final String pattern,
1278                              final char param1) {
1279         if (logger.isEnabledFor(level)) {
1280             forcedLog(logger, level,
1281                     format(pattern, toArray(valueOf(param1))));
1282         }
1283     }
1284 
1285     /***
1286       * Log a parameterized message at specified level.
1287       * @param logger logger, may not be null.
1288       * @param level level, may not be null.
1289       * @param pattern pattern, may be null.
1290      * @param param1 parameter to the log message.
1291       */
1292     public static void log(final Logger logger,
1293                              final Level level,
1294                              final String pattern,
1295                              final short param1) {
1296         if (logger.isEnabledFor(level)) {
1297             forcedLog(logger, level,
1298                     format(pattern, toArray(valueOf(param1))));
1299         }
1300     }
1301 
1302     /***
1303       * Log a parameterized message at specified level.
1304       * @param logger logger, may not be null.
1305       * @param level level, may not be null.
1306       * @param pattern pattern, may be null.
1307      * @param param1 parameter to the log message.
1308       */
1309     public static void log(final Logger logger,
1310                              final Level level,
1311                              final String pattern,
1312                              final int param1) {
1313         if (logger.isEnabledFor(level)) {
1314             forcedLog(logger, level,
1315                     format(pattern, toArray(valueOf(param1))));
1316         }
1317     }
1318 
1319 
1320     /***
1321       * Log a parameterized message at specified level.
1322       * @param logger logger, may not be null.
1323       * @param level level, may not be null.
1324       * @param pattern pattern, may be null.
1325      * @param param1 parameter to the log message.
1326       */
1327     public static void log(final Logger logger,
1328                              final Level level,
1329                              final String pattern,
1330                              final long param1) {
1331         if (logger.isEnabledFor(level)) {
1332             forcedLog(logger, level,
1333                     format(pattern, toArray(valueOf(param1))));
1334         }
1335     }
1336 
1337 
1338     /***
1339       * Log a parameterized message at specified level.
1340       * @param logger logger, may not be null.
1341       * @param level level, may not be null.
1342       * @param pattern pattern, may be null.
1343      * @param param1 parameter to the log message.
1344       */
1345     public static void log(final Logger logger,
1346                              final Level level,
1347                              final String pattern,
1348                              final float param1) {
1349         if (logger.isEnabledFor(level)) {
1350             forcedLog(logger, level,
1351                     format(pattern, toArray(valueOf(param1))));
1352         }
1353     }
1354 
1355 
1356     /***
1357       * Log a parameterized message at specified level.
1358       * @param logger logger, may not be null.
1359       * @param level level, may not be null.
1360       * @param pattern pattern, may be null.
1361      * @param param1 parameter to the log message.
1362       */
1363     public static void log(final Logger logger,
1364                              final Level level,
1365                              final String pattern,
1366                              final double param1) {
1367         if (logger.isEnabledFor(level)) {
1368             forcedLog(logger, level,
1369                     format(pattern, toArray(valueOf(param1))));
1370         }
1371     }
1372 
1373 
1374     /***
1375      * Log a parameterized message at specified level.
1376      * @param logger logger, may not be null.
1377      * @param level level, may not be null.
1378      * @param pattern pattern, may be null.
1379      * @param arg0 a value to be formatted and substituted.
1380      * @param arg1 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) {
1386         if (logger.isEnabledFor(level)) {
1387             forcedLog(logger, level,
1388                     format(pattern, toArray(arg0, arg1)));
1389         }
1390     }
1391 
1392     /***
1393      * Log a parameterized message at specifed level.
1394      * @param logger logger, may not be null.
1395      * @param level level, may not be null.
1396      * @param pattern pattern, may be null.
1397      * @param arg0 a value to be formatted and substituted.
1398      * @param arg1 a value to be formatted and substituted.
1399      * @param arg2 a value to be formatted and substituted.
1400      */
1401     public static void log(final Logger logger,
1402                            final Level level,
1403                            final String pattern,
1404         final Object arg0, final Object arg1, final Object arg2) {
1405         if (logger.isEnabledFor(level)) {
1406             forcedLog(logger, level,
1407                     format(pattern, toArray(arg0, arg1, arg2)));
1408         }
1409     }
1410 
1411     /***
1412      * Log a parameterized message at specified level.
1413      * @param logger logger, may not be null.
1414      * @param pattern pattern, may be null.
1415      * @param level level, may not be null.
1416      * @param arg0 a value to be formatted and substituted.
1417      * @param arg1 a value to be formatted and substituted.
1418      * @param arg2 a value to be formatted and substituted.
1419      * @param arg3 a value to be formatted and substituted.
1420      */
1421     public static void log(final Logger logger,
1422                            final Level level,
1423                            final String pattern,
1424         final Object arg0, final Object arg1, final Object arg2,
1425         final Object arg3) {
1426         if (logger.isEnabledFor(level)) {
1427             forcedLog(logger, level, format(pattern,
1428                     toArray(arg0, arg1, arg2, arg3)));
1429         }
1430     }
1431 
1432 
1433     /***
1434       * Log a parameterized message using a pattern from a resource bundle.
1435       * @param logger logger, may not be null.
1436       * @param level level, may not be null.
1437       * @param bundleName resource bundle name, may be null.
1438      * @param key key, may be null.
1439      * @param parameters parameters to the log message.
1440       */
1441     public static void logrb(final Logger logger,
1442                              final Level level,
1443                              final String bundleName,
1444                              final String key,
1445                              final Object[] parameters) {
1446         if (logger.isEnabledFor(level)) {
1447             forcedLog(logger, level,
1448                     format(bundleName, key, parameters));
1449         }
1450     }
1451 
1452     /***
1453       * Log a parameterized message using a pattern from a resource bundle.
1454       * @param logger logger, may not be null.
1455       * @param level level, may not be null.
1456      * @param t throwable, may be null.
1457       * @param bundleName resource bundle name, may be null.
1458      * @param key key, may be null.
1459      * @param parameters parameters to the log message.
1460       */
1461     public static void logrb(final Logger logger,
1462                              final Level level,
1463                              final Throwable t,
1464                              final String bundleName,
1465                              final String key,
1466                              final Object[] parameters) {
1467         if (logger.isEnabledFor(level)) {
1468             forcedLog(logger, level,
1469                     format(bundleName, key, parameters), t);
1470         }
1471     }
1472 
1473     /***
1474       * Log a parameterized message using a pattern from a resource bundle.
1475       * @param logger logger, may not be null.
1476       * @param level level, may not be null.
1477       * @param bundleName resource bundle name, may be null.
1478      * @param key key, may be null.
1479      * @param param1 Parameter to the log message.
1480       */
1481     public static void logrb(final Logger logger,
1482                              final Level level,
1483                              final String bundleName,
1484                              final String key,
1485                              final Object param1) {
1486         if (logger.isEnabledFor(level)) {
1487             forcedLog(logger, level,
1488                     format(bundleName, key, toArray(param1)));
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 param1 Parameter to the log message.
1499       */
1500     public static void logrb(final Logger logger,
1501                              final Level level,
1502                              final String bundleName,
1503                              final String key,
1504                              final boolean param1) {
1505         if (logger.isEnabledFor(level)) {
1506             forcedLog(logger, level,
1507                     format(bundleName, key, toArray(valueOf(param1))));
1508         }
1509     }
1510 
1511     /***
1512       * Log a parameterized message using a pattern from a resource bundle.
1513       * @param logger logger, may not be null.
1514       * @param level level, may not be null.
1515       * @param bundleName resource bundle name, may be null.
1516      * @param key key, may be null.
1517      * @param param1 Parameter to the log message.
1518       */
1519     public static void logrb(final Logger logger,
1520                              final Level level,
1521                              final String bundleName,
1522                              final String key,
1523                              final char param1) {
1524         if (logger.isEnabledFor(level)) {
1525             forcedLog(logger, level,
1526                     format(bundleName, key, toArray(valueOf(param1))));
1527         }
1528     }
1529 
1530     /***
1531       * Log a parameterized message using a pattern from a resource bundle.
1532       * @param logger logger, may not be null.
1533       * @param level level, may not be null.
1534       * @param bundleName resource bundle name, may be null.
1535      * @param key key, may be null.
1536      * @param param1 Parameter to the log message.
1537       */
1538     public static void logrb(final Logger logger,
1539                              final Level level,
1540                              final String bundleName,
1541                              final String key,
1542                              final byte param1) {
1543         if (logger.isEnabledFor(level)) {
1544             forcedLog(logger, level,
1545                     format(bundleName, key, toArray(valueOf(param1))));
1546         }
1547     }
1548 
1549     /***
1550       * Log a parameterized message using a pattern from a resource bundle.
1551       * @param logger logger, may not be null.
1552       * @param level level, may not be null.
1553       * @param bundleName resource bundle name, may be null.
1554      * @param key key, may be null.
1555      * @param param1 Parameter to the log message.
1556       */
1557     public static void logrb(final Logger logger,
1558                              final Level level,
1559                              final String bundleName,
1560                              final String key,
1561                              final short param1) {
1562         if (logger.isEnabledFor(level)) {
1563             forcedLog(logger, level,
1564                     format(bundleName, key, toArray(valueOf(param1))));
1565         }
1566     }
1567 
1568     /***
1569       * Log a parameterized message using a pattern from a resource bundle.
1570       * @param logger logger, may not be null.
1571       * @param level level, may not be null.
1572       * @param bundleName resource bundle name, may be null.
1573      * @param key key, may be null.
1574      * @param param1 Parameter to the log message.
1575       */
1576     public static void logrb(final Logger logger,
1577                              final Level level,
1578                              final String bundleName,
1579                              final String key,
1580                              final int param1) {
1581         if (logger.isEnabledFor(level)) {
1582             forcedLog(logger, level,
1583                     format(bundleName, key, toArray(valueOf(param1))));
1584         }
1585     }
1586 
1587     /***
1588       * Log a parameterized message using a pattern from a resource bundle.
1589       * @param logger logger, may not be null.
1590       * @param level level, may not be null.
1591       * @param bundleName resource bundle name, may be null.
1592      * @param key key, may be null.
1593      * @param param1 Parameter to the log message.
1594       */
1595     public static void logrb(final Logger logger,
1596                              final Level level,
1597                              final String bundleName,
1598                              final String key,
1599                              final long param1) {
1600         if (logger.isEnabledFor(level)) {
1601             forcedLog(logger, level,
1602                     format(bundleName, key, toArray(valueOf(param1))));
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 param1 Parameter to the log message.
1612       */
1613     public static void logrb(final Logger logger,
1614                              final Level level,
1615                              final String bundleName,
1616                              final String key,
1617                              final float param1) {
1618         if (logger.isEnabledFor(level)) {
1619             forcedLog(logger, level,
1620                     format(bundleName, key, toArray(valueOf(param1))));
1621         }
1622     }
1623 
1624 
1625     /***
1626       * Log a parameterized message using a pattern from a resource bundle.
1627       * @param logger logger, may not be null.
1628       * @param level level, may not be null.
1629       * @param bundleName resource bundle name, may be null.
1630      * @param key key, may be null.
1631      * @param param1 Parameter to the log message.
1632       */
1633     public static void logrb(final Logger logger,
1634                              final Level level,
1635                              final String bundleName,
1636                              final String key,
1637                              final double param1) {
1638         if (logger.isEnabledFor(level)) {
1639             forcedLog(logger, level,
1640                     format(bundleName, key, toArray(valueOf(param1))));
1641         }
1642     }
1643 
1644     /***
1645       * Log a parameterized message using a pattern from a resource bundle.
1646       * @param logger logger, may not be null.
1647       * @param level level, may not be null.
1648       * @param bundleName resource bundle name, may be null.
1649      * @param key key, may be null.
1650      * @param param0 Parameter to the log message.
1651      * @param param1 Parameter to the log message.
1652       */
1653     public static void logrb(final Logger logger,
1654                              final Level level,
1655                              final String bundleName,
1656                              final String key,
1657                              final Object param0,
1658                              final Object param1) {
1659         if (logger.isEnabledFor(level)) {
1660             forcedLog(logger, level,
1661                     format(bundleName, key, toArray(param0, param1)));
1662         }
1663     }
1664 
1665 
1666     /***
1667       * Log a parameterized message using a pattern from a resource bundle.
1668       * @param logger logger, may not be null.
1669       * @param level level, may not be null.
1670       * @param bundleName resource bundle name, may be null.
1671      * @param key key, may be null.
1672      * @param param0 Parameter to the log message.
1673      * @param param1 Parameter to the log message.
1674      * @param param2 Parameter to the log message.
1675       */
1676     public static void logrb(final Logger logger,
1677                              final Level level,
1678                              final String bundleName,
1679                              final String key,
1680                              final Object param0,
1681                              final Object param1,
1682                              final Object param2) {
1683         if (logger.isEnabledFor(level)) {
1684             forcedLog(logger, level,
1685                     format(bundleName, key, toArray(param0, param1, param2)));
1686         }
1687     }
1688 
1689 
1690     /***
1691       * Log a parameterized message using a pattern from a resource bundle.
1692       * @param logger logger, may not be null.
1693       * @param level level, may not be null.
1694       * @param bundleName resource bundle name, may be null.
1695      * @param key key, may be null.
1696      * @param param0 Parameter to the log message.
1697      * @param param1 Parameter to the log message.
1698      * @param param2 Parameter to the log message.
1699      * @param param3 Parameter to the log message.
1700       */
1701     public static void logrb(final Logger logger,
1702                              final Level level,
1703                              final String bundleName,
1704                              final String key,
1705                              final Object param0,
1706                              final Object param1,
1707                              final Object param2,
1708                              final Object param3) {
1709         if (logger.isEnabledFor(level)) {
1710             forcedLog(logger, level,
1711                     format(bundleName, key,
1712                             toArray(param0, param1, param2, param3)));
1713         }
1714     }
1715 }