gt:         return platformProxy == null ? null
context: /*
   * 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 jdk.internal.logger;
  
  import java.util.ResourceBundle;
  import java.util.function.Supplier;
  import java.lang.System.Logger;
  import java.lang.System.Logger.Level;
  import sun.util.logging.PlatformLogger;
  
  /**
   * An implementation of {@link System.Logger System.Logger}
   * that redirects all calls to a wrapped instance of {@link
   * System.Logger System.Logger}
   *
   * @param <L> Type of the wrapped Logger: {@code Logger} or
   *        an extension of that interface.
   *
   */
  abstract class AbstractLoggerWrapper<L extends Logger>
      implements Logger, PlatformLogger.Bridge, PlatformLogger.ConfigurableBridge {
  
      AbstractLoggerWrapper() { }
  
      abstract L wrapped();
  
      abstract PlatformLogger.Bridge platformProxy();
  
      L getWrapped() {
          return wrapped();
      }
  
      @Override
      public final String getName() {
          return wrapped().getName();
      }
  
      // -----------------------------------------------------------------
      // Generic methods taking a Level as parameter
      // -----------------------------------------------------------------
  
  
      @Override
      public boolean isLoggable(Level level) {
          return wrapped().isLoggable(level);
      }
  
      @Override
      public void log(Level level, String msg) {
          wrapped().log(level, msg);
      }
  
      @Override
      public void log(Level level,
                      Supplier<String> msgSupplier) {
          wrapped().log(level, msgSupplier);
      }
  
      @Override
      public void log(Level level, Object obj) {
          wrapped().log(level, obj);
      }
  
      @Override
      public void log(Level level,
                     String msg, Throwable thrown) {
          wrapped().log(level, msg, thrown);
      }
  
      @Override
      public void log(Level level, Supplier<String> msgSupplier, Throwable thrown) {
          wrapped().log(level, msgSupplier, thrown);
      }
  
      @Override
      public void log(Level level,
                      String format, Object... params) {
          wrapped().log(level, format, params);
      }
  
      @Override
      public void log(Level level, ResourceBundle bundle,
                      String key, Throwable thrown) {
          wrapped().log(level, bundle, key, thrown);
      }
  
      @Override
      public void log(Level level, ResourceBundle bundle,
                      String format, Object... params) {
          wrapped().log(level, bundle, format, params);
      }
  
      // ---------------------------------------------------------
      // Methods from PlatformLogger.Bridge
      // ---------------------------------------------------------
  
      @Override
      public boolean isLoggable(PlatformLogger.Level level) {
          final PlatformLogger.Bridge platformProxy = platformProxy();
          if (platformProxy == null) return isLoggable(level.systemLevel());
          else return platformProxy.isLoggable(level);
      }
  
      @Override
      public boolean isEnabled() {
          final PlatformLogger.Bridge platformProxy = platformProxy();
          return platformProxy == null || platformProxy.isEnabled();
      }
  
      @Override
      public void log(PlatformLogger.Level level, String msg) {
          final PlatformLogger.Bridge platformProxy = platformProxy();
          if (platformProxy == null)  {
              wrapped().log(level.systemLevel(), msg);
          } else {
              platformProxy.log(level, msg);
          }
      }
  
      @Override
      public void log(PlatformLogger.Level level, String msg, Throwable thrown) {
          final PlatformLogger.Bridge platformProxy = platformProxy();
          if (platformProxy == null)  {
              wrapped().log(level.systemLevel(), msg, thrown);
          } else {
              platformProxy.log(level, msg, thrown);
          }
      }
  
      @Override
      public void log(PlatformLogger.Level level, String msg, Object... params) {
          final PlatformLogger.Bridge platformProxy = platformProxy();
          if (platformProxy == null)  {
              wrapped().log(level.systemLevel(), msg, params);
          } else {
              platformProxy.log(level, msg, params);
          }
      }
  
      @Override
      public void log(PlatformLogger.Level level, Supplier<String> msgSupplier) {
          final PlatformLogger.Bridge platformProxy = platformProxy();
          if (platformProxy == null)  {
              wrapped().log(level.systemLevel(),msgSupplier);
          } else {
              platformProxy.log(level,msgSupplier);
          }
      }
  
      @Override
      public void log(PlatformLogger.Level level, Throwable thrown,
                      Supplier<String> msgSupplier) {
          final PlatformLogger.Bridge platformProxy = platformProxy();
          if (platformProxy == null)  {
              wrapped().log(level.systemLevel(), msgSupplier, thrown);
          } else {
              platformProxy.log(level, thrown, msgSupplier);
          }
      }
  
      @Override
      public void logp(PlatformLogger.Level level, String sourceClass,
                       String sourceMethod, String msg) {
          final PlatformLogger.Bridge platformProxy = platformProxy();
          if (platformProxy == null)  {
              if (sourceClass == null && sourceMethod == null) { // best effort
                  wrapped().log(level.systemLevel(), msg);
              } else {
                  Level systemLevel = level.systemLevel();
                  Logger wrapped = wrapped();
                  if (wrapped.isLoggable(systemLevel)) {
                      sourceClass  = sourceClass  == null ? "" : sourceClass;
                      sourceMethod = sourceMethod == null ? "" : sourceMethod;
                      msg = msg == null ? "" : msg;
                      wrapped.log(systemLevel, String.format("[%s %s] %s",
                              sourceClass, sourceMethod, msg));
                  }
              }
          } else {
              platformProxy.logp(level, sourceClass, sourceMethod, msg);
          }
      }
  
      @Override
      public void logp(PlatformLogger.Level level, String sourceClass,
                       String sourceMethod, Supplier<String> msgSupplier) {
          final PlatformLogger.Bridge platformProxy = platformProxy();
          if (platformProxy == null) { // best effort
              if (sourceClass == null && sourceMethod == null) {
                  wrapped().log(level.systemLevel(), msgSupplier);
              } else {
                  Level systemLevel = level.systemLevel();
                  Logger wrapped = wrapped();
                  if (wrapped.isLoggable(systemLevel)) {
                      final String sClass  = sourceClass  == null ? "" : sourceClass;
                      final String sMethod = sourceMethod == null ? "" : sourceMethod;
                      wrapped.log(systemLevel, () -> String.format("[%s %s] %s",
                              sClass, sMethod, msgSupplier.get()));
                  }
              }
          } else {
              platformProxy.logp(level, sourceClass, sourceMethod, msgSupplier);
          }
      }
  
      @Override
      public void logp(PlatformLogger.Level level, String sourceClass,
                       String sourceMethod, String msg, Object... params) {
          final PlatformLogger.Bridge platformProxy = platformProxy();
          if (platformProxy == null) { // best effort
              if (sourceClass == null && sourceMethod == null) {
                  wrapped().log(level.systemLevel(), msg, params);
              } else {
                  Level systemLevel = level.systemLevel();
                  Logger wrapped = wrapped();
                  if (wrapped.isLoggable(systemLevel)) {
                      sourceClass  = sourceClass  == null ? "" : sourceClass;
                      sourceMethod = sourceMethod == null ? "" : sourceMethod;
                      msg = msg == null ? "" : msg;
                      wrapped.log(systemLevel, String.format("[%s %s] %s",
                              sourceClass, sourceMethod, msg), params);
                  }
              }
          } else {
              platformProxy.logp(level, sourceClass, sourceMethod, msg, params);
          }
      }
  
      @Override
      public void logp(PlatformLogger.Level level, String sourceClass,
                       String sourceMethod, String msg, Throwable thrown) {
          final PlatformLogger.Bridge platformProxy = platformProxy();
          if (platformProxy == null) { // best effort
              if (sourceClass == null && sourceMethod == null) {
                  wrapped().log(level.systemLevel(), msg, thrown);
              } else {
                  Level systemLevel = level.systemLevel();
                  Logger wrapped = wrapped();
                  if (wrapped.isLoggable(systemLevel)) {
                      sourceClass  = sourceClass  == null ? "" : sourceClass;
                      sourceMethod = sourceMethod == null ? "" : sourceMethod;
                      msg = msg == null ? "" : msg;
                      wrapped.log(systemLevel, String.format("[%s %s] %s",
                              sourceClass, sourceMethod, msg), thrown);
                  }
              }
          } else {
              platformProxy.logp(level, sourceClass, sourceMethod, msg, thrown);
          }
      }
  
      @Override
      public void logp(PlatformLogger.Level level, String sourceClass,
                       String sourceMethod, Throwable thrown,
                       Supplier<String> msgSupplier) {
          final PlatformLogger.Bridge platformProxy = platformProxy();
          if (platformProxy == null)  { // best effort
              if (sourceClass == null && sourceMethod == null) {
                  wrapped().log(level.systemLevel(), msgSupplier, thrown);
              } else {
                  Level systemLevel = level.systemLevel();
                  Logger wrapped = wrapped();
                  if (wrapped.isLoggable(systemLevel)) {
                      final String sClass  = sourceClass  == null ? "" : sourceClass;
                      final String sMethod = sourceMethod == null ? "" : sourceMethod;
                      wrapped.log(systemLevel,  () -> String.format("[%s %s] %s",
                              sClass, sMethod, msgSupplier.get()), thrown);
                  }
              }
          } else {
              platformProxy.logp(level, sourceClass, sourceMethod,
                                 thrown, msgSupplier);
          }
      }
  
      @Override
      public void logrb(PlatformLogger.Level level, String sourceClass,
                        String sourceMethod, ResourceBundle bundle,
                        String msg, Object... params) {
          final PlatformLogger.Bridge platformProxy = platformProxy();
          if (platformProxy == null)  { // best effort
              if (bundle != null || sourceClass == null && sourceMethod == null) {
                  wrapped().log(level.systemLevel(), bundle, msg, params);
              } else {
                  Level systemLevel = level.systemLevel();
                  Logger wrapped = wrapped();
                  if (wrapped.isLoggable(systemLevel)) {
                      sourceClass  = sourceClass  == null ? "" : sourceClass;
                      sourceMethod = sourceMethod == null ? "" : sourceMethod;
                      msg = msg == null ? "" : msg;
                      wrapped.log(systemLevel, bundle, String.format("[%s %s] %s",
                              sourceClass, sourceMethod, msg), params);
                  }
              }
          } else {
              platformProxy.logrb(level, sourceClass, sourceMethod,
                      bundle, msg, params);
          }
      }
  
      @Override
      public void logrb(PlatformLogger.Level level, String sourceClass,
                        String sourceMethod, ResourceBundle bundle, String msg,
                        Throwable thrown) {
          final PlatformLogger.Bridge platformProxy = platformProxy();
          if (platformProxy == null)  { // best effort
              if (bundle != null || sourceClass == null && sourceMethod == null) {
                  wrapped().log(level.systemLevel(), bundle, msg, thrown);
              } else {
                  Level systemLevel = level.systemLevel();
                  Logger wrapped = wrapped();
                  if (wrapped.isLoggable(systemLevel)) {
                      sourceClass  = sourceClass  == null ? "" : sourceClass;
                      sourceMethod = sourceMethod == null ? "" : sourceMethod;
                      msg = msg == null ? "" : msg;
                      wrapped.log(systemLevel, bundle, String.format("[%s %s] %s",
                              sourceClass, sourceMethod, msg), thrown);
                  }
              }
          } else {
              platformProxy.logrb(level, sourceClass, sourceMethod, bundle,
                                  msg, thrown);
          }
      }
  
      @Override
      public void logrb(PlatformLogger.Level level, ResourceBundle bundle,
                        String msg, Throwable thrown) {
          final PlatformLogger.Bridge platformProxy = platformProxy();
          if (platformProxy == null)  {
              wrapped().log(level.systemLevel(), bundle, msg, thrown);
          } else {
              platformProxy.logrb(level, bundle, msg, thrown);
          }
      }
  
      @Override
      public void logrb(PlatformLogger.Level level, ResourceBundle bundle,
                        String msg, Object... params) {
          final PlatformLogger.Bridge platformProxy = platformProxy();
          if (platformProxy == null)  {
              wrapped().log(level.systemLevel(), bundle, msg, params);
          } else {
              platformProxy.logrb(level, bundle, msg, params);
          }
      }
  
  
      @Override
      public LoggerConfiguration getLoggerConfiguration() {
          final PlatformLogger.Bridge platformProxy = platformProxy();
  