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