jdk/src/java.logging/share/classes/sun/util/logging/internal/LoggingProviderImpl.java - platform/libcore - Git at Google

 /*
  * Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License version 2 only, as
  * published by the Free Software Foundation.  Oracle designates this
  * particular file as subject to the "Classpath" exception as provided
  * by Oracle in the LICENSE file that accompanied this code.
  *
  * This code is distributed in the hope that it will be useful, but WITHOUT
  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  * version 2 for more details (a copy is included in the LICENSE file that
  * accompanied this code).
  *
  * You should have received a copy of the GNU General Public License version
  * 2 along with this work; if not, write to the Free Software Foundation,
  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  *
  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  * or visit www.oracle.com if you need additional information or have any
  * questions.
  */


 package sun.util.logging.internal;

 import java.security.AccessController;
 import java.security.PrivilegedAction;
 import java.util.ResourceBundle;
 import java.util.function.Supplier;
 import java.lang.System.LoggerFinder;
 import java.lang.System.Logger;
 import java.util.Objects;
 import java.util.logging.LogManager;
 import jdk.internal.logger.DefaultLoggerFinder;
 import java.util.logging.LoggingPermission;
 import sun.util.logging.PlatformLogger;
 import sun.util.logging.PlatformLogger.ConfigurableBridge.LoggerConfiguration;

 /**
  * This {@code LoggingProviderImpl} is the JDK internal implementation of the
  * {@link jdk.internal.logger.DefaultLoggerFinder} which is used by
  * the default implementation of the {@link Logger}
  * when no {@link LoggerFinder} is found
  * and {@code java.util.logging} is present.
  * When {@code java.util.logging} is present, the {@code LoggingProviderImpl}
  * is {@linkplain java.util.ServiceLoader#loadInstalled(Class) installed} as
  * an internal service provider, making it possible to use {@code java.util.logging}
  * as the backend for loggers returned by the default LoggerFinder implementation.
  * <p>
  * This implementation of {@link DefaultLoggerFinder} returns instances of
  * {@link java.lang.System.Logger} which
  * delegate to a wrapped instance of {@link java.util.logging.Logger
  * java.util.logging.Logger}.
  * <br>
  * Loggers returned by this class can therefore be configured by accessing
  * their wrapped implementation through the regular {@code java.util.logging}
  * APIs - such as {@link java.util.logging.LogManager java.util.logging.LogManager}
  * and {@link java.util.logging.Logger java.util.logging.Logger}.
  *
  * @apiNote Programmers are not expected to call this class directly.
  * Instead they should rely on the static methods defined by
  * {@link java.lang.System java.lang.System}.
  * <p>
  * To replace this default
  * {@code java.util.logging} backend, an application is expected to install
  * its own {@link java.lang.System.LoggerFinder}.
  *
  * @see java.lang.System.Logger
  * @see java.lang.System.LoggerFinder
  * @see sun.util.logging.PlatformLogger.Bridge
  * @see java.lang.System
  * @see jdk.internal.logger
  * @see jdk.internal.logger
  *
  */
 public final class LoggingProviderImpl extends DefaultLoggerFinder {
     static final RuntimePermission LOGGERFINDER_PERMISSION =
                 new RuntimePermission("loggerFinder");
     private static final LoggingPermission LOGGING_CONTROL_PERMISSION =
             new LoggingPermission("control", null);

     /**
      * Creates a new instance of LoggingProviderImpl.
      * @throws SecurityException if the calling code does not have the
      * {@code RuntimePermission("loggerFinder")}.
      */
     public LoggingProviderImpl() {
     }

     /**
      * A logger that delegates to a java.util.logging.Logger delegate.
      */
     static final class JULWrapper extends LoggerConfiguration
             implements System.Logger, PlatformLogger.Bridge,
                        PlatformLogger.ConfigurableBridge {


         private static final java.util.logging.Level[] spi2JulLevelMapping = {
                 java.util.logging.Level.ALL,     // mapped from ALL
                 java.util.logging.Level.FINER,   // mapped from TRACE
                 java.util.logging.Level.FINE,    // mapped from DEBUG
                 java.util.logging.Level.INFO,    // mapped from INFO
                 java.util.logging.Level.WARNING, // mapped from WARNING
                 java.util.logging.Level.SEVERE,  // mapped from ERROR
                 java.util.logging.Level.OFF      // mapped from OFF
         };

         private static final java.util.logging.Level[] platform2JulLevelMapping = {
                 java.util.logging.Level.ALL,     // mapped from ALL
                 java.util.logging.Level.FINEST,  // mapped from FINEST
                 java.util.logging.Level.FINER,   // mapped from FINER
                 java.util.logging.Level.FINE,    // mapped from FINE
                 java.util.logging.Level.CONFIG,  // mapped from CONFIG
                 java.util.logging.Level.INFO,    // mapped from INFO
                 java.util.logging.Level.WARNING, // mapped from WARNING
                 java.util.logging.Level.SEVERE,  // mapped from SEVERE
                 java.util.logging.Level.OFF      // mapped from OFF
         };

         private final java.util.logging.Logger julLogger;


         private JULWrapper(java.util.logging.Logger logger) {
             this.julLogger = logger;
         }

         @Override
         public String getName() {
             return julLogger.getName();
         }
         @Override
         public void log(sun.util.logging.PlatformLogger.Level level, String msg, Throwable throwable) {
             julLogger.log(toJUL(level), msg, throwable);
         }

         @Override
         public void log(sun.util.logging.PlatformLogger.Level level, String format, Object... params) {
             julLogger.log(toJUL(level), format, params);
         }

         @Override
         public void log(sun.util.logging.PlatformLogger.Level level, String msg) {
             julLogger.log(toJUL(level), msg);
         }

         @Override
         public void log(sun.util.logging.PlatformLogger.Level level, Supplier<String> msgSuppier) {
             julLogger.log(toJUL(level), msgSuppier);
         }

         @Override
         public void log(sun.util.logging.PlatformLogger.Level level, Throwable thrown, Supplier<String> msgSuppier) {
             julLogger.log(toJUL(level), thrown, msgSuppier);
         }

         @Override
         public void logrb(sun.util.logging.PlatformLogger.Level level, ResourceBundle bundle, String key, Throwable throwable) {
             julLogger.logrb(toJUL(level), bundle, key, throwable);
         }

         @Override
         public void logrb(sun.util.logging.PlatformLogger.Level level, ResourceBundle bundle, String key, Object... params) {
             julLogger.logrb(toJUL(level), bundle, key, params);
         }

         @Override
         public void logp(sun.util.logging.PlatformLogger.Level level, String sourceClass, String sourceMethod, String msg) {
             julLogger.logp(toJUL(level), sourceClass, sourceMethod, msg);
         }

         @Override
         public void logp(sun.util.logging.PlatformLogger.Level level, String sourceClass, String sourceMethod,
                 Supplier<String> msgSupplier) {
             julLogger.logp(toJUL(level), sourceClass, sourceMethod, msgSupplier);
         }

         @Override
         public void logp(sun.util.logging.PlatformLogger.Level level, String sourceClass, String sourceMethod,
                 String msg, Object... params) {
             julLogger.logp(toJUL(level), sourceClass, sourceMethod, msg, params);
         }

         @Override
         public void logp(sun.util.logging.PlatformLogger.Level level, String sourceClass, String sourceMethod,
                 String msg, Throwable thrown) {
             julLogger.logp(toJUL(level), sourceClass, sourceMethod, msg, thrown);
         }

         @Override
         public void logp(sun.util.logging.PlatformLogger.Level level, String sourceClass, String sourceMethod,
                 Throwable thrown, Supplier<String> msgSupplier) {
             julLogger.logp(toJUL(level), sourceClass, sourceMethod,
                     thrown, msgSupplier);
         }

         @Override
         public void logrb(sun.util.logging.PlatformLogger.Level level, String sourceClass, String sourceMethod,
                 ResourceBundle bundle, String key, Object... params) {
             julLogger.logrb(toJUL(level), sourceClass, sourceMethod,
                     bundle, key, params);
         }

         @Override
         public void logrb(sun.util.logging.PlatformLogger.Level level, String sourceClass, String sourceMethod,
                 ResourceBundle bundle, String key, Throwable thrown) {
             julLogger.logrb(toJUL(level), sourceClass, sourceMethod,
                     bundle, key, thrown);
         }

         @Override
         public  boolean isLoggable(sun.util.logging.PlatformLogger.Level level) {
             return julLogger.isLoggable(toJUL(level));
         }

         // -----------------------------------------------------------------
         // Generic methods taking a Level as parameter
         // -----------------------------------------------------------------


         @Override
         public boolean isLoggable(Level level) {
             return julLogger.isLoggable(toJUL(level));
         }

         @Override
         public void log(Level level, String msg) {
             julLogger.log(toJUL(level), msg);
         }

         @Override
         public void log(Level level,
                         Supplier<String> msgSupplier) {
             // We need to check for null here to satisfy the contract
             // of System.Logger - because the underlying implementation
             // of julLogger will check for it only if the level is
             // loggable
             Objects.requireNonNull(msgSupplier);
             julLogger.log(toJUL(level), msgSupplier);
         }

         @Override
         public void log(Level level, Object obj) {
             // We need to check for null here to satisfy the contract
             // of System.Logger - because the underlying implementation
             // of julLogger will check for it only if the level is
             // loggable
             Objects.requireNonNull(obj);
             julLogger.log(toJUL(level), () -> obj.toString());
         }

         @Override
         public void log(Level level,
                         String msg, Throwable thrown) {
             julLogger.log(toJUL(level), msg, thrown);
         }

         @Override
         public void log(Level level, Supplier<String> msgSupplier,
                         Throwable thrown) {
             // We need to check for null here to satisfy the contract
             // of System.Logger - because the underlying implementation
             // of julLogger will check for it only if the level is
             // loggable
             Objects.requireNonNull(msgSupplier);
             julLogger.log(toJUL(level), thrown, msgSupplier);
         }

         @Override
         public void log(Level level,
                         String format, Object... params) {
             julLogger.log(toJUL(level), format, params);
         }

         @Override
         public void log(Level level, ResourceBundle bundle,
                         String key, Throwable thrown) {
             julLogger.logrb(toJUL(level), bundle, key, thrown);
         }

         @Override
         public void log(Level level, ResourceBundle bundle,
                         String format, Object... params) {
             julLogger.logrb(toJUL(level), bundle, format, params);
         }

         static java.util.logging.Level toJUL(Level level) {
             if (level == null) return null;
             assert level.ordinal() < spi2JulLevelMapping.length;
             return spi2JulLevelMapping[level.ordinal()];
         }

         // ---------------------------------------------------------
         // Methods from PlatformLogger.Bridge
         // ---------------------------------------------------------

         @Override
         public boolean isEnabled() {
             return julLogger.getLevel() != java.util.logging.Level.OFF;
         }

         @Override
         public PlatformLogger.Level getPlatformLevel() {
             final java.util.logging.Level javaLevel = julLogger.getLevel();
             if (javaLevel == null) return null;
             try {
                 return PlatformLogger.Level.valueOf(javaLevel.getName());
             } catch (IllegalArgumentException e) {
                 return PlatformLogger.Level.valueOf(javaLevel.intValue());
             }
         }

         @Override
         public void setPlatformLevel(PlatformLogger.Level level) {
             // null is allowed here
             julLogger.setLevel(toJUL(level));
         }

         @Override
         public LoggerConfiguration getLoggerConfiguration() {
             return this;
         }

         static java.util.logging.Level toJUL(PlatformLogger.Level level) {
             // The caller will throw if null is invalid in its context.
             // There's at least one case where a null level is valid.
             if (level == null) return null;
             assert level.ordinal() < platform2JulLevelMapping.length;
             return platform2JulLevelMapping[level.ordinal()];
         }

         @Override
         public boolean equals(Object obj) {
             return (obj instanceof JULWrapper)
                     && obj.getClass() == this.getClass()
                     && ((JULWrapper)obj).julLogger == this.julLogger;
         }

         @Override
         public int hashCode() {
             return julLogger.hashCode();
         }

         // A JULWrapper is just a stateless thin shell over a JUL logger - so
         // for a given JUL logger, we could always return the same wrapper.
         //
         // This is an optimization which may - or may not - be worth the
         // trouble: if many classes use the same logger, and if each class
         // keeps a reference to that logger, then caching the wrapper will
         // be worthwhile. Otherwise, if each logger is only referred once,
         // then the cache will eat up more memory than would be necessary...
         //
         // Here is an example of how we could implement JULWrapper.of(...)
         // if we wanted to create at most one wrapper instance for each logger
         // instance:
         //
         //        static final WeakHashMap<JULWrapper, WeakReference<JULWrapper>>
         //                wrappers = new WeakHashMap<>();
         //
         //        static JULWrapper of(java.util.logging.Logger logger) {
         //
         //            // First access without synchronizing
         //            final JULWrapper candidate = new JULWrapper(logger);
         //            WeakReference<JULWrapper> ref = wrappers.get(candidate);
         //            JULWrapper found = ref.get();
         //
         //            // OK - we found it - lets return it.
         //            if (found != null) return found;
         //
         //            // Not found. Need to synchronize.
         //            synchronized (wrappers) {
         //                ref = wrappers.get(candidate);
         //                found = ref.get();
         //                if (found == null) {
         //                    wrappers.put(candidate, new WeakReference<>(candidate));
         //                    found = candidate;
         //                }
         //            }
         //            assert found != null;
         //            return found;
         //        }
         //
         // But given that it may end up eating more memory in the nominal case
         // (where each class that does logging has its own logger with the
         //  class name as logger name and stashes that logger away in a static
         //  field, thus making the cache redundant - as only one wrapper will
         //  ever be created anyway) - then we will simply return a new wrapper
         // for each invocation of JULWrapper.of(...) - which may
         // still prove more efficient in terms of memory consumption...
         //
         static JULWrapper of(java.util.logging.Logger logger) {
             return new JULWrapper(logger);
         }


     }

     /**
      * Creates a java.util.logging.Logger for the given module.
      * @param name the logger name.
      * @param module the module for which the logger should be created.
      * @return a Logger suitable for use in the given module.
      */
     private static java.util.logging.Logger demandJULLoggerFor(final String name,
                                                                Module module) {
         final LogManager manager = LogManager.getLogManager();
         final SecurityManager sm = System.getSecurityManager();
         if (sm == null) {
             return logManagerAccess.demandLoggerFor(manager, name, module);
         } else {
             final PrivilegedAction<java.util.logging.Logger> pa =
                     () -> logManagerAccess.demandLoggerFor(manager, name, module);
             return AccessController.doPrivileged(pa, null, LOGGING_CONTROL_PERMISSION);
         }
     }

     /**
      * {@inheritDoc}
      *
      * @apiNote The logger returned by this method can be configured through
      * its {@linkplain java.util.logging.LogManager#getLogger(String)
      * corresponding java.util.logging.Logger backend}.
      *
      * @return {@inheritDoc}
      * @throws SecurityException if the calling code doesn't have the
      * {@code RuntimePermission("loggerFinder")}.
      */
     @Override
     protected Logger demandLoggerFor(String name, Module module) {
         final SecurityManager sm = System.getSecurityManager();
         if (sm != null) {
             sm.checkPermission(LOGGERFINDER_PERMISSION);
         }
         return JULWrapper.of(demandJULLoggerFor(name,module));
     }

     public static interface LogManagerAccess {
         java.util.logging.Logger demandLoggerFor(LogManager manager,
                 String name, Module module);
     }

     // Hook for tests
     public static LogManagerAccess getLogManagerAccess() {
         final SecurityManager sm = System.getSecurityManager();
         if (sm != null) {
             sm.checkPermission(LOGGING_CONTROL_PERMISSION);
         }
         // Triggers initialization of accessJulLogger if not set.
         if (logManagerAccess == null) LogManager.getLogManager();
         return logManagerAccess;
     }


     private static volatile LogManagerAccess logManagerAccess;
     public static void setLogManagerAccess(LogManagerAccess accesLoggers) {
         final SecurityManager sm = System.getSecurityManager();
         if (sm != null) {
             sm.checkPermission(LOGGING_CONTROL_PERMISSION);
         }
         logManagerAccess = accesLoggers;
     }

 }
	/*
	* Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved.
	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	*
	* This code is free software; you can redistribute it and/or modify it
	* under the terms of the GNU General Public License version 2 only, as
	* published by the Free Software Foundation. Oracle designates this
	* particular file as subject to the "Classpath" exception as provided
	* by Oracle in the LICENSE file that accompanied this code.
	*
	* This code is distributed in the hope that it will be useful, but WITHOUT
	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	* version 2 for more details (a copy is included in the LICENSE file that
	* accompanied this code).
	*
	* You should have received a copy of the GNU General Public License version
	* 2 along with this work; if not, write to the Free Software Foundation,
	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	*
	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	* or visit www.oracle.com if you need additional information or have any
	* questions.
	*/


	package sun.util.logging.internal;

	import java.security.AccessController;
	import java.security.PrivilegedAction;
	import java.util.ResourceBundle;
	import java.util.function.Supplier;
	import java.lang.System.LoggerFinder;
	import java.lang.System.Logger;
	import java.util.Objects;
	import java.util.logging.LogManager;
	import jdk.internal.logger.DefaultLoggerFinder;
	import java.util.logging.LoggingPermission;
	import sun.util.logging.PlatformLogger;
	import sun.util.logging.PlatformLogger.ConfigurableBridge.LoggerConfiguration;

	/**
	* This {@code LoggingProviderImpl} is the JDK internal implementation of the
	* {@link jdk.internal.logger.DefaultLoggerFinder} which is used by
	* the default implementation of the {@link Logger}
	* when no {@link LoggerFinder} is found
	* and {@code java.util.logging} is present.
	* When {@code java.util.logging} is present, the {@code LoggingProviderImpl}
	* is {@linkplain java.util.ServiceLoader#loadInstalled(Class) installed} as
	* an internal service provider, making it possible to use {@code java.util.logging}
	* as the backend for loggers returned by the default LoggerFinder implementation.
	* <p>
	* This implementation of {@link DefaultLoggerFinder} returns instances of
	* {@link java.lang.System.Logger} which
	* delegate to a wrapped instance of {@link java.util.logging.Logger
	* java.util.logging.Logger}.
	* <br>
	* Loggers returned by this class can therefore be configured by accessing
	* their wrapped implementation through the regular {@code java.util.logging}
	* APIs - such as {@link java.util.logging.LogManager java.util.logging.LogManager}
	* and {@link java.util.logging.Logger java.util.logging.Logger}.
	*
	* @apiNote Programmers are not expected to call this class directly.
	* Instead they should rely on the static methods defined by
	* {@link java.lang.System java.lang.System}.
	* <p>
	* To replace this default
	* {@code java.util.logging} backend, an application is expected to install
	* its own {@link java.lang.System.LoggerFinder}.
	*
	* @see java.lang.System.Logger
	* @see java.lang.System.LoggerFinder
	* @see sun.util.logging.PlatformLogger.Bridge
	* @see java.lang.System
	* @see jdk.internal.logger
	* @see jdk.internal.logger
	*
	*/
	public final class LoggingProviderImpl extends DefaultLoggerFinder {
	static final RuntimePermission LOGGERFINDER_PERMISSION =
	new RuntimePermission("loggerFinder");
	private static final LoggingPermission LOGGING_CONTROL_PERMISSION =
	new LoggingPermission("control", null);

	/**
	* Creates a new instance of LoggingProviderImpl.
	* @throws SecurityException if the calling code does not have the
	* {@code RuntimePermission("loggerFinder")}.
	*/
	public LoggingProviderImpl() {
	}

	/**
	* A logger that delegates to a java.util.logging.Logger delegate.
	*/
	static final class JULWrapper extends LoggerConfiguration
	implements System.Logger, PlatformLogger.Bridge,
	PlatformLogger.ConfigurableBridge {


	private static final java.util.logging.Level[] spi2JulLevelMapping = {
	java.util.logging.Level.ALL, // mapped from ALL
	java.util.logging.Level.FINER, // mapped from TRACE
	java.util.logging.Level.FINE, // mapped from DEBUG
	java.util.logging.Level.INFO, // mapped from INFO
	java.util.logging.Level.WARNING, // mapped from WARNING
	java.util.logging.Level.SEVERE, // mapped from ERROR
	java.util.logging.Level.OFF // mapped from OFF
	};

	private static final java.util.logging.Level[] platform2JulLevelMapping = {
	java.util.logging.Level.ALL, // mapped from ALL
	java.util.logging.Level.FINEST, // mapped from FINEST
	java.util.logging.Level.FINER, // mapped from FINER
	java.util.logging.Level.FINE, // mapped from FINE
	java.util.logging.Level.CONFIG, // mapped from CONFIG
	java.util.logging.Level.INFO, // mapped from INFO
	java.util.logging.Level.WARNING, // mapped from WARNING
	java.util.logging.Level.SEVERE, // mapped from SEVERE
	java.util.logging.Level.OFF // mapped from OFF
	};

	private final java.util.logging.Logger julLogger;


	private JULWrapper(java.util.logging.Logger logger) {
	this.julLogger = logger;
	}

	@Override
	public String getName() {
	return julLogger.getName();
	}
	@Override
	public void log(sun.util.logging.PlatformLogger.Level level, String msg, Throwable throwable) {
	julLogger.log(toJUL(level), msg, throwable);
	}

	@Override
	public void log(sun.util.logging.PlatformLogger.Level level, String format, Object... params) {
	julLogger.log(toJUL(level), format, params);
	}

	@Override
	public void log(sun.util.logging.PlatformLogger.Level level, String msg) {
	julLogger.log(toJUL(level), msg);
	}

	@Override
	public void log(sun.util.logging.PlatformLogger.Level level, Supplier<String> msgSuppier) {
	julLogger.log(toJUL(level), msgSuppier);
	}

	@Override
	public void log(sun.util.logging.PlatformLogger.Level level, Throwable thrown, Supplier<String> msgSuppier) {
	julLogger.log(toJUL(level), thrown, msgSuppier);
	}

	@Override
	public void logrb(sun.util.logging.PlatformLogger.Level level, ResourceBundle bundle, String key, Throwable throwable) {
	julLogger.logrb(toJUL(level), bundle, key, throwable);
	}

	@Override
	public void logrb(sun.util.logging.PlatformLogger.Level level, ResourceBundle bundle, String key, Object... params) {
	julLogger.logrb(toJUL(level), bundle, key, params);
	}

	@Override
	public void logp(sun.util.logging.PlatformLogger.Level level, String sourceClass, String sourceMethod, String msg) {
	julLogger.logp(toJUL(level), sourceClass, sourceMethod, msg);
	}

	@Override
	public void logp(sun.util.logging.PlatformLogger.Level level, String sourceClass, String sourceMethod,
	Supplier<String> msgSupplier) {
	julLogger.logp(toJUL(level), sourceClass, sourceMethod, msgSupplier);
	}

	@Override
	public void logp(sun.util.logging.PlatformLogger.Level level, String sourceClass, String sourceMethod,
	String msg, Object... params) {
	julLogger.logp(toJUL(level), sourceClass, sourceMethod, msg, params);
	}

	@Override
	public void logp(sun.util.logging.PlatformLogger.Level level, String sourceClass, String sourceMethod,
	String msg, Throwable thrown) {
	julLogger.logp(toJUL(level), sourceClass, sourceMethod, msg, thrown);
	}

	@Override
	public void logp(sun.util.logging.PlatformLogger.Level level, String sourceClass, String sourceMethod,
	Throwable thrown, Supplier<String> msgSupplier) {
	julLogger.logp(toJUL(level), sourceClass, sourceMethod,
	thrown, msgSupplier);
	}

	@Override
	public void logrb(sun.util.logging.PlatformLogger.Level level, String sourceClass, String sourceMethod,
	ResourceBundle bundle, String key, Object... params) {
	julLogger.logrb(toJUL(level), sourceClass, sourceMethod,
	bundle, key, params);
	}

	@Override
	public void logrb(sun.util.logging.PlatformLogger.Level level, String sourceClass, String sourceMethod,
	ResourceBundle bundle, String key, Throwable thrown) {
	julLogger.logrb(toJUL(level), sourceClass, sourceMethod,
	bundle, key, thrown);
	}

	@Override
	public boolean isLoggable(sun.util.logging.PlatformLogger.Level level) {
	return julLogger.isLoggable(toJUL(level));
	}

	// -----------------------------------------------------------------
	// Generic methods taking a Level as parameter
	// -----------------------------------------------------------------


	@Override
	public boolean isLoggable(Level level) {
	return julLogger.isLoggable(toJUL(level));
	}

	@Override
	public void log(Level level, String msg) {
	julLogger.log(toJUL(level), msg);
	}

	@Override
	public void log(Level level,
	Supplier<String> msgSupplier) {
	// We need to check for null here to satisfy the contract
	// of System.Logger - because the underlying implementation
	// of julLogger will check for it only if the level is
	// loggable
	Objects.requireNonNull(msgSupplier);
	julLogger.log(toJUL(level), msgSupplier);
	}

	@Override
	public void log(Level level, Object obj) {
	// We need to check for null here to satisfy the contract
	// of System.Logger - because the underlying implementation
	// of julLogger will check for it only if the level is
	// loggable
	Objects.requireNonNull(obj);
	julLogger.log(toJUL(level), () -> obj.toString());
	}

	@Override
	public void log(Level level,
	String msg, Throwable thrown) {
	julLogger.log(toJUL(level), msg, thrown);
	}

	@Override
	public void log(Level level, Supplier<String> msgSupplier,
	Throwable thrown) {
	// We need to check for null here to satisfy the contract
	// of System.Logger - because the underlying implementation
	// of julLogger will check for it only if the level is
	// loggable
	Objects.requireNonNull(msgSupplier);
	julLogger.log(toJUL(level), thrown, msgSupplier);
	}

	@Override
	public void log(Level level,
	String format, Object... params) {
	julLogger.log(toJUL(level), format, params);
	}

	@Override
	public void log(Level level, ResourceBundle bundle,
	String key, Throwable thrown) {
	julLogger.logrb(toJUL(level), bundle, key, thrown);
	}

	@Override
	public void log(Level level, ResourceBundle bundle,
	String format, Object... params) {
	julLogger.logrb(toJUL(level), bundle, format, params);
	}

	static java.util.logging.Level toJUL(Level level) {
	if (level == null) return null;
	assert level.ordinal() < spi2JulLevelMapping.length;
	return spi2JulLevelMapping[level.ordinal()];
	}

	// ---------------------------------------------------------
	// Methods from PlatformLogger.Bridge
	// ---------------------------------------------------------

	@Override
	public boolean isEnabled() {
	return julLogger.getLevel() != java.util.logging.Level.OFF;
	}

	@Override
	public PlatformLogger.Level getPlatformLevel() {
	final java.util.logging.Level javaLevel = julLogger.getLevel();
	if (javaLevel == null) return null;
	try {
	return PlatformLogger.Level.valueOf(javaLevel.getName());
	} catch (IllegalArgumentException e) {
	return PlatformLogger.Level.valueOf(javaLevel.intValue());
	}
	}

	@Override
	public void setPlatformLevel(PlatformLogger.Level level) {
	// null is allowed here
	julLogger.setLevel(toJUL(level));
	}

	@Override
	public LoggerConfiguration getLoggerConfiguration() {
	return this;
	}

	static java.util.logging.Level toJUL(PlatformLogger.Level level) {
	// The caller will throw if null is invalid in its context.
	// There's at least one case where a null level is valid.
	if (level == null) return null;
	assert level.ordinal() < platform2JulLevelMapping.length;
	return platform2JulLevelMapping[level.ordinal()];
	}

	@Override
	public boolean equals(Object obj) {
	return (obj instanceof JULWrapper)
	&& obj.getClass() == this.getClass()
	&& ((JULWrapper)obj).julLogger == this.julLogger;
	}

	@Override
	public int hashCode() {
	return julLogger.hashCode();
	}

	// A JULWrapper is just a stateless thin shell over a JUL logger - so
	// for a given JUL logger, we could always return the same wrapper.
	//
	// This is an optimization which may - or may not - be worth the
	// trouble: if many classes use the same logger, and if each class
	// keeps a reference to that logger, then caching the wrapper will
	// be worthwhile. Otherwise, if each logger is only referred once,
	// then the cache will eat up more memory than would be necessary...
	//
	// Here is an example of how we could implement JULWrapper.of(...)
	// if we wanted to create at most one wrapper instance for each logger
	// instance:
	//
	// static final WeakHashMap<JULWrapper, WeakReference<JULWrapper>>
	// wrappers = new WeakHashMap<>();
	//
	// static JULWrapper of(java.util.logging.Logger logger) {
	//
	// // First access without synchronizing
	// final JULWrapper candidate = new JULWrapper(logger);
	// WeakReference<JULWrapper> ref = wrappers.get(candidate);
	// JULWrapper found = ref.get();
	//
	// // OK - we found it - lets return it.
	// if (found != null) return found;
	//
	// // Not found. Need to synchronize.
	// synchronized (wrappers) {
	// ref = wrappers.get(candidate);
	// found = ref.get();
	// if (found == null) {
	// wrappers.put(candidate, new WeakReference<>(candidate));
	// found = candidate;
	// }
	// }
	// assert found != null;
	// return found;
	// }
	//
	// But given that it may end up eating more memory in the nominal case
	// (where each class that does logging has its own logger with the
	// class name as logger name and stashes that logger away in a static
	// field, thus making the cache redundant - as only one wrapper will
	// ever be created anyway) - then we will simply return a new wrapper
	// for each invocation of JULWrapper.of(...) - which may
	// still prove more efficient in terms of memory consumption...
	//
	static JULWrapper of(java.util.logging.Logger logger) {
	return new JULWrapper(logger);
	}


	}

	/**
	* Creates a java.util.logging.Logger for the given module.
	* @param name the logger name.
	* @param module the module for which the logger should be created.
	* @return a Logger suitable for use in the given module.
	*/
	private static java.util.logging.Logger demandJULLoggerFor(final String name,
	Module module) {
	final LogManager manager = LogManager.getLogManager();
	final SecurityManager sm = System.getSecurityManager();
	if (sm == null) {
	return logManagerAccess.demandLoggerFor(manager, name, module);
	} else {
	final PrivilegedAction<java.util.logging.Logger> pa =
	() -> logManagerAccess.demandLoggerFor(manager, name, module);
	return AccessController.doPrivileged(pa, null, LOGGING_CONTROL_PERMISSION);
	}
	}

	/**
	* {@inheritDoc}
	*
	* @apiNote The logger returned by this method can be configured through
	* its {@linkplain java.util.logging.LogManager#getLogger(String)
	* corresponding java.util.logging.Logger backend}.
	*
	* @return {@inheritDoc}
	* @throws SecurityException if the calling code doesn't have the
	* {@code RuntimePermission("loggerFinder")}.
	*/
	@Override
	protected Logger demandLoggerFor(String name, Module module) {
	final SecurityManager sm = System.getSecurityManager();
	if (sm != null) {
	sm.checkPermission(LOGGERFINDER_PERMISSION);
	}
	return JULWrapper.of(demandJULLoggerFor(name,module));
	}

	public static interface LogManagerAccess {
	java.util.logging.Logger demandLoggerFor(LogManager manager,
	String name, Module module);
	}

	// Hook for tests
	public static LogManagerAccess getLogManagerAccess() {
	final SecurityManager sm = System.getSecurityManager();
	if (sm != null) {
	sm.checkPermission(LOGGING_CONTROL_PERMISSION);
	}
	// Triggers initialization of accessJulLogger if not set.
	if (logManagerAccess == null) LogManager.getLogManager();
	return logManagerAccess;
	}


	private static volatile LogManagerAccess logManagerAccess;
	public static void setLogManagerAccess(LogManagerAccess accesLoggers) {
	final SecurityManager sm = System.getSecurityManager();
	if (sm != null) {
	sm.checkPermission(LOGGING_CONTROL_PERMISSION);
	}
	logManagerAccess = accesLoggers;
	}

	}