Source code

    001/**
    002 * Copyright (c) 2004-2011 QOS.ch
    003 * All rights reserved.
    004 *
    005 * Permission is hereby granted, free  of charge, to any person obtaining
    006 * a  copy  of this  software  and  associated  documentation files  (the
    007 * "Software"), to  deal in  the Software without  restriction, including
    008 * without limitation  the rights to  use, copy, modify,  merge, publish,
    009 * distribute,  sublicense, and/or sell  copies of  the Software,  and to
    010 * permit persons to whom the Software  is furnished to do so, subject to
    011 * the following conditions:
    012 *
    013 * The  above  copyright  notice  and  this permission  notice  shall  be
    014 * included in all copies or substantial portions of the Software.
    015 *
    016 * THE  SOFTWARE IS  PROVIDED  "AS  IS", WITHOUT  WARRANTY  OF ANY  KIND,
    017 * EXPRESS OR  IMPLIED, INCLUDING  BUT NOT LIMITED  TO THE  WARRANTIES OF
    018 * MERCHANTABILITY,    FITNESS    FOR    A   PARTICULAR    PURPOSE    AND
    019 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
    020 * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
    021 * OF CONTRACT, TORT OR OTHERWISE,  ARISING FROM, OUT OF OR IN CONNECTION
    022 * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
    023 *
    024 */
    025
    026package org.slf4j.impl;
    027
    028import org.apache.commons.logging.Log;
    029import org.slf4j.Logger;
    030import org.slf4j.helpers.FormattingTuple;
    031import org.slf4j.helpers.MarkerIgnoringBase;
    032import org.slf4j.helpers.MessageFormatter;
    033
    034/**
    035 * A wrapper over {@link org.apache.commons.logging.Log
    036 * org.apache.commons.logging.Log} in conformance with the {@link Logger}
    037 * interface.
    038 *
    039 * @author Ceki G&uuml;lc&uuml;
    040 */
    041public final class JCLLoggerAdapter extends MarkerIgnoringBase {
    042
    043    private static final long serialVersionUID = 4141593417490482209L;
    044    final Log log;
    045
    046    // WARN: JCLLoggerAdapter constructor should have only package access so
    047    // that only JCLLoggerFactory be able to create one.
    048    JCLLoggerAdapter(Log log, String name) {
    049        this.log = log;
    050        this.name = name;
    051    }
    052
    053    /**
    054     * Delegates to the {@link Log#isTraceEnabled} method of the underlying
    055     * {@link Log} instance.
    056     */
    057    public boolean isTraceEnabled() {
    058        return log.isTraceEnabled();
    059    }
    060
    061    //
    062
    063    /**
    064     * Delegates to the {@link Log#trace(java.lang.Object)} method of the underlying
    065     * {@link Log} instance.
    066     *
    067     * @param msg - the message object to be logged
    068     */
    069    public void trace(String msg) {
    070        log.trace(msg);
    071    }
    072
    073    /**
    074     * Delegates to the {@link Log#trace(java.lang.Object)} method of the underlying
    075     * {@link Log} instance.
    076     *
    077     * <p>
    078     * However, this form avoids superfluous object creation when the logger is disabled
    079     * for level TRACE.
    080     * </p>
    081     *
    082     * @param format
    083     *          the format string
    084     * @param arg
    085     *          the argument
    086     */
    087    public void trace(String format, Object arg) {
    088        if (log.isTraceEnabled()) {
    089            FormattingTuple ft = MessageFormatter.format(format, arg);
    090            log.trace(ft.getMessage(), ft.getThrowable());
    091        }
    092    }
    093
    094    /**
    095     * Delegates to the {@link Log#trace(java.lang.Object)} method of the underlying
    096     * {@link Log} instance.
    097     *
    098     * <p>
    099     * 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}