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  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 }