JAL-3949 Complete new abstracted logging framework in jalview.log. Updated log calls...

[jalview.git] / src / jalview / log / JLogger.java

diff --git a/src/jalview/log/JLogger.java b/src/jalview/log/JLogger.java
new file mode 100644 (file)
index 0000000..03b664a
--- /dev/null
+++ b/src/jalview/log/JLogger.java
@@ -0,0 +1,181 @@
+package jalview.log;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import jalview.bin.Cache;
+import jalview.util.Platform;
+
+public abstract class JLogger implements JLoggerI
+{
+  protected String name;
+
+  protected LogLevel level;
+
+  private Object logger = null;
+
+  private static Map<String, JLogger> registry = new HashMap<>();
+
+  // implement these abstract methods
+  protected abstract void loggerSetup();
+
+  public abstract boolean loggerExists();
+
+  protected abstract void loggerSetLevel(LogLevel level);
+
+  protected abstract void loggerLogMessage(LogLevel level, String message,
+          Throwable t);
+
+  public static LogLevel toLevel(String levelString)
+  {
+    try
+    {
+      return LogLevel.valueOf(levelString);
+    } catch (IllegalArgumentException e)
+    {
+      Cache.error("Could not parse LogLevel '" + levelString + "'", e);
+      return LogLevel.INFO;
+    }
+  }
+
+  public static JLogger getLogger(String name)
+  {
+    return getLogger(name, LogLevel.INFO);
+  }
+
+  public static JLogger getLogger(String name, LogLevel loglevel)
+  {
+    return registry.containsKey(name) ? (JLogger) registry.get(name) : null;
+  }
+
+  protected JLogger()
+  {
+  }
+
+  protected JLogger(String name, LogLevel level)
+  {
+    this.name = name;
+    this.level = level;
+    this.loggerSetup();
+    this.registryStore();
+  }
+
+  protected void registryStore()
+  {
+    registry.put(this.name, this);
+  }
+
+  protected static boolean registryContainsKey(String name)
+  {
+    return registry.containsKey(name);
+  }
+
+  protected static JLogger registryGet(String name)
+  {
+    return registry.get(name);
+  }
+
+  public LogLevel getLevel()
+  {
+    return this.level;
+  }
+
+  public void setLevel(LogLevel level)
+  {
+    this.level = level;
+    if (loggerExists())
+      loggerSetLevel(level);
+  }
+
+  private boolean println(LogLevel level, String message, Throwable t)
+  {
+    if (!loggerExists() || Platform.isJS())
+    {
+      String logLine = String.format("%s: %s", level.toString(), message);
+      System.out.println(logLine);
+      if (t != null)
+      {
+        if (level.compareTo(LogLevel.DEBUG) <= 0)
+          t.printStackTrace(System.err);
+        else
+          System.err.println(t.getMessage());
+      }
+      return false;
+    }
+    else
+    {
+      loggerLogMessage(level, message, t);
+      return true;
+    }
+  }
+
+  public void trace(String message)
+  {
+    trace(message, null);
+  }
+
+  public void trace(String message, Throwable t)
+  {
+    println(LogLevel.TRACE, message, t);
+  }
+
+  public void debug(String message)
+  {
+    debug(message, null);
+  }
+
+  public void debug(String message, Throwable t)
+  {
+    println(LogLevel.DEBUG, message, t);
+  }
+
+  public void info(String message)
+  {
+    info(message, null);
+  }
+
+  public void info(String message, Throwable t)
+  {
+    println(LogLevel.INFO, message, t);
+  }
+
+  public void warn(String message)
+  {
+    warn(message, null);
+  }
+
+  public void warn(String message, Throwable t)
+  {
+    println(LogLevel.WARN, message, t);
+  }
+
+  public void error(String message)
+  {
+    error(message, null);
+  }
+
+  public void error(String message, Throwable t)
+  {
+    println(LogLevel.ERROR, message, t);
+  }
+
+  public void fatal(String message)
+  {
+    fatal(message, null);
+  }
+
+  public void fatal(String message, Throwable t)
+  {
+    println(LogLevel.FATAL, message, t);
+  }
+
+  public boolean isDebugEnabled()
+  {
+    return level.compareTo(LogLevel.DEBUG) <= 0;
+  }
+
+  public boolean isTraceEnabled()
+  {
+    return level.compareTo(LogLevel.TRACE) <= 0;
+  }
+}