JCLLoggerAdapter xref

View Javadoc

    1   /**
    2    * Copyright (c) 2004-2011 QOS.ch
    3    * All rights reserved.
    4    *
    5    * Permission is hereby granted, free  of charge, to any person obtaining
    6    * a  copy  of this  software  and  associated  documentation files  (the
    7    * "Software"), to  deal in  the Software without  restriction, including
    8    * without limitation  the rights to  use, copy, modify,  merge, publish,
    9    * distribute,  sublicense, and/or sell  copies of  the Software,  and to
    10   * permit persons to whom the Software  is furnished to do so, subject to
    11   * the following conditions:
    12   *
    13   * The  above  copyright  notice  and  this permission  notice  shall  be
    14   * included in all copies or substantial portions of the Software.
    15   *
    16   * THE  SOFTWARE IS  PROVIDED  "AS  IS", WITHOUT  WARRANTY  OF ANY  KIND,
    17   * EXPRESS OR  IMPLIED, INCLUDING  BUT NOT LIMITED  TO THE  WARRANTIES OF
    18   * MERCHANTABILITY,    FITNESS    FOR    A   PARTICULAR    PURPOSE    AND
    19   * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
    20   * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
    21   * OF CONTRACT, TORT OR OTHERWISE,  ARISING FROM, OUT OF OR IN CONNECTION
    22   * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
    23   *
    24   */
    25
    26  package org.slf4j.impl;
    27
    28  import org.apache.commons.logging.Log;
    29  import org.slf4j.Logger;
    30  import org.slf4j.helpers.FormattingTuple;
    31  import org.slf4j.helpers.MarkerIgnoringBase;
    32  import org.slf4j.helpers.MessageFormatter;
    33
    34  /**
    35   * A wrapper over {@link org.apache.commons.logging.Log
    36   * org.apache.commons.logging.Log} in conformance with the {@link Logger}
    37   * interface.
    38   *
    39   * @author Ceki G&uuml;lc&uuml;
    40   */
    41  public final class JCLLoggerAdapter extends MarkerIgnoringBase {
    42
    43      private static final long serialVersionUID = 4141593417490482209L;
    44      final Log log;
    45
    46      // WARN: JCLLoggerAdapter constructor should have only package access so
    47      // that only JCLLoggerFactory be able to create one.
    48      JCLLoggerAdapter(Log log, String name) {
    49          this.log = log;
    50          this.name = name;
    51      }
    52
    53      /**
    54       * Delegates to the {@link Log#isTraceEnabled} method of the underlying
    55       * {@link Log} instance.
    56       */
    57      public boolean isTraceEnabled() {
    58          return log.isTraceEnabled();
    59      }
    60
    61      //
    62
    63      /**
    64       * Delegates to the {@link Log#trace(java.lang.Object)} method of the underlying
    65       * {@link Log} instance.
    66       *
    67       * @param msg - the message object to be logged
    68       */
    69      public void trace(String msg) {
    70          log.trace(msg);
    71      }
    72
    73      /**
    74       * Delegates to the {@link Log#trace(java.lang.Object)} method of the underlying
    75       * {@link Log} instance.
    76       *
    77       * <p>
    78       * However, this form avoids superfluous object creation when the logger is disabled
    79       * for level TRACE.
    80       * </p>
    81       *
    82       * @param format
    83       *          the format string
    84       * @param arg
    85       *          the argument
    86       */
    87      public void trace(String format, Object arg) {
    88          if (log.isTraceEnabled()) {
    89              FormattingTuple ft = MessageFormatter.format(format, arg);
    90              log.trace(ft.getMessage(), ft.getThrowable());
    91          }
    92      }
    93
    94      /**
    95       * Delegates to the {@link Log#trace(java.lang.Object)} method of the underlying
    96       * {@link Log} instance.
    97       *
    98       * <p>
    99       * However, this form avoids superfluous object creation when the logger is disabled
    100      * for level TRACE.
    101      * </p>
    102      *
    103      * @param format
    104      *          the format string
    105      * @param arg1
    106      *          the first argument
    107      * @param arg2
    108      *          the second argument
    109      */
    110     public void trace(String format, Object arg1, Object arg2) {
    111         if (log.isTraceEnabled()) {
    112             FormattingTuple ft = MessageFormatter.format(format, arg1, arg2);
    113             log.trace(ft.getMessage(), ft.getThrowable());
    114         }
    115     }
    116
    117     /**
    118      * Delegates to the {@link Log#trace(java.lang.Object)} method of the underlying
    119      * {@link Log} instance.
    120      *
    121      * <p>
    122      * However, this form avoids superfluous object creation when the logger is disabled
    123      * for level TRACE.
    124      * </p>
    125      *
    126      * @param format the format string
    127      * @param arguments a list of 3 or more arguments
    128      */
    129     public void trace(String format, Object... arguments) {
    130         if (log.isTraceEnabled()) {
    131             FormattingTuple ft = MessageFormatter.arrayFormat(format, arguments);
    132             log.trace(ft.getMessage(), ft.getThrowable());
    133         }
    134     }
    135
    136     /**
    137      * Delegates to the {@link Log#trace(java.lang.Object, java.lang.Throwable)} method of
    138      * the underlying {@link Log} instance.
    139      *
    140      * @param msg
    141      *          the message accompanying the exception
    142      * @param t
    143      *          the exception (throwable) to log
    144      */
    145     public void trace(String msg, Throwable t) {
    146         log.trace(msg, t);
    147     }
    148
    149     /**
    150      * Delegates to the {@link Log#isDebugEnabled} method of the underlying
    151      * {@link Log} instance.
    152      */
    153     public boolean isDebugEnabled() {
    154         return log.isDebugEnabled();
    155     }
    156
    157     //
    158
    159     /**
    160      * Delegates to the {@link Log#debug(java.lang.Object)} method of the underlying
    161      * {@link Log} instance.
    162      *
    163      * @param msg - the message object to be logged
    164      */
    165     public void debug(String msg) {
    166         log.debug(msg);
    167     }
    168
    169     /**
    170      * Delegates to the {@link Log#debug(java.lang.Object)} method of the underlying
    171      * {@link Log} instance.
    172      *
    173      * <p>
    174      * However, this form avoids superfluous object creation when the logger is disabled
    175      * for level DEBUG.
    176      * </p>
    177      *
    178      * @param format
    179      *          the format string
    180      * @param arg
    181      *          the argument
    182      */
    183     public void debug(String format, Object arg) {
    184         if (log.isDebugEnabled()) {
    185             FormattingTuple ft = MessageFormatter.format(format, arg);
    186             log.debug(ft.getMessage(), ft.getThrowable());
    187         }
    188     }
    189
    190     /**
    191      * Delegates to the {@link Log#debug(java.lang.Object)} method of the underlying
    192      * {@link Log} instance.
    193      *
    194      * <p>
    195      * However, this form avoids superfluous object creation when the logger is disabled
    196      * for level DEBUG.
    197      * </p>
    198      *
    199      * @param format
    200      *          the format string
    201      * @param arg1
    202      *          the first argument
    203      * @param arg2
    204      *          the second argument
    205      */
    206     public void debug(String format, Object arg1, Object arg2) {
    207         if (log.isDebugEnabled()) {
    208             FormattingTuple ft = MessageFormatter.format(format, arg1, arg2);
    209             log.debug(ft.getMessage(), ft.getThrowable());
    210         }
    211     }
    212
    213     /**
    214      * Delegates to the {@link Log#debug(java.lang.Object)} method of the underlying
    215      * {@link Log} instance.
    216      *
    217      * <p>
    218      * However, this form avoids superfluous object creation when the logger is disabled
    219      * for level DEBUG.
    220      * </p>
    221      *
    222      * @param format the format string
    223      * @param arguments a list of 3 or more arguments
    224      */
    225     public void debug(String format, Object... arguments) {
    226         if (log.isDebugEnabled()) {
    227             FormattingTuple ft = MessageFormatter.arrayFormat(format, arguments);
    228             log.debug(ft.getMessage(), ft.getThrowable());
    229         }
    230     }
    231
    232     /**
    233      * Delegates to the {@link Log#debug(java.lang.Object, java.lang.Throwable)} method of
    234      * the underlying {@link Log} instance.
    235      *
    236      * @param msg
    237      *          the message accompanying the exception
    238      * @param t
    239      *          the exception (throwable) to log
    240      */
    241     public void debug(String msg, Throwable t) {
    242         log.debug(msg, t);
    243     }
    244
    245     /**
    246      * Delegates to the {@link Log#isInfoEnabled} method of the underlying
    247      * {@link Log} instance.
    248      */
    249     public boolean isInfoEnabled() {
    250         return log.isInfoEnabled();
    251     }
    252
    253     /**
    254      * Delegates to the {@link Log#debug(java.lang.Object)} method of the underlying
    255      * {@link Log} instance.
    256      *
    257      * @param msg - the message object to be logged
    258      */
    259     public void info(String msg) {
    260         log.info(msg);
    261     }
    262
    263     /**
    264      * Delegates to the {@link Log#info(java.lang.Object)} method of the underlying
    265      * {@link Log} instance.
    266      *
    267      * <p>
    268      * However, this form avoids superfluous object creation when the logger is disabled
    269      * for level INFO.
    270      * </p>
    271      *
    272      * @param format
    273      *          the format string
    274      * @param arg
    275      *          the argument
    276      */
    277
    278     public void info(String format, Object arg) {
    279         if (log.isInfoEnabled()) {
    280             FormattingTuple ft = MessageFormatter.format(format, arg);
    281             log.info(ft.getMessage(), ft.getThrowable());
    282         }
    283     }
    284
    285     /**
    286      * Delegates to the {@link Log#info(java.lang.Object)} method of the underlying
    287      * {@link Log} instance.
    288      *
    289      * <p>
    290      * However, this form avoids superfluous object creation when the logger is disabled
    291      * for level INFO.
    292      * </p>
    293      *
    294      * @param format
    295      *          the format string
    296      * @param arg1
    297      *          the first argument
    298      * @param arg2
    299      *          the second argument
    300      */
    301     public void info(String format, Object arg1, Object arg2) {
    302         if (log.isInfoEnabled()) {
    303
    304             FormattingTuple ft = MessageFormatter.format(format, arg1, arg2);
    305             log.info(ft.getMessage(), ft.getThrowable());
    306         }
    307     }
    308
    309     /**
    310      * Delegates to the {@link Log#info(java.lang.Object)} method of the underlying
    311      * {@link Log} instance.
    312      *
    313      * <p>
    314      * However, this form avoids superfluous object creation when the logger is disabled
    315      * for level INFO.
    316      * </p>
    317      *
    318      * @param format the format string
    319      * @param arguments a list of 3 or more arguments
    320      */
    321     public void info(String format, Object... arguments) {
    322         if (log.isInfoEnabled()) {
    323             FormattingTuple ft = MessageFormatter.arrayFormat(format, arguments);
    324             log.info(ft.getMessage(), ft.getThrowable());
    325         }
    326     }
    327
    328     /**
    329      * Delegates to the {@link Log#info(java.lang.Object, java.lang.Throwable)} method of
    330      * the underlying {@link Log} instance.
    331      *
    332      * @param msg
    333      *          the message accompanying the exception
    334      * @param t
    335      *          the exception (throwable) to log
    336      */
    337     public void info(String msg, Throwable t) {
    338         log.info(msg, t);
    339     }
    340
    341     /**
    342      * Delegates to the {@link Log#isWarnEnabled} method of the underlying
    343      * {@link Log} instance.
    344      */
    345     public boolean isWarnEnabled() {
    346         return log.isWarnEnabled();
    347     }
    348
    349     /**
    350      * Delegates to the {@link Log#warn(java.lang.Object)} method of the underlying
    351      * {@link Log} instance.
    352      *
    353      * @param msg - the message object to be logged
    354      */
    355     public void warn(String msg) {
    356         log.warn(msg);
    357     }
    358
    359     /**
    360      * Delegates to the {@link Log#warn(java.lang.Object)} method of the underlying
    361      * {@link Log} instance.
    362      *
    363      * <p>
    364      * However, this form avoids superfluous object creation when the logger is disabled
    365      * for level WARN.
    366      * </p>
    367      *
    368      * @param format
    369      *          the format string
    370      * @param arg
    371      *          the argument
    372      */
    373     public void warn(String format, Object arg) {
    374         if (log.isWarnEnabled()) {
    375             FormattingTuple ft = MessageFormatter.format(format, arg);
    376             log.warn(ft.getMessage(), ft.getThrowable());
    377         }
    378     }
    379
    380     /**
    381      * Delegates to the {@link Log#warn(java.lang.Object)} method of the underlying
    382      * {@link Log} instance.
    383      *
    384      * <p>
    385      * However, this form avoids superfluous object creation when the logger is disabled
    386      * for level WARN.
    387      * </p>
    388      *
    389      * @param format
    390      *          the format string
    391      * @param arg1
    392      *          the first argument
    393      * @param arg2
    394      *          the second argument
    395      */
    396     public void warn(String format, Object arg1, Object arg2) {
    397         if (log.isWarnEnabled()) {
    398             FormattingTuple ft = MessageFormatter.format(format, arg1, arg2);
    399             log.warn(ft.getMessage(), ft.getThrowable());
    400         }
    401     }
    402
    403     /**
    404      * Delegates to the {@link Log#warn(java.lang.Object)} method of the underlying
    405      * {@link Log} instance.
    406      *
    407      * <p>
    408      * However, this form avoids superfluous object creation when the logger is disabled
    409      * for level WARN.
    410      * </p>
    411      *
    412      * @param format the format string
    413      * @param arguments a list of 3 or more arguments
    414      */
    415     public void warn(String format, Object... arguments) {
    416         if (log.isWarnEnabled()) {
    417             FormattingTuple ft = MessageFormatter.arrayFormat(format, arguments);
    418             log.warn(ft.getMessage(), ft.getThrowable());
    419         }
    420     }
    421
    422     /**
    423      * Delegates to the {@link Log#warn(java.lang.Object, java.lang.Throwable)} method of
    424      * the underlying {@link Log} instance.
    425      *
    426      * @param msg
    427      *          the message accompanying the exception
    428      * @param t
    429      *          the exception (throwable) to log
    430      */
    431
    432     public void warn(String msg, Throwable t) {
    433         log.warn(msg, t);
    434     }
    435
    436     /**
    437      * Delegates to the {@link Log#isErrorEnabled} method of the underlying
    438      * {@link Log} instance.
    439      */
    440     public boolean isErrorEnabled() {
    441         return log.isErrorEnabled();
    442     }
    443
    444     /**
    445      * Delegates to the {@link Log#error(java.lang.Object)} method of the underlying
    446      * {@link Log} instance.
    447      *
    448      * @param msg - the message object to be logged
    449      */
    450     public void error(String msg) {
    451         log.error(msg);
    452     }
    453
    454     /**
    455      * Delegates to the {@link Log#error(java.lang.Object)} method of the underlying
    456      * {@link Log} instance.
    457      *
    458      * <p>
    459      * However, this form avoids superfluous object creation when the logger is disabled
    460      * for level ERROR.
    461      * </p>
    462      *
    463      * @param format
    464      *          the format string
    465      * @param arg
    466      *          the argument
    467      */
    468     public void error(String format, Object arg) {
    469         if (log.isErrorEnabled()) {
    470             FormattingTuple ft = MessageFormatter.format(format, arg);
    471             log.error(ft.getMessage(), ft.getThrowable());
    472         }
    473     }
    474
    475     /**
    476      * Delegates to the {@link Log#error(java.lang.Object)} method of the underlying
    477      * {@link Log} instance.
    478      *
    479      * <p>
    480      * However, this form avoids superfluous object creation when the logger is disabled
    481      * for level ERROR.
    482      * </p>
    483      *
    484      * @param format
    485      *          the format string
    486      * @param arg1
    487      *          the first argument
    488      * @param arg2
    489      *          the second argument
    490      */
    491     public void error(String format, Object arg1, Object arg2) {
    492         if (log.isErrorEnabled()) {
    493             FormattingTuple ft = MessageFormatter.format(format, arg1, arg2);
    494             log.error(ft.getMessage(), ft.getThrowable());
    495         }
    496     }
    497
    498     /**
    499      * Delegates to the {@link Log#error(java.lang.Object)} method of the underlying
    500      * {@link Log} instance.
    501      *
    502      * <p>
    503      * However, this form avoids superfluous object creation when the logger is disabled
    504      * for level ERROR.
    505      * </p>
    506      *
    507      * @param format the format string
    508      * @param arguments a list of 3 or more arguments
    509      */
    510     public void error(String format, Object... arguments) {
    511         if (log.isErrorEnabled()) {
    512             FormattingTuple ft = MessageFormatter.arrayFormat(format, arguments);
    513             log.error(ft.getMessage(), ft.getThrowable());
    514         }
    515     }
    516
    517     /**
    518      * Delegates to the {@link Log#error(java.lang.Object, java.lang.Throwable)} method of
    519      * the underlying {@link Log} instance.
    520      *
    521      * @param msg
    522      *          the message accompanying the exception
    523      * @param t
    524      *          the exception (throwable) to log
    525      */
    526
    527     public void error(String msg, Throwable t) {
    528         log.error(msg, t);
    529     }
    530
    531 }