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