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 }