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