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
26package org.slf4j.impl;
27
28import org.apache.commons.logging.Log;
29import org.slf4j.Logger;
30import org.slf4j.helpers.FormattingTuple;
31import org.slf4j.helpers.MarkerIgnoringBase;
32import 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ülcü
40 */
41public 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}
532