2 * Copyright (C) 2014, United States Government, as represented by the
3 * Administrator of the National Aeronautics and Space Administration.
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
10 * http://www.apache.org/licenses/LICENSE-2.0.
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.
19 package gov.nasa.jpf.util;
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;
29 * this is a decorator for java.util.logging.JPFLogger
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.
34 * We provide a fat interface to avoid Object[] creation for ellipsis method
35 * or auto boxing for Object arguments
38 public class JPFLogger extends Logger {
40 protected Logger logger;
42 public JPFLogger (Logger logger) {
43 super(logger.getName(), logger.getResourceBundleName());
49 public ResourceBundle getResourceBundle() {
50 return logger.getResourceBundle();
54 public String getResourceBundleName() {
55 return logger.getResourceBundleName();
59 public void setFilter(Filter newFilter) throws SecurityException {
60 logger.setFilter(newFilter);
64 public Filter getFilter() {
65 return logger.getFilter();
69 public void log(LogRecord record) {
74 public void log(Level level, String msg) {
75 logger.log(level, msg);
79 public void log(Level level, String msg, Object param1) {
80 logger.log(level, msg, param1);
84 public void log(Level level, String msg, Object params[]) {
85 logger.log(level, msg, params);
89 public void log(Level level, String msg, Throwable thrown) {
90 logger.log(level, msg, thrown);
94 public void logp(Level level, String sourceClass, String sourceMethod, String msg) {
95 logger.logp(level, sourceClass, sourceMethod, msg);
99 public void logp(Level level, String sourceClass, String sourceMethod, String msg, Object param1) {
100 logger.logp(level, sourceClass, sourceMethod, msg, param1);
104 public void logp(Level level, String sourceClass, String sourceMethod, String msg, Object params[]) {
105 logger.logp(level, sourceClass, sourceMethod, msg, params);
109 public void logp(Level level, String sourceClass, String sourceMethod, String msg, Throwable thrown) {
110 logger.logp(level, sourceClass, sourceMethod, msg, thrown);
115 public void logrb(Level level, String sourceClass, String sourceMethod, String bundleName, String msg) {
116 logger.logrb(level, sourceClass, sourceMethod, bundleName, msg);
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);
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);
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);
138 public void entering(String sourceClass, String sourceMethod) {
139 logger.entering(sourceClass, sourceMethod);
143 public void entering(String sourceClass, String sourceMethod, Object param1) {
144 logger.entering(sourceClass, sourceMethod, param1);
148 public void entering(String sourceClass, String sourceMethod, Object params[]) {
149 logger.entering(sourceClass, sourceMethod, params);
153 public void exiting(String sourceClass, String sourceMethod) {
154 logger.exiting(sourceClass, sourceMethod);
158 public void exiting(String sourceClass, String sourceMethod, Object result) {
159 logger.exiting(sourceClass, sourceMethod, result);
163 public void throwing(String sourceClass, String sourceMethod, Throwable thrown) {
164 logger.throwing(sourceClass, sourceMethod, thrown);
168 public void severe(String msg) {
173 public void warning(String msg) {
178 public void info(String msg) {
183 public void config(String msg) {
188 public void fine(String msg) {
193 public void finer(String msg) {
198 public void finest(String msg) {
203 public void setLevel(Level newLevel) throws SecurityException {
204 logger.setLevel(newLevel);
208 public Level getLevel() {
209 return logger.getLevel();
213 public boolean isLoggable(Level level) {
214 return logger.isLoggable(level);
217 public boolean isInfoLogged(){
218 return isLoggable(Level.INFO);
221 public boolean isFineLogged(){
222 return isLoggable(Level.FINE);
225 public boolean isFinerLogged(){
226 return isLoggable(Level.FINER);
230 public String getName() {
231 return logger.getName();
235 public void addHandler(Handler handler) throws SecurityException {
236 logger.addHandler(handler);
240 public void removeHandler(Handler handler) throws SecurityException {
241 logger.removeHandler(handler);
245 public Handler[] getHandlers() {
246 return logger.getHandlers();
250 public void setUseParentHandlers(boolean useParentHandlers) {
251 logger.setUseParentHandlers(useParentHandlers);
255 public boolean getUseParentHandlers() {
256 return logger.getUseParentHandlers();
260 public Logger getParent() {
261 return logger.getParent();
265 public void setParent(Logger parent) {
266 logger.setParent(parent);
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++) {
275 logger.log(level, sb.toString());
279 public void severe (Object s1, Object s2) {
280 if (isLoggable(Level.SEVERE)) {
281 logger.log(Level.SEVERE, s1.toString() + s2.toString());
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);
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());
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());
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);
305 public void severe (Object... args){
306 if (isLoggable(Level.SEVERE)) {
307 log(Level.SEVERE, args);
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));
318 public void warning (Object s1, Object s2) {
319 if (isLoggable(Level.WARNING)) {
320 logger.log(Level.WARNING, s1.toString() + s2.toString());
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);
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());
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());
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);
344 public void warning (Object... args){
345 if (isLoggable(Level.WARNING)) {
346 log(Level.WARNING, args);
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));
357 public void info (Object s1, Object s2){
358 if (isLoggable(Level.INFO)) {
359 logger.log(Level.INFO, s1.toString() + s2.toString());
362 public void info (Object s1, int s2){
363 if (isLoggable(Level.INFO)) {
364 logger.log(Level.INFO, s1.toString() + s2);
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());
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());
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);
382 public void info (Object... args){
383 if (isLoggable(Level.INFO)) {
384 log(Level.INFO, args);
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));
395 public void config (Object s1, Object s2){
396 if (isLoggable(Level.CONFIG)) {
397 logger.log(Level.CONFIG, s1.toString() + s2.toString());
400 public void config (Object s1, int s2){
401 if (isLoggable(Level.CONFIG)) {
402 logger.log(Level.CONFIG, s1.toString() + s2);
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());
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());
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);
420 public void config (Object... args){
421 if (isLoggable(Level.CONFIG)) {
422 log(Level.CONFIG, args);
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));
433 public void fine (Object s1, Object s2){
434 if (isLoggable(Level.FINE)) {
435 logger.log(Level.FINE, s1.toString() + s2.toString());
438 public void fine (Object s1, int s2){
439 if (isLoggable(Level.FINE)) {
440 logger.log(Level.FINE, s1.toString() + s2);
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());
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());
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);
458 public void fine (Object... args){
459 if (isLoggable(Level.FINE)) {
460 log(Level.FINE, args);
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));
471 public void finer (Object s1, Object s2){
472 if (isLoggable(Level.FINER)) {
473 logger.log(Level.FINER, s1.toString() + s2.toString());
476 public void finer (Object s1, int s2){
477 if (isLoggable(Level.FINER)) {
478 logger.log(Level.FINER, s1.toString() + s2);
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());
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());
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);
496 public void finer (Object... args){
497 if (isLoggable(Level.FINER)) {
498 log(Level.FINER, args);
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));
509 public void finest (Object s1, Object s2){
510 if (isLoggable(Level.FINEST)) {
511 logger.log(Level.FINEST, s1.toString() + s2.toString());
514 public void finest (Object s1, int s2){
515 if (isLoggable(Level.FINEST)) {
516 logger.log(Level.FINEST, s1.toString() + s2);
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());
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());
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);
534 public void finest (Object... args){
535 if (isLoggable(Level.FINEST)) {
536 log(Level.FINEST, args);
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));