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.isDebugEnabled()) {
    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.isDebugEnabled()) {
    112       FormattingTuple ft = MessageFormatter.format(format, arg1, arg2);
    113       log.trace(ft.getMessage(), ft.getThrowable());
    114     }
    115   }
    116
    117
    118   /**
    119    * Delegates to the {@link Log#trace(java.lang.Object)} method of the underlying
    120    * {@link Log} instance.
    121    *
    122    * <p>
    123    * However, this form avoids superfluous object creation when the logger is disabled
    124    * for level TRACE.
    125    * </p>
    126    *
    127    * @param format the format string
    128    * @param arguments a list of 3 or more arguments
    129    */
    130   public void trace(String format, Object... arguments) {
    131     if (log.isDebugEnabled()) {
    132       FormattingTuple ft = MessageFormatter.arrayFormat(format, arguments);
    133       log.trace(ft.getMessage(), ft.getThrowable());
    134     }
    135   }
    136
    137   /**
    138    * Delegates to the {@link Log#trace(java.lang.Object, java.lang.Throwable)} method of
    139    * the underlying {@link Log} instance.
    140    *
    141    * @param msg
    142    *          the message accompanying the exception
    143    * @param t
    144    *          the exception (throwable) to log
    145    */
    146   public void trace(String msg, Throwable t) {
    147       log.trace(msg, t);
    148   }
    149
    150
    151   /**
    152    * Delegates to the {@link Log#isDebugEnabled} method of the underlying
    153    * {@link Log} instance.
    154    */
    155   public boolean isDebugEnabled() {
    156     return log.isDebugEnabled();
    157   }
    158
    159   //
    160
    161   /**
    162    * Delegates to the {@link Log#debug(java.lang.Object)} method of the underlying
    163    * {@link Log} instance.
    164    *
    165    * @param msg - the message object to be logged
    166    */
    167   public void debug(String msg) {
    168     log.debug(msg);
    169   }
    170
    171   /**
    172    * Delegates to the {@link Log#debug(java.lang.Object)} method of the underlying
    173    * {@link Log} instance.
    174    *
    175    * <p>
    176    * However, this form avoids superfluous object creation when the logger is disabled
    177    * for level DEBUG.
    178    * </p>
    179    *
    180    * @param format
    181    *          the format string
    182    * @param arg
    183    *          the argument
    184    */
    185   public void debug(String format, Object arg) {
    186     if (log.isDebugEnabled()) {
    187       FormattingTuple ft = MessageFormatter.format(format, arg);
    188       log.debug(ft.getMessage(), ft.getThrowable());
    189     }
    190   }
    191
    192   /**
    193    * Delegates to the {@link Log#debug(java.lang.Object)} method of the underlying
    194    * {@link Log} instance.
    195    *
    196    * <p>
    197    * However, this form avoids superfluous object creation when the logger is disabled
    198    * for level DEBUG.
    199    * </p>
    200    *
    201    * @param format
    202    *          the format string
    203    * @param arg1
    204    *          the first argument
    205    * @param arg2
    206    *          the second argument
    207    */
    208   public void debug(String format, Object arg1, Object arg2) {
    209     if (log.isDebugEnabled()) {
    210       FormattingTuple ft = MessageFormatter.format(format, arg1, arg2);
    211       log.debug(ft.getMessage(), ft.getThrowable());
    212     }
    213   }
    214
    215
    216   /**
    217    * Delegates to the {@link Log#debug(java.lang.Object)} method of the underlying
    218    * {@link Log} instance.
    219    *
    220    * <p>
    221    * However, this form avoids superfluous object creation when the logger is disabled
    222    * for level DEBUG.
    223    * </p>
    224    *
    225    * @param format the format string
    226    * @param arguments a list of 3 or more arguments
    227    */
    228   public void debug(String format, Object... arguments) {
    229     if (log.isDebugEnabled()) {
    230       FormattingTuple ft = MessageFormatter.arrayFormat(format, arguments);
    231       log.debug(ft.getMessage(), ft.getThrowable());
    232     }
    233   }
    234
    235   /**
    236    * Delegates to the {@link Log#debug(java.lang.Object, java.lang.Throwable)} method of
    237    * the underlying {@link Log} instance.
    238    *
    239    * @param msg
    240    *          the message accompanying the exception
    241    * @param t
    242    *          the exception (throwable) to log
    243    */
    244   public void debug(String msg, Throwable t) {
    245       log.debug(msg, t);
    246   }
    247
    248   /**
    249    * Delegates to the {@link Log#isInfoEnabled} method of the underlying
    250    * {@link Log} instance.
    251    */
    252   public boolean isInfoEnabled() {
    253     return log.isInfoEnabled();
    254   }
    255
    256   /**
    257    * Delegates to the {@link Log#debug(java.lang.Object)} method of the underlying
    258    * {@link Log} instance.
    259    *
    260    * @param msg - the message object to be logged
    261    */
    262   public void info(String msg) {
    263     log.info(msg);
    264   }
    265
    266   /**
    267    * Delegates to the {@link Log#info(java.lang.Object)} method of the underlying
    268    * {@link Log} instance.
    269    *
    270    * <p>
    271    * However, this form avoids superfluous object creation when the logger is disabled
    272    * for level INFO.
    273    * </p>
    274    *
    275    * @param format
    276    *          the format string
    277    * @param arg
    278    *          the argument
    279    */
    280
    281   public void info(String format, Object arg) {
    282     if (log.isInfoEnabled()) {
    283       FormattingTuple ft = MessageFormatter.format(format, arg);
    284       log.info(ft.getMessage(), ft.getThrowable());
    285     }
    286   }
    287   /**
    288    * Delegates to the {@link Log#info(java.lang.Object)} method of the underlying
    289    * {@link Log} instance.
    290    *
    291    * <p>
    292    * However, this form avoids superfluous object creation when the logger is disabled
    293    * for level INFO.
    294    * </p>
    295    *
    296    * @param format
    297    *          the format string
    298    * @param arg1
    299    *          the first argument
    300    * @param arg2
    301    *          the second argument
    302    */
    303   public void info(String format, Object arg1, Object arg2) {
    304     if (log.isInfoEnabled()) {
    305
    306       FormattingTuple ft = MessageFormatter.format(format, arg1, arg2);
    307       log.info(ft.getMessage(), ft.getThrowable());
    308     }
    309   }
    310
    311   /**
    312    * Delegates to the {@link Log#info(java.lang.Object)} method of the underlying
    313    * {@link Log} instance.
    314    *
    315    * <p>
    316    * However, this form avoids superfluous object creation when the logger is disabled
    317    * for level INFO.
    318    * </p>
    319    *
    320    * @param format the format string
    321    * @param arguments a list of 3 or more arguments
    322    */
    323   public void info(String format, Object... arguments) {
    324     if (log.isInfoEnabled()) {
    325       FormattingTuple ft = MessageFormatter.arrayFormat(format, arguments);
    326       log.info(ft.getMessage(), ft.getThrowable());
    327     }
    328   }
    329
    330
    331   /**
    332    * Delegates to the {@link Log#info(java.lang.Object, java.lang.Throwable)} method of
    333    * the underlying {@link Log} instance.
    334    *
    335    * @param msg
    336    *          the message accompanying the exception
    337    * @param t
    338    *          the exception (throwable) to log
    339    */
    340   public void info(String msg, Throwable t) {
    341     log.info(msg, t);
    342   }
    343
    344   /**
    345    * Delegates to the {@link Log#isWarnEnabled} method of the underlying
    346    * {@link Log} instance.
    347    */
    348   public boolean isWarnEnabled() {
    349     return log.isWarnEnabled();
    350   }
    351
    352   /**
    353    * Delegates to the {@link Log#warn(java.lang.Object)} method of the underlying
    354    * {@link Log} instance.
    355    *
    356    * @param msg - the message object to be logged
    357    */
    358   public void warn(String msg) {
    359     log.warn(msg);
    360   }
    361
    362   /**
    363    * Delegates to the {@link Log#warn(java.lang.Object)} method of the underlying
    364    * {@link Log} instance.
    365    *
    366    * <p>
    367    * However, this form avoids superfluous object creation when the logger is disabled
    368    * for level WARN.
    369    * </p>
    370    *
    371    * @param format
    372    *          the format string
    373    * @param arg
    374    *          the argument
    375    */
    376   public void warn(String format, Object arg) {
    377     if (log.isWarnEnabled()) {
    378       FormattingTuple ft = MessageFormatter.format(format, arg);
    379       log.warn(ft.getMessage(), ft.getThrowable());
    380     }
    381   }
    382
    383   /**
    384    * Delegates to the {@link Log#warn(java.lang.Object)} method of the underlying
    385    * {@link Log} instance.
    386    *
    387    * <p>
    388    * However, this form avoids superfluous object creation when the logger is disabled
    389    * for level WARN.
    390    * </p>
    391    *
    392    * @param format
    393    *          the format string
    394    * @param arg1
    395    *          the first argument
    396    * @param arg2
    397    *          the second argument
    398    */
    399   public void warn(String format, Object arg1, Object arg2) {
    400     if (log.isWarnEnabled()) {
    401       FormattingTuple ft = MessageFormatter.format(format, arg1, arg2);
    402       log.warn(ft.getMessage(), ft.getThrowable());
    403     }
    404   }
    405
    406   /**
    407    * Delegates to the {@link Log#warn(java.lang.Object)} method of the underlying
    408    * {@link Log} instance.
    409    *
    410    * <p>
    411    * However, this form avoids superfluous object creation when the logger is disabled
    412    * for level WARN.
    413    * </p>
    414    *
    415    * @param format the format string
    416    * @param arguments a list of 3 or more arguments
    417    */
    418   public void warn(String format, Object... arguments) {
    419     if (log.isWarnEnabled()) {
    420       FormattingTuple ft = MessageFormatter.arrayFormat(format, arguments);
    421       log.warn(ft.getMessage(), ft.getThrowable());
    422     }
    423   }
    424
    425
    426   /**
    427    * Delegates to the {@link Log#warn(java.lang.Object, java.lang.Throwable)} method of
    428    * the underlying {@link Log} instance.
    429    *
    430    * @param msg
    431    *          the message accompanying the exception
    432    * @param t
    433    *          the exception (throwable) to log
    434    */
    435
    436   public void warn(String msg, Throwable t) {
    437     log.warn(msg, t);
    438   }
    439
    440
    441   /**
    442    * Delegates to the {@link Log#isErrorEnabled} method of the underlying
    443    * {@link Log} instance.
    444    */
    445   public boolean isErrorEnabled() {
    446     return log.isErrorEnabled();
    447   }
    448
    449   /**
    450    * Delegates to the {@link Log#error(java.lang.Object)} method of the underlying
    451    * {@link Log} instance.
    452    *
    453    * @param msg - the message object to be logged
    454    */
    455   public void error(String msg) {
    456     log.error(msg);
    457   }
    458
    459   /**
    460    * Delegates to the {@link Log#error(java.lang.Object)} method of the underlying
    461    * {@link Log} instance.
    462    *
    463    * <p>
    464    * However, this form avoids superfluous object creation when the logger is disabled
    465    * for level ERROR.
    466    * </p>
    467    *
    468    * @param format
    469    *          the format string
    470    * @param arg
    471    *          the argument
    472    */
    473   public void error(String format, Object arg) {
    474     if (log.isErrorEnabled()) {
    475       FormattingTuple ft = MessageFormatter.format(format, arg);
    476       log.error(ft.getMessage(), ft.getThrowable());
    477     }
    478   }
    479
    480   /**
    481    * Delegates to the {@link Log#error(java.lang.Object)} method of the underlying
    482    * {@link Log} instance.
    483    *
    484    * <p>
    485    * However, this form avoids superfluous object creation when the logger is disabled
    486    * for level ERROR.
    487    * </p>
    488    *
    489    * @param format
    490    *          the format string
    491    * @param arg1
    492    *          the first argument
    493    * @param arg2
    494    *          the second argument
    495    */
    496   public void error(String format, Object arg1, Object arg2) {
    497     if (log.isErrorEnabled()) {
    498       FormattingTuple ft = MessageFormatter.format(format, arg1, arg2);
    499       log.error(ft.getMessage(), ft.getThrowable());
    500     }
    501   }
    502
    503   /**
    504    * Delegates to the {@link Log#error(java.lang.Object)} method of the underlying
    505    * {@link Log} instance.
    506    *
    507    * <p>
    508    * However, this form avoids superfluous object creation when the logger is disabled
    509    * for level ERROR.
    510    * </p>
    511    *
    512    * @param format the format string
    513    * @param arguments a list of 3 or more arguments
    514    */
    515   public void error(String format, Object... arguments) {
    516     if (log.isErrorEnabled()) {
    517       FormattingTuple ft = MessageFormatter.arrayFormat(format, arguments);
    518       log.error(ft.getMessage(), ft.getThrowable());
    519     }
    520   }
    521
    522
    523   /**
    524    * Delegates to the {@link Log#error(java.lang.Object, java.lang.Throwable)} method of
    525    * the underlying {@link Log} instance.
    526    *
    527    * @param msg
    528    *          the message accompanying the exception
    529    * @param t
    530    *          the exception (throwable) to log
    531    */
    532
    533   public void error(String msg, Throwable t) {
    534     log.error(msg, t);
    535   }
    536
    537 }