git.gag.com Git - debian/openrocket/blob - src/net/sf/openrocket/logging/LogHelper.java

   1 package net.sf.openrocket.logging;
   2
   3 import net.sf.openrocket.util.BugException;
   4
   5
   6 /**
   7  * Base class for all loggers used in OpenRocket.
   8  * <p>
   9  * This class contains methods for logging at various log levels, and methods
  10  * which take the logging level as a parameter.  All methods may take three types
  11  * of parameters:
  12  * <ul>
  13  *      <li><code>levels</code>         number of additional levels of the stack trace to print
  14  *                                                              on the log line.  This is useful to determine from where
  15  *                                                              the current method has been called.  Zero if not provided.
  16  *  <li><code>message</code>    the String message (may be null).
  17  *  <li><code>cause</code>              the exception that caused this log (may be null).
  18  * </ul>
  19  *
  20  * @author Sampo Niskanen <sampo.niskanen@iki.fi>
  21  */
  22 public abstract class LogHelper {
  23         /**
  24          * Level from which upward a TraceException is added to the log lines.
  25          */
  26         private static final LogLevel TRACING_LOG_LEVEL =
  27                         LogLevel.fromString(System.getProperty("openrocket.log.tracelevel"), LogLevel.INFO);
  28
  29         private static final DelegatorLogger delegator = new DelegatorLogger();
  30
  31
  32
  33         /**
  34          * Get the logger to be used in logging.
  35          *
  36          * @return      the logger to be used in all logging.
  37          */
  38         public static LogHelper getInstance() {
  39                 return delegator;
  40         }
  41
  42
  43
  44         /**
  45          * Log a LogLine object.  This method needs to be able to cope with multiple threads
  46          * accessing it concurrently (for example by being synchronized).
  47          *
  48          * @param line  the LogLine to log.
  49          */
  50         public abstract void log(LogLine line);
  51
  52
  53         /**
  54          * Log using VBOSE level.
  55          *
  56          * @param message       the logged message (may be null).
  57          */
  58         public void verbose(String message) {
  59                 log(createLogLine(0, LogLevel.VBOSE, message, null));
  60         }
  61
  62         /**
  63          * Log using VBOSE level.
  64          *
  65          * @param message       the logged message (may be null).
  66          * @param cause         the causing exception (may be null).
  67          */
  68         public void verbose(String message, Throwable cause) {
  69                 log(createLogLine(0, LogLevel.VBOSE, message, cause));
  70         }
  71
  72         /**
  73          * Log using VBOSE level.
  74          *
  75          * @param levels        number of additional levels of stack trace to include.
  76          * @param message       the logged message (may be null).
  77          */
  78         public void verbose(int levels, String message) {
  79                 log(createLogLine(levels, LogLevel.VBOSE, message, null));
  80         }
  81
  82         /**
  83          * Log using VBOSE level.
  84          *
  85          * @param levels        number of additional levels of stack trace to include.
  86          * @param message       the logged message (may be null).
  87          * @param cause         the causing exception (may be null).
  88          */
  89         public void verbose(int levels, String message, Throwable cause) {
  90                 log(createLogLine(levels, LogLevel.VBOSE, message, cause));
  91         }
  92
  93
  94         /**
  95          * Log using DEBUG level.
  96          *
  97          * @param message       the logged message (may be null).
  98          */
  99         public void debug(String message) {
 100                 log(createLogLine(0, LogLevel.DEBUG, message, null));
 101         }
 102
 103         /**
 104          * Log using DEBUG level.
 105          *
 106          * @param message       the logged message (may be null).
 107          * @param cause         the causing exception (may be null).
 108          */
 109         public void debug(String message, Throwable cause) {
 110                 log(createLogLine(0, LogLevel.DEBUG, message, cause));
 111         }
 112
 113         /**
 114          * Log using DEBUG level.
 115          *
 116          * @param levels        number of additional levels of stack trace to include.
 117          * @param message       the logged message (may be null).
 118          */
 119         public void debug(int levels, String message) {
 120                 log(createLogLine(levels, LogLevel.DEBUG, message, null));
 121         }
 122
 123         /**
 124          * Log using DEBUG level.
 125          *
 126          * @param levels        number of additional levels of stack trace to include.
 127          * @param message       the logged message (may be null).
 128          * @param cause         the causing exception (may be null).
 129          */
 130         public void debug(int levels, String message, Throwable cause) {
 131                 log(createLogLine(levels, LogLevel.DEBUG, message, cause));
 132         }
 133
 134
 135         /**
 136          * Log using INFO level.
 137          *
 138          * @param message       the logged message (may be null).
 139          */
 140         public void info(String message) {
 141                 log(createLogLine(0, LogLevel.INFO, message, null));
 142         }
 143
 144         /**
 145          * Log using INFO level.
 146          *
 147          * @param message       the logged message (may be null).
 148          * @param cause         the causing exception (may be null).
 149          */
 150         public void info(String message, Throwable cause) {
 151                 log(createLogLine(0, LogLevel.INFO, message, cause));
 152         }
 153
 154         /**
 155          * Log using INFO level.
 156          *
 157          * @param levels        number of additional levels of stack trace to include.
 158          * @param message       the logged message (may be null).
 159          */
 160         public void info(int levels, String message) {
 161                 log(createLogLine(levels, LogLevel.INFO, message, null));
 162         }
 163
 164         /**
 165          * Log using INFO level.
 166          *
 167          * @param levels        number of additional levels of stack trace to include.
 168          * @param message       the logged message (may be null).
 169          * @param cause         the causing exception (may be null).
 170          */
 171         public void info(int levels, String message, Throwable cause) {
 172                 log(createLogLine(levels, LogLevel.INFO, message, cause));
 173         }
 174
 175
 176         /**
 177          * Log using USER level.
 178          *
 179          * @param message       the logged message (may be null).
 180          */
 181         public void user(String message) {
 182                 log(createLogLine(0, LogLevel.USER, message, null));
 183         }
 184
 185         /**
 186          * Log using USER level.
 187          *
 188          * @param message       the logged message (may be null).
 189          * @param cause         the causing exception (may be null).
 190          */
 191         public void user(String message, Throwable cause) {
 192                 log(createLogLine(0, LogLevel.USER, message, cause));
 193         }
 194
 195         /**
 196          * Log using USER level.
 197          *
 198          * @param levels        number of additional levels of stack trace to include.
 199          * @param message       the logged message (may be null).
 200          */
 201         public void user(int levels, String message) {
 202                 log(createLogLine(levels, LogLevel.USER, message, null));
 203         }
 204
 205         /**
 206          * Log using USER level.
 207          *
 208          * @param levels        number of additional levels of stack trace to include.
 209          * @param message       the logged message (may be null).
 210          * @param cause         the causing exception (may be null).
 211          */
 212         public void user(int levels, String message, Throwable cause) {
 213                 log(createLogLine(levels, LogLevel.USER, message, cause));
 214         }
 215
 216
 217         /**
 218          * Log using WARN level.
 219          *
 220          * @param message       the logged message (may be null).
 221          */
 222         public void warn(String message) {
 223                 log(createLogLine(0, LogLevel.WARN, message, null));
 224         }
 225
 226         /**
 227          * Log using WARN level.
 228          *
 229          * @param message       the logged message (may be null).
 230          * @param cause         the causing exception (may be null).
 231          */
 232         public void warn(String message, Throwable cause) {
 233                 log(createLogLine(0, LogLevel.WARN, message, cause));
 234         }
 235
 236         /**
 237          * Log using WARN level.
 238          *
 239          * @param levels        number of additional levels of stack trace to include.
 240          * @param message       the logged message (may be null).
 241          */
 242         public void warn(int levels, String message) {
 243                 log(createLogLine(levels, LogLevel.WARN, message, null));
 244         }
 245
 246         /**
 247          * Log using WARN level.
 248          *
 249          * @param levels        number of additional levels of stack trace to include.
 250          * @param message       the logged message (may be null).
 251          * @param cause         the causing exception (may be null).
 252          */
 253         public void warn(int levels, String message, Throwable cause) {
 254                 log(createLogLine(levels, LogLevel.WARN, message, cause));
 255         }
 256
 257
 258         /**
 259          * Log using ERROR level.
 260          *
 261          * @param message       the logged message (may be null).
 262          */
 263         public void error(String message) {
 264                 log(createLogLine(0, LogLevel.ERROR, message, null));
 265         }
 266
 267         /**
 268          * Log using ERROR level.
 269          *
 270          * @param message       the logged message (may be null).
 271          * @param cause         the causing exception (may be null).
 272          */
 273         public void error(String message, Throwable cause) {
 274                 log(createLogLine(0, LogLevel.ERROR, message, cause));
 275         }
 276
 277         /**
 278          * Log using ERROR level.
 279          *
 280          * @param levels        number of additional levels of stack trace to include.
 281          * @param message       the logged message (may be null).
 282          */
 283         public void error(int levels, String message) {
 284                 log(createLogLine(levels, LogLevel.ERROR, message, null));
 285         }
 286
 287         /**
 288          * Log using ERROR level.
 289          *
 290          * @param levels        number of additional levels of stack trace to include.
 291          * @param message       the logged message (may be null).
 292          * @param cause         the causing exception (may be null).
 293          */
 294         public void error(int levels, String message, Throwable cause) {
 295                 log(createLogLine(levels, LogLevel.ERROR, message, cause));
 296         }
 297
 298
 299
 300         /**
 301          * Log using the provided log level.
 302          *
 303          * @param level         the logging level.
 304          * @param message       the logged message (may be null).
 305          */
 306         public void log(LogLevel level, String message) {
 307                 log(createLogLine(0, level, message, null));
 308         }
 309
 310         /**
 311          * Log using the provided log level.
 312          *
 313          * @param level         the logging level.
 314          * @param message       the logged message (may be null).
 315          * @param cause         the causing exception (may be null).
 316          */
 317         public void log(LogLevel level, String message, Throwable cause) {
 318                 log(createLogLine(0, level, message, cause));
 319         }
 320
 321         /**
 322          * Log using the provided log level.
 323          *
 324          * @param levels        number of additional levels of stack trace to include.
 325          * @param level         the logging level.
 326          * @param message       the logged message (may be null).
 327          */
 328         public void log(int levels, LogLevel level, String message) {
 329                 log(createLogLine(levels, level, message, null));
 330         }
 331
 332         /**
 333          * Log using the provided log level.
 334          *
 335          * @param levels        number of additional levels of stack trace to include.
 336          * @param level         the logging level.
 337          * @param message       the logged message (may be null).
 338          * @param cause         the causing exception (may be null).
 339          */
 340         public void log(int levels, LogLevel level, String message, Throwable cause) {
 341                 log(createLogLine(levels, level, message, cause));
 342         }
 343
 344
 345
 346         /**
 347          * Instantiates, logs and throws a BugException.  The message is logged at
 348          * ERROR level.
 349          * <p>
 350          * This method never returns normally.
 351          *
 352          * @param message       the message for the log and exception.
 353          * @throws BugException always.
 354          */
 355         public void throwBugException(String message) throws BugException {
 356                 BugException e = new BugException(message);
 357                 log(createLogLine(0, LogLevel.ERROR, message, e));
 358                 throw e;
 359         }
 360
 361         /**
 362          * Instantiates, logs and throws a BugException.  The message is logged at
 363          * ERROR level with the specified cause.
 364          * <p>
 365          * This method never returns normally.
 366          *
 367          * @param message       the message for the log and exception.
 368          * @param cause         the causing exception (may be null).
 369          * @throws BugException always.
 370          */
 371         public void throwBugException(String message, Throwable cause) throws BugException {
 372                 BugException e = new BugException(message, cause);
 373                 log(createLogLine(0, LogLevel.ERROR, message, cause));
 374                 throw e;
 375         }
 376
 377
 378
 379
 380         /**
 381          * Create a LogLine object from the provided information.  This method must be
 382          * called directly from the called method in order for the trace position
 383          * to be correct!
 384          *
 385          * @param additionalLevels      how many additional stack trace levels to include on the line.
 386          * @param level                         the log level.
 387          * @param message                       the log message (null ok).
 388          * @param cause                         the log exception (null ok).
 389          *
 390          * @return                                      a LogLine populated with all necessary fields.
 391          */
 392         private LogLine createLogLine(int additionalLevels, LogLevel level, String message,
 393                         Throwable cause) {
 394                 TraceException trace;
 395                 if (level.atLeast(TRACING_LOG_LEVEL)) {
 396                         trace = new TraceException(2, 2 + additionalLevels);
 397                 } else {
 398                         trace = null;
 399                 }
 400                 return new LogLine(level, trace, message, cause);
 401         }
 402 }