src/share/classes/sun/util/logging/PlatformLogger.java
Print this page
*** 30,39 ****
--- 30,40 ----
import java.io.PrintStream;
import java.io.PrintWriter;
import java.io.StringWriter;
import java.security.AccessController;
import java.security.PrivilegedAction;
+ import java.util.Arrays;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;
import sun.misc.JavaLangAccess;
import sun.misc.SharedSecrets;
*** 82,136 ****
* -Djava.util.logging.config.file system property.
*
* @since 1.7
*/
public class PlatformLogger {
! // shortcut to PlatformLogger.Level enums
! public static final Level OFF = Level.OFF;
! public static final Level SEVERE = Level.SEVERE;
! public static final Level WARNING = Level.WARNING;
! public static final Level INFO = Level.INFO;
! public static final Level CONFIG = Level.CONFIG;
! public static final Level FINE = Level.FINE;
! public static final Level FINER = Level.FINER;
! public static final Level FINEST = Level.FINEST;
! public static final Level ALL = Level.ALL;
/**
* PlatformLogger logging levels.
*/
public static enum Level {
! // The name and value must match that of {@code java.util.logging.Level} objects.
! ALL(Integer.MIN_VALUE),
! FINEST(300),
! FINER(400),
! FINE(500),
! CONFIG(700),
! INFO(800),
! WARNING(900),
! SEVERE(1000),
! OFF(Integer.MAX_VALUE);
/**
* Associated java.util.logging.Level lazily initialized in
* JavaLoggerProxy's static initializer only once
* when java.util.logging is available and enabled.
* Only accessed by JavaLoggerProxy.
*/
/* java.util.logging.Level */ Object javaLevel;
! private final int value;
public int intValue() {
! return value;
}
! Level(int value) {
! this.value = value;
}
}
! private static final Level DEFAULT_LEVEL = INFO;
private static boolean loggingEnabled;
static {
loggingEnabled = AccessController.doPrivileged(
new PrivilegedAction<Boolean>() {
public Boolean run() {
--- 83,166 ----
* -Djava.util.logging.config.file system property.
*
* @since 1.7
*/
public class PlatformLogger {
! /*
! * These constants should be shortcuts to Level enum constants that
! * the clients of sun.util.logging.PlatformLogger require no source
! * modification and avoid the conversion from int to Level enum.
! *
! * This can be done when JavaFX is converted to use the new PlatformLogger.Level API.
! */
! public static final int OFF = Integer.MAX_VALUE;
! public static final int SEVERE = 1000;
! public static final int WARNING = 900;
! public static final int INFO = 800;
! public static final int CONFIG = 700;
! public static final int FINE = 500;
! public static final int FINER = 400;
! public static final int FINEST = 300;
! public static final int ALL = Integer.MIN_VALUE;
/**
* PlatformLogger logging levels.
*/
public static enum Level {
! // The name and value must match that of {@code java.util.logging.Level}s.
! // Declare in ascending order of the given value for binary search.
! ALL,
! FINEST,
! FINER,
! FINE,
! CONFIG,
! INFO,
! WARNING,
! SEVERE,
! OFF;
/**
* Associated java.util.logging.Level lazily initialized in
* JavaLoggerProxy's static initializer only once
* when java.util.logging is available and enabled.
* Only accessed by JavaLoggerProxy.
*/
/* java.util.logging.Level */ Object javaLevel;
! // ascending order for binary search matching the list of enum constants
! private static final int[] levelValues = new int[] {
! PlatformLogger.ALL, PlatformLogger.FINEST, PlatformLogger.FINER,
! PlatformLogger.FINE, PlatformLogger.CONFIG, PlatformLogger.INFO,
! PlatformLogger.WARNING, PlatformLogger.SEVERE, PlatformLogger.OFF
! };
!
public int intValue() {
! return levelValues[this.ordinal()];
}
! static Level valueOf(int level) {
! switch (level) {
! // ordering per the highest occurences in the jdk source
! // finest, fine, finer, info first
! case PlatformLogger.FINEST : return Level.FINEST;
! case PlatformLogger.FINE : return Level.FINE;
! case PlatformLogger.FINER : return Level.FINER;
! case PlatformLogger.INFO : return Level.INFO;
! case PlatformLogger.WARNING : return Level.WARNING;
! case PlatformLogger.CONFIG : return Level.CONFIG;
! case PlatformLogger.SEVERE : return Level.SEVERE;
! case PlatformLogger.OFF : return Level.OFF;
! case PlatformLogger.ALL : return Level.ALL;
! }
! // return the nearest Level value >= the given level,
! // for level > SEVERE, return SEVERE and exclude OFF
! int i = Arrays.binarySearch(levelValues, 0, levelValues.length-2, level);
! return values()[i >= 0 ? i : (-i-1)];
}
}
! private static final Level DEFAULT_LEVEL = Level.INFO;
private static boolean loggingEnabled;
static {
loggingEnabled = AccessController.doPrivileged(
new PrivilegedAction<Boolean>() {
public Boolean run() {
*** 232,262 ****
}
/**
* Returns true if a message of the given level would actually
* be logged by this logger.
*/
public boolean isLoggable(Level level) {
// performance-sensitive method: use two monomorphic call-sites
JavaLoggerProxy jlp = javaLoggerProxy;
return jlp != null ? jlp.isLoggable(level) : loggerProxy.isLoggable(level);
}
/**
* Get the log level that has been specified for this PlatformLogger.
* The result may be null, which means that this logger's
* effective level will be inherited from its parent.
*
- * This method is primarily for testing purpose and not recommended
- * to be used at runtime since it does not support custom j.u.l.Level.
- *
* @return this PlatformLogger's level
- *
- * @throw IllegalArgumentException if j.u.l.Logger is set to
- * a custom j.u.l.Level when java.util.logging facility is enabled
*/
! public Level getLevel() {
return loggerProxy.getLevel();
}
/**
* Set the log level specifying which message levels will be
--- 262,322 ----
}
/**
* Returns true if a message of the given level would actually
* be logged by this logger.
+ *
+ * @deprecated Use isLoggable(Level) instead.
+ */
+ @Deprecated
+ public boolean isLoggable(int levelValue) {
+ return isLoggable(Level.valueOf(levelValue));
+ }
+
+ /**
+ * Gets the current log level. Returns 0 if the current effective level is
+ * not set (equivalent to Logger.getLevel() returns null).
+ *
+ * @deprecated Use level() instead
+ */
+ @Deprecated
+ public int getLevel() {
+ Level level = loggerProxy.getLevel();
+ return level != null ? level.intValue() : 0;
+ }
+
+ /**
+ * Sets the log level.
+ *
+ * @deprecated Use setLevel(Level) instead
+ */
+ @Deprecated
+ public void setLevel(int newLevel) {
+ loggerProxy.setLevel(newLevel == 0 ? null : Level.valueOf(newLevel));
+ }
+
+ /**
+ * Returns true if a message of the given level would actually
+ * be logged by this logger.
*/
public boolean isLoggable(Level level) {
+ if (level == null) {
+ throw new NullPointerException();
+ }
// performance-sensitive method: use two monomorphic call-sites
JavaLoggerProxy jlp = javaLoggerProxy;
return jlp != null ? jlp.isLoggable(level) : loggerProxy.isLoggable(level);
}
/**
* Get the log level that has been specified for this PlatformLogger.
* The result may be null, which means that this logger's
* effective level will be inherited from its parent.
*
* @return this PlatformLogger's level
*/
! public Level level() {
return loggerProxy.getLevel();
}
/**
* Set the log level specifying which message levels will be
*** 276,384 ****
/**
* Logs a SEVERE message.
*/
public void severe(String msg) {
! loggerProxy.doLog(SEVERE, msg);
}
public void severe(String msg, Throwable t) {
! loggerProxy.doLog(SEVERE, msg, t);
}
public void severe(String msg, Object... params) {
! loggerProxy.doLog(SEVERE, msg, params);
}
/**
* Logs a WARNING message.
*/
public void warning(String msg) {
! loggerProxy.doLog(WARNING, msg);
}
public void warning(String msg, Throwable t) {
! loggerProxy.doLog(WARNING, msg, t);
}
public void warning(String msg, Object... params) {
! loggerProxy.doLog(WARNING, msg, params);
}
/**
* Logs an INFO message.
*/
public void info(String msg) {
! loggerProxy.doLog(INFO, msg);
}
public void info(String msg, Throwable t) {
! loggerProxy.doLog(INFO, msg, t);
}
public void info(String msg, Object... params) {
! loggerProxy.doLog(INFO, msg, params);
}
/**
* Logs a CONFIG message.
*/
public void config(String msg) {
! loggerProxy.doLog(CONFIG, msg);
}
public void config(String msg, Throwable t) {
! loggerProxy.doLog(CONFIG, msg, t);
}
public void config(String msg, Object... params) {
! loggerProxy.doLog(CONFIG, msg, params);
}
/**
* Logs a FINE message.
*/
public void fine(String msg) {
! loggerProxy.doLog(FINE, msg);
}
public void fine(String msg, Throwable t) {
! loggerProxy.doLog(FINE, msg, t);
}
public void fine(String msg, Object... params) {
! loggerProxy.doLog(FINE, msg, params);
}
/**
* Logs a FINER message.
*/
public void finer(String msg) {
! loggerProxy.doLog(FINER, msg);
}
public void finer(String msg, Throwable t) {
! loggerProxy.doLog(FINER, msg, t);
}
public void finer(String msg, Object... params) {
! loggerProxy.doLog(FINER, msg, params);
}
/**
* Logs a FINEST message.
*/
public void finest(String msg) {
! loggerProxy.doLog(FINEST, msg);
}
public void finest(String msg, Throwable t) {
! loggerProxy.doLog(FINEST, msg, t);
}
public void finest(String msg, Object... params) {
! loggerProxy.doLog(FINEST, msg, params);
}
/**
* Abstract base class for logging support, defining the API and common field.
*/
--- 336,444 ----
/**
* Logs a SEVERE message.
*/
public void severe(String msg) {
! loggerProxy.doLog(Level.SEVERE, msg);
}
public void severe(String msg, Throwable t) {
! loggerProxy.doLog(Level.SEVERE, msg, t);
}
public void severe(String msg, Object... params) {
! loggerProxy.doLog(Level.SEVERE, msg, params);
}
/**
* Logs a WARNING message.
*/
public void warning(String msg) {
! loggerProxy.doLog(Level.WARNING, msg);
}
public void warning(String msg, Throwable t) {
! loggerProxy.doLog(Level.WARNING, msg, t);
}
public void warning(String msg, Object... params) {
! loggerProxy.doLog(Level.WARNING, msg, params);
}
/**
* Logs an INFO message.
*/
public void info(String msg) {
! loggerProxy.doLog(Level.INFO, msg);
}
public void info(String msg, Throwable t) {
! loggerProxy.doLog(Level.INFO, msg, t);
}
public void info(String msg, Object... params) {
! loggerProxy.doLog(Level.INFO, msg, params);
}
/**
* Logs a CONFIG message.
*/
public void config(String msg) {
! loggerProxy.doLog(Level.CONFIG, msg);
}
public void config(String msg, Throwable t) {
! loggerProxy.doLog(Level.CONFIG, msg, t);
}
public void config(String msg, Object... params) {
! loggerProxy.doLog(Level.CONFIG, msg, params);
}
/**
* Logs a FINE message.
*/
public void fine(String msg) {
! loggerProxy.doLog(Level.FINE, msg);
}
public void fine(String msg, Throwable t) {
! loggerProxy.doLog(Level.FINE, msg, t);
}
public void fine(String msg, Object... params) {
! loggerProxy.doLog(Level.FINE, msg, params);
}
/**
* Logs a FINER message.
*/
public void finer(String msg) {
! loggerProxy.doLog(Level.FINER, msg);
}
public void finer(String msg, Throwable t) {
! loggerProxy.doLog(Level.FINER, msg, t);
}
public void finer(String msg, Object... params) {
! loggerProxy.doLog(Level.FINER, msg, params);
}
/**
* Logs a FINEST message.
*/
public void finest(String msg) {
! loggerProxy.doLog(Level.FINEST, msg);
}
public void finest(String msg, Throwable t) {
! loggerProxy.doLog(Level.FINEST, msg, t);
}
public void finest(String msg, Object... params) {
! loggerProxy.doLog(Level.FINEST, msg, params);
}
/**
* Abstract base class for logging support, defining the API and common field.
*/
*** 419,429 ****
this.effectiveLevel = deriveEffectiveLevel(null);
this.level = null;
}
boolean isEnabled() {
! return effectiveLevel != OFF;
}
Level getLevel() {
return level;
}
--- 479,489 ----
this.effectiveLevel = deriveEffectiveLevel(null);
this.level = null;
}
boolean isEnabled() {
! return effectiveLevel != Level.OFF;
}
Level getLevel() {
return level;
}
*** 455,465 ****
}
}
boolean isLoggable(Level level) {
Level effectiveLevel = this.effectiveLevel;
! return level.intValue() >= effectiveLevel.intValue() && effectiveLevel != OFF;
}
// derive effective level (could do inheritance search like j.u.l.Logger)
private Level deriveEffectiveLevel(Level level) {
return level == null ? DEFAULT_LEVEL : level;
--- 515,525 ----
}
}
boolean isLoggable(Level level) {
Level effectiveLevel = this.effectiveLevel;
! return level.intValue() >= effectiveLevel.intValue() && effectiveLevel != Level.OFF;
}
// derive effective level (could do inheritance search like j.u.l.Logger)
private Level deriveEffectiveLevel(Level level) {
return level == null ? DEFAULT_LEVEL : level;
*** 609,627 ****
return LoggingSupport.isLoggable(javaLogger, Level.OFF.javaLevel);
}
/**
* Returns the PlatformLogger.Level mapped from j.u.l.Level
! * set in the logger.
! * @throw IllegalArgumentException if j.u.l.Logger is set to
! * a custom j.u.l.Level
*/
Level getLevel() {
Object javaLevel = LoggingSupport.getLevel(javaLogger);
! return javaLevel == null
! ? null
! : Level.valueOf(LoggingSupport.getLevelName(javaLevel));
}
void setLevel(Level level) {
LoggingSupport.setLevel(javaLogger, level == null ? null : level.javaLevel);
}
--- 669,690 ----
return LoggingSupport.isLoggable(javaLogger, Level.OFF.javaLevel);
}
/**
* Returns the PlatformLogger.Level mapped from j.u.l.Level
! * set in the logger. If the j.u.l.Logger is set to a custom Level,
! * this method will return the nearest Level.
*/
Level getLevel() {
Object javaLevel = LoggingSupport.getLevel(javaLogger);
! if (javaLevel == null) return null;
!
! try {
! return Level.valueOf(LoggingSupport.getLevelName(javaLevel));
! } catch (IllegalArgumentException e) {
! return Level.valueOf(LoggingSupport.getLevelValue(javaLevel));
! }
}
void setLevel(Level level) {
LoggingSupport.setLevel(javaLogger, level == null ? null : level.javaLevel);
}