src/jalview/log/JLogger.java

   1 /*
   2  * Jalview - A Sequence Alignment Editor and Viewer ($$Version-Rel$$)
   3  * Copyright (C) $$Year-Rel$$ The Jalview Authors
   4  *
   5  * This file is part of Jalview.
   6  *
   7  * Jalview is free software: you can redistribute it and/or
   8  * modify it under the terms of the GNU General Public License
   9  * as published by the Free Software Foundation, either version 3
  10  * of the License, or (at your option) any later version.
  11  *
  12  * Jalview is distributed in the hope that it will be useful, but
  13  * WITHOUT ANY WARRANTY; without even the implied warranty
  14  * of MERCHANTABILITY or FITNESS FOR A PARTICULAR
  15  * PURPOSE.  See the GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with Jalview.  If not, see <http://www.gnu.org/licenses/>.
  19  * The Jalview Authors are detailed in the 'AUTHORS' file.
  20  */
  21 package jalview.log;
  22
  23 import java.util.EnumSet;
  24 import java.util.HashMap;
  25 import java.util.Map;
  26
  27 import jalview.bin.Console;
  28 import jalview.util.Platform;
  29
  30 public abstract class JLogger implements JLoggerI
  31 {
  32   protected String name;
  33
  34   protected LogLevel level;
  35
  36   private Object logger = null;
  37
  38   private static Map<String, JLogger> registry = new HashMap<>();
  39
  40   // implement these abstract methods
  41   protected abstract void loggerSetup();
  42
  43   public abstract boolean loggerExists();
  44
  45   protected abstract void loggerSetLevel(LogLevel level);
  46
  47   protected abstract void loggerLogMessage(LogLevel level, String message,
  48           Throwable t);
  49
  50   public static boolean isLevel(String levelString)
  51   {
  52     for (LogLevel l : EnumSet.allOf(LogLevel.class))
  53     {
  54       if (l.name().equals(levelString))
  55         return true;
  56     }
  57     return false;
  58   }
  59
  60   public static LogLevel toLevel(String levelString)
  61   {
  62     try
  63     {
  64       return LogLevel.valueOf(levelString);
  65     } catch (IllegalArgumentException e)
  66     {
  67       Console.error("Could not parse LogLevel '" + levelString + "'", e);
  68       return LogLevel.INFO;
  69     }
  70   }
  71
  72   public static JLogger getLogger(Class c)
  73   {
  74     return getLogger(c, LogLevel.INFO);
  75   }
  76
  77   public static JLogger getLogger(Class c, LogLevel loglevel)
  78   {
  79     return getLogger(c.getCanonicalName(), loglevel);
  80   }
  81
  82   public static JLogger getLogger(String name)
  83   {
  84     return getLogger(name, LogLevel.INFO);
  85   }
  86
  87   public static JLogger getLogger(String name, LogLevel loglevel)
  88   {
  89     return registry.containsKey(name) ? (JLogger) registry.get(name) : null;
  90   }
  91
  92   protected JLogger()
  93   {
  94   }
  95
  96   protected JLogger(String name, LogLevel level)
  97   {
  98     this.name = name;
  99     this.level = level;
 100     this.loggerSetup();
 101     this.registryStore();
 102   }
 103
 104   protected void registryStore()
 105   {
 106     registry.put(this.name, this);
 107   }
 108
 109   protected static boolean registryContainsKey(String name)
 110   {
 111     return registry.containsKey(name);
 112   }
 113
 114   protected static JLogger registryGet(String name)
 115   {
 116     return registry.get(name);
 117   }
 118
 119   public LogLevel getLevel()
 120   {
 121     return this.level;
 122   }
 123
 124   public void setLevel(LogLevel level)
 125   {
 126     this.level = level;
 127     if (loggerExists())
 128       loggerSetLevel(level);
 129   }
 130
 131   private boolean println(LogLevel loglevel, String message, Throwable t)
 132   {
 133     if (loglevel.compareTo(this.level) < 0)
 134     {
 135       return false;
 136     }
 137     if (!loggerExists() || Platform.isJS())
 138     {
 139       String logLine = String.format("%s: %s", loglevel.toString(),
 140               message);
 141       jalview.bin.Console.outPrintln(logLine);
 142       if (t != null)
 143       {
 144         if (loglevel.compareTo(LogLevel.DEBUG) <= 0)
 145           t.printStackTrace(System.err);
 146         else
 147           jalview.bin.Console.errPrintln(t.getMessage());
 148       }
 149       return false;
 150     }
 151     else
 152     {
 153       loggerLogMessage(loglevel, message, t);
 154       return true;
 155     }
 156   }
 157
 158   public void trace(String message)
 159   {
 160     trace(message, null);
 161   }
 162
 163   public void trace(String message, Throwable t)
 164   {
 165     println(LogLevel.TRACE, message, t);
 166   }
 167
 168   public void debug(String message)
 169   {
 170     debug(message, null);
 171   }
 172
 173   public void debug(String message, Throwable t)
 174   {
 175     println(LogLevel.DEBUG, message, t);
 176   }
 177
 178   public void info(String message)
 179   {
 180     info(message, null);
 181   }
 182
 183   public void info(String message, Throwable t)
 184   {
 185     println(LogLevel.INFO, message, t);
 186   }
 187
 188   public void warn(String message)
 189   {
 190     warn(message, null);
 191   }
 192
 193   public void warn(String message, Throwable t)
 194   {
 195     println(LogLevel.WARN, message, t);
 196   }
 197
 198   public void error(String message)
 199   {
 200     error(message, null);
 201   }
 202
 203   public void error(String message, Throwable t)
 204   {
 205     println(LogLevel.ERROR, message, t);
 206   }
 207
 208   public void fatal(String message)
 209   {
 210     fatal(message, null);
 211   }
 212
 213   public void fatal(String message, Throwable t)
 214   {
 215     println(LogLevel.FATAL, message, t);
 216   }
 217
 218   public boolean isDebugEnabled()
 219   {
 220     return level.compareTo(LogLevel.DEBUG) <= 0;
 221   }
 222
 223   public boolean isTraceEnabled()
 224   {
 225     return level.compareTo(LogLevel.TRACE) <= 0;
 226   }
 227 }