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         private static final DelegatorLogger delegator = new DelegatorLogger();
  25
  26         /**
  27          * Get the logger to be used in logging.
  28          *
  29          * @return      the logger to be used in all logging.
  30          */
  31         public static LogHelper getInstance() {
  32                 return delegator;
  33         }
  34
  35
  36
  37         public abstract void log(LogLine line);
  38
  39
  40
  41         /**
  42          * Log using DEBUG level.
  43          *
  44          * @param message       the logged message (may be null).
  45          */
  46         public void debug(String message) {
  47                 log(createLogLine(0, LogLevel.DEBUG, message, null));
  48         }
  49
  50         /**
  51          * Log using DEBUG level.
  52          *
  53          * @param message       the logged message (may be null).
  54          * @param cause         the causing exception (may be null).
  55          */
  56         public void debug(String message, Throwable cause) {
  57                 log(createLogLine(0, LogLevel.DEBUG, message, cause));
  58         }
  59
  60         /**
  61          * Log using DEBUG level.
  62          *
  63          * @param levels        number of additional levels of stack trace to include.
  64          * @param message       the logged message (may be null).
  65          */
  66         public void debug(int levels, String message) {
  67                 log(createLogLine(levels, LogLevel.DEBUG, message, null));
  68         }
  69
  70         /**
  71          * Log using DEBUG level.
  72          *
  73          * @param levels        number of additional levels of stack trace to include.
  74          * @param message       the logged message (may be null).
  75          * @param cause         the causing exception (may be null).
  76          */
  77         public void debug(int levels, String message, Throwable cause) {
  78                 log(createLogLine(levels, LogLevel.DEBUG, message, cause));
  79         }
  80
  81
  82         /**
  83          * Log using INFO level.
  84          *
  85          * @param message       the logged message (may be null).
  86          */
  87         public void info(String message) {
  88                 log(createLogLine(0, LogLevel.INFO, message, null));
  89         }
  90
  91         /**
  92          * Log using INFO level.
  93          *
  94          * @param message       the logged message (may be null).
  95          * @param cause         the causing exception (may be null).
  96          */
  97         public void info(String message, Throwable cause) {
  98                 log(createLogLine(0, LogLevel.INFO, message, cause));
  99         }
 100
 101         /**
 102          * Log using INFO level.
 103          *
 104          * @param levels        number of additional levels of stack trace to include.
 105          * @param message       the logged message (may be null).
 106          */
 107         public void info(int levels, String message) {
 108                 log(createLogLine(levels, LogLevel.INFO, message, null));
 109         }
 110
 111         /**
 112          * Log using INFO level.
 113          *
 114          * @param levels        number of additional levels of stack trace to include.
 115          * @param message       the logged message (may be null).
 116          * @param cause         the causing exception (may be null).
 117          */
 118         public void info(int levels, String message, Throwable cause) {
 119                 log(createLogLine(levels, LogLevel.INFO, message, cause));
 120         }
 121
 122
 123         /**
 124          * Log using USER level.
 125          *
 126          * @param message       the logged message (may be null).
 127          */
 128         public void user(String message) {
 129                 log(createLogLine(0, LogLevel.USER, message, null));
 130         }
 131
 132         /**
 133          * Log using USER level.
 134          *
 135          * @param message       the logged message (may be null).
 136          * @param cause         the causing exception (may be null).
 137          */
 138         public void user(String message, Throwable cause) {
 139                 log(createLogLine(0, LogLevel.USER, message, cause));
 140         }
 141
 142         /**
 143          * Log using USER level.
 144          *
 145          * @param levels        number of additional levels of stack trace to include.
 146          * @param message       the logged message (may be null).
 147          */
 148         public void user(int levels, String message) {
 149                 log(createLogLine(levels, LogLevel.USER, message, null));
 150         }
 151
 152         /**
 153          * Log using USER level.
 154          *
 155          * @param levels        number of additional levels of stack trace to include.
 156          * @param message       the logged message (may be null).
 157          * @param cause         the causing exception (may be null).
 158          */
 159         public void user(int levels, String message, Throwable cause) {
 160                 log(createLogLine(levels, LogLevel.USER, message, cause));
 161         }
 162
 163
 164         /**
 165          * Log using WARN level.
 166          *
 167          * @param message       the logged message (may be null).
 168          */
 169         public void warn(String message) {
 170                 log(createLogLine(0, LogLevel.WARN, message, null));
 171         }
 172
 173         /**
 174          * Log using WARN level.
 175          *
 176          * @param message       the logged message (may be null).
 177          * @param cause         the causing exception (may be null).
 178          */
 179         public void warn(String message, Throwable cause) {
 180                 log(createLogLine(0, LogLevel.WARN, message, cause));
 181         }
 182
 183         /**
 184          * Log using WARN level.
 185          *
 186          * @param levels        number of additional levels of stack trace to include.
 187          * @param message       the logged message (may be null).
 188          */
 189         public void warn(int levels, String message) {
 190                 log(createLogLine(levels, LogLevel.WARN, message, null));
 191         }
 192
 193         /**
 194          * Log using WARN level.
 195          *
 196          * @param levels        number of additional levels of stack trace to include.
 197          * @param message       the logged message (may be null).
 198          * @param cause         the causing exception (may be null).
 199          */
 200         public void warn(int levels, String message, Throwable cause) {
 201                 log(createLogLine(levels, LogLevel.WARN, message, cause));
 202         }
 203
 204
 205         /**
 206          * Log using ERROR level.
 207          *
 208          * @param message       the logged message (may be null).
 209          */
 210         public void error(String message) {
 211                 log(createLogLine(0, LogLevel.ERROR, message, null));
 212         }
 213
 214         /**
 215          * Log using ERROR level.
 216          *
 217          * @param message       the logged message (may be null).
 218          * @param cause         the causing exception (may be null).
 219          */
 220         public void error(String message, Throwable cause) {
 221                 log(createLogLine(0, LogLevel.ERROR, message, cause));
 222         }
 223
 224         /**
 225          * Log using ERROR level.
 226          *
 227          * @param levels        number of additional levels of stack trace to include.
 228          * @param message       the logged message (may be null).
 229          */
 230         public void error(int levels, String message) {
 231                 log(createLogLine(levels, LogLevel.ERROR, message, null));
 232         }
 233
 234         /**
 235          * Log using ERROR level.
 236          *
 237          * @param levels        number of additional levels of stack trace to include.
 238          * @param message       the logged message (may be null).
 239          * @param cause         the causing exception (may be null).
 240          */
 241         public void error(int levels, String message, Throwable cause) {
 242                 log(createLogLine(levels, LogLevel.ERROR, message, cause));
 243         }
 244
 245
 246
 247         /**
 248          * Log using the provided log level.
 249          *
 250          * @param level         the logging level.
 251          * @param message       the logged message (may be null).
 252          */
 253         public void log(LogLevel level, String message) {
 254                 log(createLogLine(0, level, message, null));
 255         }
 256
 257         /**
 258          * Log using the provided log level.
 259          *
 260          * @param level         the logging level.
 261          * @param message       the logged message (may be null).
 262          * @param cause         the causing exception (may be null).
 263          */
 264         public void log(LogLevel level, String message, Throwable cause) {
 265                 log(createLogLine(0, level, message, cause));
 266         }
 267
 268         /**
 269          * Log using the provided log level.
 270          *
 271          * @param levels        number of additional levels of stack trace to include.
 272          * @param level         the logging level.
 273          * @param message       the logged message (may be null).
 274          */
 275         public void log(int levels, LogLevel level, String message) {
 276                 log(createLogLine(levels, level, message, null));
 277         }
 278
 279         /**
 280          * Log using the provided log level.
 281          *
 282          * @param levels        number of additional levels of stack trace to include.
 283          * @param level         the logging level.
 284          * @param message       the logged message (may be null).
 285          * @param cause         the causing exception (may be null).
 286          */
 287         public void log(int levels, LogLevel level, String message, Throwable cause) {
 288                 log(createLogLine(levels, level, message, cause));
 289         }
 290
 291
 292
 293         /**
 294          * Instantiates, logs and throws a BugException.  The message is logged at
 295          * ERROR level.
 296          * <p>
 297          * This method never returns normally.
 298          *
 299          * @param message       the message for the log and exception.
 300          * @throws BugException always.
 301          */
 302         public void throwBugException(String message) throws BugException {
 303                 BugException e = new BugException(message);
 304                 log(createLogLine(0, LogLevel.ERROR, message, e));
 305                 throw e;
 306         }
 307
 308         /**
 309          * Instantiates, logs and throws a BugException.  The message is logged at
 310          * ERROR level with the specified cause.
 311          * <p>
 312          * This method never returns normally.
 313          *
 314          * @param message       the message for the log and exception.
 315          * @param cause         the causing exception (may be null).
 316          * @throws BugException always.
 317          */
 318         public void throwBugException(String message, Throwable cause) throws BugException {
 319                 BugException e = new BugException(message, cause);
 320                 log(createLogLine(0, LogLevel.ERROR, message, cause));
 321                 throw e;
 322         }
 323
 324
 325
 326
 327         /**
 328          * Create a LogLine object from the provided information.  This method must be
 329          * called directly from the called method in order for the trace position
 330          * to be correct!
 331          *
 332          * @param additionalLevels      how many additional stack trace levels to include on the line.
 333          * @param level                         the log level.
 334          * @param message                       the log message (null ok).
 335          * @param cause                         the log exception (null ok).
 336          *
 337          * @return                                      a LogLine populated with all necessary fields.
 338          */
 339         private LogLine createLogLine(int additionalLevels, LogLevel level, String message,
 340                         Throwable cause) {
 341                 TraceException trace = new TraceException(2, 2 + additionalLevels);
 342                 return new LogLine(level, trace, message, cause);
 343         }
 344 }