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ülcü
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   /**
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.isTraceEnabled()) {
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 }