LogSF xref

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