org.argeo.api.cms/src/org/argeo/api/cms/CmsLog.java

   1 package org.argeo.api.cms;
   2
   3 import java.lang.System.Logger;
   4 import java.lang.System.Logger.Level;
   5 import java.util.Objects;
   6 import java.util.function.Supplier;
   7
   8 /**
   9  * A Commons Logging / SLF4J style logging utilities wrapping a standard Java
  10  * platform {@link Logger}.
  11  */
  12 public interface CmsLog {
  13         Logger getLogger();
  14
  15         default boolean isDebugEnabled() {
  16                 return getLogger().isLoggable(Level.DEBUG);
  17         }
  18
  19         default boolean isErrorEnabled() {
  20                 return getLogger().isLoggable(Level.ERROR);
  21         }
  22
  23         default boolean isInfoEnabled() {
  24                 return getLogger().isLoggable(Level.INFO);
  25         }
  26
  27         default boolean isTraceEnabled() {
  28                 return getLogger().isLoggable(Level.TRACE);
  29         }
  30
  31         default boolean isWarnEnabled() {
  32                 return getLogger().isLoggable(Level.WARNING);
  33         }
  34
  35         /*
  36          * TRACE
  37          */
  38
  39         default void trace(String message) {
  40                 getLogger().log(Level.TRACE, message);
  41         }
  42
  43         default void trace(Supplier<String> message) {
  44                 getLogger().log(Level.TRACE, message);
  45         }
  46
  47         default void trace(Object message) {
  48                 getLogger().log(Level.TRACE, Objects.requireNonNull(message));
  49         }
  50
  51         default void trace(String message, Throwable t) {
  52                 getLogger().log(Level.TRACE, message, t);
  53         }
  54
  55         default void trace(Object message, Throwable t) {
  56                 trace(Objects.requireNonNull(message).toString(), t);
  57         }
  58
  59         default void trace(String format, Object... arguments) {
  60                 getLogger().log(Level.TRACE, format, arguments);
  61         }
  62
  63         /*
  64          * DEBUG
  65          */
  66
  67         default void debug(String message) {
  68                 getLogger().log(Level.DEBUG, message);
  69         }
  70
  71         default void debug(Supplier<String> message) {
  72                 getLogger().log(Level.DEBUG, message);
  73         }
  74
  75         default void debug(Object message) {
  76                 getLogger().log(Level.DEBUG, message);
  77         }
  78
  79         default void debug(String message, Throwable t) {
  80                 getLogger().log(Level.DEBUG, message, t);
  81         }
  82
  83         default void debug(Object message, Throwable t) {
  84                 debug(Objects.requireNonNull(message).toString(), t);
  85         }
  86
  87         default void debug(String format, Object... arguments) {
  88                 getLogger().log(Level.DEBUG, format, arguments);
  89         }
  90
  91         /*
  92          * INFO
  93          */
  94
  95         default void info(String message) {
  96                 getLogger().log(Level.INFO, message);
  97         }
  98
  99         default void info(Supplier<String> message) {
 100                 getLogger().log(Level.INFO, message);
 101         }
 102
 103         default void info(Object message) {
 104                 getLogger().log(Level.INFO, message);
 105         }
 106
 107         default void info(String message, Throwable t) {
 108                 getLogger().log(Level.INFO, message, t);
 109         }
 110
 111         default void info(Object message, Throwable t) {
 112                 info(Objects.requireNonNull(message).toString(), t);
 113         }
 114
 115         default void info(String format, Object... arguments) {
 116                 getLogger().log(Level.INFO, format, arguments);
 117         }
 118
 119         /*
 120          * WARN
 121          */
 122
 123         default void warn(String message) {
 124                 getLogger().log(Level.WARNING, message);
 125         }
 126
 127         default void warn(Supplier<String> message) {
 128                 getLogger().log(Level.WARNING, message);
 129         }
 130
 131         default void warn(Object message) {
 132                 getLogger().log(Level.WARNING, message);
 133         }
 134
 135         default void warn(String message, Throwable t) {
 136                 getLogger().log(Level.WARNING, message, t);
 137         }
 138
 139         default void warn(Object message, Throwable t) {
 140                 warn(Objects.requireNonNull(message).toString(), t);
 141         }
 142
 143         default void warn(String format, Object... arguments) {
 144                 getLogger().log(Level.WARNING, format, arguments);
 145         }
 146
 147         /*
 148          * ERROR
 149          */
 150
 151         default void error(String message) {
 152                 getLogger().log(Level.ERROR, message);
 153         }
 154
 155         default void error(Supplier<String> message) {
 156                 getLogger().log(Level.ERROR, message);
 157         }
 158
 159         default void error(Object message) {
 160                 getLogger().log(Level.ERROR, message);
 161         }
 162
 163         default void error(String message, Throwable t) {
 164                 getLogger().log(Level.ERROR, message, t);
 165         }
 166
 167         default void error(Object message, Throwable t) {
 168                 error(Objects.requireNonNull(message).toString(), t);
 169         }
 170
 171         default void error(String format, Object... arguments) {
 172                 getLogger().log(Level.ERROR, format, arguments);
 173         }
 174
 175         /*
 176          * STATIC UTILITIES
 177          */
 178
 179         static CmsLog getLog(Class<?> clss) {
 180                 return getLog(Objects.requireNonNull(clss).getName());
 181         }
 182
 183         static CmsLog getLog(String name) {
 184                 Logger logger = System.getLogger(Objects.requireNonNull(name));
 185                 return new LoggerWrapper(logger);
 186         }
 187
 188         /** A trivial implementation wrapping a platform logger. */
 189         static class LoggerWrapper implements CmsLog {
 190                 private final Logger logger;
 191
 192                 LoggerWrapper(Logger logger) {
 193                         this.logger = logger;
 194                 }
 195
 196                 @Override
 197                 public Logger getLogger() {
 198                         return logger;
 199                 }
 200
 201         }
 202
 203 }