/interpreter/tags/at2-build060407/src/edu/vub/at/util/logging/Logger.java

http://ambienttalk.googlecode.com/ · Java · 158 lines · 84 code · 22 blank · 52 comment · 15 complexity · 94df672933bae4753573b21bc7a94f47 MD5 · raw file

  1. /**
  2. * AmbientTalk/2 Project
  3. * Logger.java created on 5-apr-2007 at 10:50:03
  4. * (c) Programming Technology Lab, 2006 - 2007
  5. * Authors: Tom Van Cutsem & Stijn Mostinckx
  6. *
  7. * Permission is hereby granted, free of charge, to any person
  8. * obtaining a copy of this software and associated documentation
  9. * files (the "Software"), to deal in the Software without
  10. * restriction, including without limitation the rights to use,
  11. * copy, modify, merge, publish, distribute, sublicense, and/or
  12. * sell copies of the Software, and to permit persons to whom the
  13. * Software is furnished to do so, subject to the following
  14. * conditions:
  15. *
  16. * The above copyright notice and this permission notice shall be
  17. * included in all copies or substantial portions of the Software.
  18. *
  19. * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  20. * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
  21. * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  22. * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
  23. * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
  24. * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  25. * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
  26. * OTHER DEALINGS IN THE SOFTWARE.
  27. */
  28. package edu.vub.at.util.logging;
  29. import java.util.Date;
  30. import java.util.HashMap;
  31. /**
  32. * A logger object modelled after the interface of the Log4J framework.
  33. *
  34. * @author tvcutsem
  35. */
  36. public class Logger {
  37. /**
  38. * A map for pooling all of the loggers.
  39. */
  40. private static final HashMap _LOGS = new HashMap();
  41. private final String name_;
  42. /**
  43. * Logs with a priority less than this will not get logged.
  44. */
  45. private int leastPriority_;
  46. private String textPriority_;
  47. /**
  48. * Access to the map should actually be synchronized, but this
  49. * adds overhead to accessing the loggers.
  50. *
  51. * Without synchronization, the possibility exists that same logger
  52. * is added twice. On the other hand, as loggers are stateless, this is not
  53. * really a problem (the new one will replace the old one without any harm)
  54. */
  55. public static Logger getInstance(String name) {
  56. Logger logger = (Logger) _LOGS.get(name);
  57. if (logger == null) {
  58. logger = new Logger(name);
  59. _LOGS.put(name, logger);
  60. }
  61. return logger;
  62. }
  63. public static final int _DEBUG_LEVEL_ = 1;
  64. public static final int _WARN_LEVEL_ = 2;
  65. public static final int _INFO_LEVEL_ = 3;
  66. public static final int _ERROR_LEVEL_ = 4;
  67. public static final int _FATAL_LEVEL_ = 5;
  68. private Logger(String nam) {
  69. name_ = nam;
  70. leastPriority_ = _DEBUG_LEVEL_;
  71. textPriority_ = "DEBUG";
  72. }
  73. /**
  74. * Set the priority of the logger.
  75. * @param priority - one of 'DEBUG', 'WARN', 'INFO', 'ERROR' or 'FATAL'
  76. * @throws IllegalArgumentException if the given argument is not one of the above logging levels.
  77. */
  78. public void setPriority(String priority) throws IllegalArgumentException {
  79. leastPriority_ = textToLevel(priority);
  80. textPriority_ = priority;
  81. }
  82. public void debug(String msg) {
  83. log(_DEBUG_LEVEL_, msg, null);
  84. }
  85. public void debug(String msg, Throwable exc) {
  86. log(_DEBUG_LEVEL_, msg, exc);
  87. }
  88. public void warn(String msg) {
  89. log(_WARN_LEVEL_, msg, null);
  90. }
  91. public void warn(String msg, Throwable exc) {
  92. log(_WARN_LEVEL_, msg, exc);
  93. }
  94. public void info(String msg) {
  95. log(_INFO_LEVEL_, msg, null);
  96. }
  97. public void info(String msg, Throwable exc) {
  98. log(_INFO_LEVEL_, msg, exc);
  99. }
  100. public void error(String msg) {
  101. log(_ERROR_LEVEL_, msg, null);
  102. }
  103. public void error(String msg, Throwable exc) {
  104. log(_ERROR_LEVEL_, msg, exc);
  105. }
  106. public void fatal(String msg) {
  107. log(_FATAL_LEVEL_, msg, null);
  108. }
  109. public void fatal(String msg, Throwable exc) {
  110. log(_FATAL_LEVEL_, msg, exc);
  111. }
  112. private void log(int priority, String msg, Throwable exc) {
  113. if (priority >= leastPriority_) {
  114. // format: date priority logname - message
  115. System.err.println(new Date().toString() + " " + textPriority_ + " "+ name_ + " - " + msg);
  116. if (exc != null) {
  117. exc.printStackTrace(System.err);
  118. }
  119. }
  120. }
  121. private int textToLevel(String priority) throws IllegalArgumentException {
  122. if (priority.equalsIgnoreCase("DEBUG")) {
  123. return _DEBUG_LEVEL_;
  124. } else if (priority.equalsIgnoreCase("WARN")) {
  125. return _WARN_LEVEL_;
  126. } else if (priority.equalsIgnoreCase("INFO")) {
  127. return _INFO_LEVEL_;
  128. } else if (priority.equalsIgnoreCase("ERROR")) {
  129. return _ERROR_LEVEL_;
  130. } else if (priority.equalsIgnoreCase("FATAL")) {
  131. return _FATAL_LEVEL_;
  132. } else {
  133. throw new IllegalArgumentException("Illegal priority value: " + priority);
  134. }
  135. }
  136. }