src/main/gov/nasa/jpf/util/JPFLogger.java

   1 /*
   2  * Copyright (C) 2014, United States Government, as represented by the
   3  * Administrator of the National Aeronautics and Space Administration.
   4  * All rights reserved.
   5  *
   6  * The Java Pathfinder core (jpf-core) platform is licensed under the
   7  * Apache License, Version 2.0 (the "License"); you may not use this file except
   8  * in compliance with the License. You may obtain a copy of the License at
   9  *
  10  *        http://www.apache.org/licenses/LICENSE-2.0.
  11  *
  12  * Unless required by applicable law or agreed to in writing, software
  13  * distributed under the License is distributed on an "AS IS" BASIS,
  14  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15  * See the License for the specific language governing permissions and
  16  * limitations under the License.
  17  */
  18
  19 package gov.nasa.jpf.util;
  20
  21 import java.util.ResourceBundle;
  22 import java.util.logging.Filter;
  23 import java.util.logging.Handler;
  24 import java.util.logging.Level;
  25 import java.util.logging.LogRecord;
  26 import java.util.logging.Logger;
  27
  28 /**
  29  * this is a decorator for java.util.logging.JPFLogger
  30  *
  31  * We use this to avoid explicit Logger.isLoggable() checks in the code.
  32  * The goal is to avoid time & memory overhead if logging is not enabled.
  33  *
  34  * We provide a fat interface to avoid Object[] creation for ellipsis method
  35  * or auto boxing for Object arguments
  36  *
  37  */
  38 public class JPFLogger extends Logger {
  39
  40   protected Logger logger;
  41
  42   public JPFLogger (Logger logger) {
  43     super(logger.getName(), logger.getResourceBundleName());
  44
  45     this.logger = logger;
  46   }
  47
  48   @Override
  49   public ResourceBundle getResourceBundle() {
  50     return logger.getResourceBundle();
  51   }
  52
  53   @Override
  54   public String getResourceBundleName() {
  55     return logger.getResourceBundleName();
  56   }
  57
  58   @Override
  59   public void setFilter(Filter newFilter) throws SecurityException {
  60     logger.setFilter(newFilter);
  61   }
  62
  63   @Override
  64   public Filter getFilter() {
  65     return logger.getFilter();
  66   }
  67
  68   @Override
  69   public void log(LogRecord record) {
  70     logger.log(record);
  71   }
  72
  73   @Override
  74   public void log(Level level, String msg) {
  75     logger.log(level, msg);
  76   }
  77
  78   @Override
  79   public void log(Level level, String msg, Object param1) {
  80     logger.log(level, msg, param1);
  81   }
  82
  83   @Override
  84   public void log(Level level, String msg, Object params[]) {
  85     logger.log(level, msg, params);
  86   }
  87
  88   @Override
  89   public void log(Level level, String msg, Throwable thrown) {
  90     logger.log(level, msg, thrown);
  91   }
  92
  93   @Override
  94   public void logp(Level level, String sourceClass, String sourceMethod, String msg) {
  95     logger.logp(level, sourceClass, sourceMethod, msg);
  96   }
  97
  98   @Override
  99   public void logp(Level level, String sourceClass, String sourceMethod, String msg, Object param1) {
 100     logger.logp(level, sourceClass, sourceMethod, msg, param1);
 101   }
 102
 103   @Override
 104   public void logp(Level level, String sourceClass, String sourceMethod, String msg, Object params[]) {
 105     logger.logp(level, sourceClass, sourceMethod, msg, params);
 106   }
 107
 108   @Override
 109   public void logp(Level level, String sourceClass, String sourceMethod, String msg, Throwable thrown) {
 110     logger.logp(level, sourceClass, sourceMethod, msg, thrown);
 111   }
 112
 113   @Override
 114 @Deprecated
 115   public void logrb(Level level, String sourceClass, String sourceMethod, String bundleName, String msg) {
 116     logger.logrb(level, sourceClass, sourceMethod, bundleName, msg);
 117   }
 118
 119   @Override
 120 @Deprecated
 121   public void logrb(Level level, String sourceClass, String sourceMethod, String bundleName, String msg, Object param1) {
 122     logger.logrb(level, sourceClass, sourceMethod, bundleName, msg, param1);
 123   }
 124
 125   @Override
 126 @Deprecated
 127   public void logrb(Level level, String sourceClass, String sourceMethod, String bundleName, String msg, Object params[]) {
 128     logger.logrb(level, sourceClass, sourceMethod, bundleName, msg, params);
 129   }
 130
 131   @Override
 132 @Deprecated
 133   public void logrb(Level level, String sourceClass, String sourceMethod, String bundleName, String msg, Throwable thrown) {
 134     logger.logrb(level, sourceClass, sourceMethod, bundleName, msg, thrown);
 135   }
 136
 137   @Override
 138   public void entering(String sourceClass, String sourceMethod) {
 139     logger.entering(sourceClass, sourceMethod);
 140   }
 141
 142   @Override
 143   public void entering(String sourceClass, String sourceMethod, Object param1) {
 144     logger.entering(sourceClass, sourceMethod, param1);
 145   }
 146
 147   @Override
 148   public void entering(String sourceClass, String sourceMethod, Object params[]) {
 149     logger.entering(sourceClass, sourceMethod, params);
 150   }
 151
 152   @Override
 153   public void exiting(String sourceClass, String sourceMethod) {
 154     logger.exiting(sourceClass, sourceMethod);
 155   }
 156
 157   @Override
 158   public void exiting(String sourceClass, String sourceMethod, Object result) {
 159     logger.exiting(sourceClass, sourceMethod, result);
 160   }
 161
 162   @Override
 163   public void throwing(String sourceClass, String sourceMethod, Throwable thrown) {
 164     logger.throwing(sourceClass, sourceMethod, thrown);
 165   }
 166
 167   @Override
 168   public void severe(String msg) {
 169     logger.severe(msg);
 170   }
 171
 172   @Override
 173   public void warning(String msg) {
 174     logger.warning(msg);
 175   }
 176
 177   @Override
 178   public void info(String msg) {
 179     logger.info(msg);
 180   }
 181
 182   @Override
 183   public void config(String msg) {
 184     logger.config(msg);
 185   }
 186
 187   @Override
 188   public void fine(String msg) {
 189     logger.fine(msg);
 190   }
 191
 192   @Override
 193   public void finer(String msg) {
 194     logger.finer(msg);
 195   }
 196
 197   @Override
 198   public void finest(String msg) {
 199     logger.finest(msg);
 200   }
 201
 202   @Override
 203   public void setLevel(Level newLevel) throws SecurityException {
 204     logger.setLevel(newLevel);
 205   }
 206
 207   @Override
 208   public Level getLevel() {
 209     return logger.getLevel();
 210   }
 211
 212   @Override
 213   public boolean isLoggable(Level level) {
 214     return logger.isLoggable(level);
 215   }
 216
 217   public boolean isInfoLogged(){
 218     return isLoggable(Level.INFO);
 219   }
 220
 221   public boolean isFineLogged(){
 222     return isLoggable(Level.FINE);
 223   }
 224
 225   public boolean isFinerLogged(){
 226     return isLoggable(Level.FINER);
 227   }
 228
 229   @Override
 230   public String getName() {
 231     return logger.getName();
 232   }
 233
 234   @Override
 235   public void addHandler(Handler handler) throws SecurityException {
 236     logger.addHandler(handler);
 237   }
 238
 239   @Override
 240   public void removeHandler(Handler handler) throws SecurityException {
 241     logger.removeHandler(handler);
 242   }
 243
 244   @Override
 245   public Handler[] getHandlers() {
 246     return logger.getHandlers();
 247   }
 248
 249   @Override
 250   public void setUseParentHandlers(boolean useParentHandlers) {
 251     logger.setUseParentHandlers(useParentHandlers);
 252   }
 253
 254   @Override
 255   public boolean getUseParentHandlers() {
 256     return logger.getUseParentHandlers();
 257   }
 258
 259   @Override
 260   public Logger getParent() {
 261     return logger.getParent();
 262   }
 263
 264   @Override
 265   public void setParent(Logger parent) {
 266     logger.setParent(parent);
 267   }
 268
 269   private void log (Level level, Object... args) {
 270     StringBuilder sb = new StringBuilder(256);
 271     int length = args.length;
 272     for (int i = 0; i < length; i++) {
 273       sb.append(args[i]);
 274     }
 275     logger.log(level, sb.toString());
 276   }
 277
 278   //--- the SEVERE
 279   public void severe (Object s1, Object s2) {
 280     if (isLoggable(Level.SEVERE)) {
 281       logger.log(Level.SEVERE, s1.toString() + s2.toString());
 282     }
 283   }
 284   // this is here to avoid auto boxing
 285   public void severe (Object s1, int s2){
 286     if (isLoggable(Level.SEVERE)) {
 287          logger.log(Level.SEVERE, s1.toString() + s2);
 288     }
 289   }
 290   public void severe (Object s1, Object s2, Object s3){
 291     if (isLoggable(Level.SEVERE)) {
 292       logger.log(Level.SEVERE, s1.toString() + s2.toString() + s3.toString());
 293     }
 294   }
 295   public void severe (Object s1, Object s2, Object s3, Object s4){
 296     if (isLoggable(Level.SEVERE)) {
 297       logger.log(Level.SEVERE, s1.toString() + s2.toString() + s3.toString() + s4.toString());
 298     }
 299   }
 300   public void severe (Object s1, int s2, Object s3, int s4){
 301     if (isLoggable(Level.SEVERE)) {
 302       logger.log(Level.SEVERE, s1.toString() + s2 + s3.toString() + s4);
 303     }
 304   }
 305   public void severe (Object... args){
 306     if (isLoggable(Level.SEVERE)) {
 307       log(Level.SEVERE, args);
 308     }
 309   }
 310   // note this still wraps args into a String array - overhead
 311   public void fsevere (String format, Object... args){
 312     if (isLoggable(Level.SEVERE)) {
 313       logger.log(Level.SEVERE, String.format(format, args));
 314     }
 315   }
 316
 317   //--- the WARNING
 318   public void warning (Object s1, Object s2) {
 319     if (isLoggable(Level.WARNING)) {
 320       logger.log(Level.WARNING, s1.toString() + s2.toString());
 321     }
 322   }
 323   // this is here to avoid auto boxing
 324   public void warning (Object s1, int s2){
 325     if (isLoggable(Level.WARNING)) {
 326          logger.log(Level.WARNING, s1.toString() + s2);
 327     }
 328   }
 329   public void warning (Object s1, Object s2, Object s3){
 330     if (isLoggable(Level.WARNING)) {
 331       logger.log(Level.WARNING, s1.toString() + s2.toString() + s3.toString());
 332     }
 333   }
 334   public void warning (Object s1, Object s2, Object s3, Object s4){
 335     if (isLoggable(Level.WARNING)) {
 336       logger.log(Level.WARNING, s1.toString() + s2.toString() + s3.toString() + s4.toString());
 337     }
 338   }
 339   public void warning (Object s1, int s2, Object s3, int s4){
 340     if (isLoggable(Level.WARNING)) {
 341       logger.log(Level.WARNING, s1.toString() + s2 + s3.toString() + s4);
 342     }
 343   }
 344   public void warning (Object... args){
 345     if (isLoggable(Level.WARNING)) {
 346       log(Level.WARNING, args);
 347     }
 348   }
 349   // note this still wraps args into a String array - overhead
 350   public void fwarning (String format, Object... args){
 351     if (isLoggable(Level.WARNING)) {
 352       logger.log(Level.WARNING, String.format(format, args));
 353     }
 354   }
 355
 356   //--- the INFO
 357   public void info (Object s1, Object s2){
 358     if (isLoggable(Level.INFO)) {
 359       logger.log(Level.INFO, s1.toString() + s2.toString());
 360     }
 361   }
 362   public void info (Object s1, int s2){
 363     if (isLoggable(Level.INFO)) {
 364       logger.log(Level.INFO, s1.toString() + s2);
 365     }
 366   }
 367   public void info (Object s1, Object s2, Object s3){
 368     if (isLoggable(Level.INFO)) {
 369       logger.log(Level.INFO, s1.toString() + s2.toString() + s3.toString());
 370     }
 371   }
 372   public void info (Object s1, Object s2, Object s3, Object s4){
 373     if (isLoggable(Level.INFO)) {
 374       logger.log(Level.INFO, s1.toString() + s2.toString() + s3.toString() + s4.toString());
 375     }
 376   }
 377   public void info (Object s1, int s2, Object s3, int s4){
 378     if (isLoggable(Level.INFO)) {
 379       logger.log(Level.INFO, s1.toString() + s2 + s3.toString() + s4);
 380     }
 381   }
 382   public void info (Object... args){
 383     if (isLoggable(Level.INFO)) {
 384       log(Level.INFO, args);
 385     }
 386   }
 387   // note this still wraps args into a String array - overhead
 388   public void finfo (String format, Object... args){
 389     if (isLoggable(Level.INFO)) {
 390       logger.log(Level.INFO, String.format(format, args));
 391     }
 392   }
 393
 394   //--- the CONFIG
 395   public void config (Object s1, Object s2){
 396     if (isLoggable(Level.CONFIG)) {
 397       logger.log(Level.CONFIG, s1.toString() + s2.toString());
 398     }
 399   }
 400   public void config (Object s1, int s2){
 401     if (isLoggable(Level.CONFIG)) {
 402       logger.log(Level.CONFIG, s1.toString() + s2);
 403     }
 404   }
 405   public void config (Object s1, Object s2, Object s3){
 406     if (isLoggable(Level.CONFIG)) {
 407       logger.log(Level.CONFIG, s1.toString() + s2.toString() + s3.toString());
 408     }
 409   }
 410   public void config (Object s1, Object s2, Object s3, Object s4){
 411     if (isLoggable(Level.CONFIG)) {
 412       logger.log(Level.CONFIG, s1.toString() + s2.toString() + s3.toString() + s4.toString());
 413     }
 414   }
 415   public void config (Object s1, int s2, Object s3, int s4){
 416     if (isLoggable(Level.CONFIG)) {
 417       logger.log(Level.CONFIG, s1.toString() + s2 + s3.toString() + s4);
 418     }
 419   }
 420   public void config (Object... args){
 421     if (isLoggable(Level.CONFIG)) {
 422       log(Level.CONFIG, args);
 423     }
 424   }
 425   // note this still wraps args into a String array - overhead
 426   public void fconfig (String format, String... args){
 427     if (isLoggable(Level.CONFIG)) {
 428       logger.log(Level.CONFIG, String.format(format, (Object)args));
 429     }
 430   }
 431
 432   //--- the FINE
 433   public void fine (Object s1, Object s2){
 434     if (isLoggable(Level.FINE)) {
 435       logger.log(Level.FINE, s1.toString() + s2.toString());
 436     }
 437   }
 438   public void fine (Object s1, int s2){
 439     if (isLoggable(Level.FINE)) {
 440       logger.log(Level.FINE, s1.toString() + s2);
 441     }
 442   }
 443   public void fine (Object s1, Object s2, Object s3){
 444     if (isLoggable(Level.FINE)) {
 445       logger.log(Level.FINE, s1.toString() + s2.toString() + s3.toString());
 446     }
 447   }
 448   public void fine (Object s1, Object s2, Object s3, Object s4){
 449     if (isLoggable(Level.FINE)) {
 450       logger.log(Level.FINE, s1.toString() + s2.toString() + s3.toString() + s4.toString());
 451     }
 452   }
 453   public void fine (Object s1, int s2, Object s3, int s4){
 454     if (isLoggable(Level.FINE)) {
 455       logger.log(Level.FINE, s1.toString() + s2 + s3.toString() + s4);
 456     }
 457   }
 458   public void fine (Object... args){
 459     if (isLoggable(Level.FINE)) {
 460       log(Level.FINE, args);
 461     }
 462   }
 463   // note this still wraps args into a String array - overhead
 464   public void ffine (String format, Object... args){
 465     if (isLoggable(Level.FINE)) {
 466       logger.log(Level.FINE, String.format(format, args));
 467     }
 468   }
 469
 470   //--- the FINER
 471   public void finer (Object s1, Object s2){
 472     if (isLoggable(Level.FINER)) {
 473       logger.log(Level.FINER, s1.toString() + s2.toString());
 474     }
 475   }
 476   public void finer (Object s1, int s2){
 477     if (isLoggable(Level.FINER)) {
 478       logger.log(Level.FINER, s1.toString() + s2);
 479     }
 480   }
 481   public void finer (Object s1, Object s2, Object s3){
 482     if (isLoggable(Level.FINER)) {
 483       logger.log(Level.FINER, s1.toString() + s2.toString() + s3.toString());
 484     }
 485   }
 486   public void finer (Object s1, Object s2, Object s3, Object s4){
 487     if (isLoggable(Level.FINER)) {
 488       logger.log(Level.FINER, s1.toString() + s2.toString() + s3.toString() + s4.toString());
 489     }
 490   }
 491   public void finer (Object s1, int s2, Object s3, int s4){
 492     if (isLoggable(Level.FINER)) {
 493       logger.log(Level.FINER, s1.toString() + s2 + s3.toString() + s4);
 494     }
 495   }
 496   public void finer (Object... args){
 497     if (isLoggable(Level.FINER)) {
 498       log(Level.FINER, args);
 499     }
 500   }
 501   // note this still wraps args into a String array - overhead
 502   public void ffiner (String format, Object... args){
 503     if (isLoggable(Level.FINER)) {
 504       logger.log(Level.FINER, String.format(format, args));
 505     }
 506   }
 507
 508   //--- the FINEST
 509   public void finest (Object s1, Object s2){
 510     if (isLoggable(Level.FINEST)) {
 511       logger.log(Level.FINEST, s1.toString() + s2.toString());
 512     }
 513   }
 514   public void finest (Object s1, int s2){
 515     if (isLoggable(Level.FINEST)) {
 516       logger.log(Level.FINEST, s1.toString() + s2);
 517     }
 518   }
 519   public void finest (Object s1, Object s2, Object s3){
 520     if (isLoggable(Level.FINEST)) {
 521       logger.log(Level.FINEST, s1.toString() + s2.toString() + s3.toString());
 522     }
 523   }
 524   public void finest (Object s1, Object s2, Object s3, Object s4){
 525     if (isLoggable(Level.FINEST)) {
 526       logger.log(Level.FINEST, s1.toString() + s2.toString() + s3.toString() + s4.toString());
 527     }
 528   }
 529   public void finest (Object s1, int s2, Object s3, int s4){
 530     if (isLoggable(Level.FINEST)) {
 531       logger.log(Level.FINEST, s1.toString() + s2 + s3.toString() + s4);
 532     }
 533   }
 534   public void finest (Object... args){
 535     if (isLoggable(Level.FINEST)) {
 536       log(Level.FINEST, args);
 537     }
 538   }
 539   // note this still wraps args into a String array - overhead
 540   public void ffinest (String format, Object... args){
 541     if (isLoggable(Level.FINEST)) {
 542       logger.log(Level.FINEST, String.format(format, args));
 543     }
 544   }
 545 }