src/net/pterodactylus/util/logging/Logging.java

   1 /*
   2  * jFCPlib-high-level-client - Logging.java -
   3  * Copyright © 2008 David Roden
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License as published by
   7  * the Free Software Foundation; either version 2 of the License, or
   8  * (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program; if not, write to the Free Software
  17  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  18  */
  19
  20 package net.pterodactylus.util.logging;
  21
  22 import java.util.ArrayList;
  23 import java.util.Collections;
  24 import java.util.List;
  25 import java.util.logging.Handler;
  26 import java.util.logging.Level;
  27 import java.util.logging.LogRecord;
  28 import java.util.logging.Logger;
  29
  30 /**
  31  * Sets up logging.
  32  *
  33  * @author David ‘Bombe’ Roden &lt;bombe@freenetproject.org&gt;
  34  * @version $Id$
  35  */
  36 public class Logging {
  37
  38         /** The log handler. */
  39         private static final LogHandler logHandler = new LogHandler();
  40
  41         static {
  42                 logHandler.setLevel(Level.ALL);
  43         }
  44
  45         /** The root name of the hierarchy. */
  46         private static String hierarchyRootName;
  47
  48         /**
  49          * Adds a listener to the log handler.
  50          *
  51          * @param loggingListener
  52          *            The listener to add
  53          */
  54         public static void addLoggingListener(LoggingListener loggingListener) {
  55                 logHandler.addLoggingListener(loggingListener);
  56         }
  57
  58         /**
  59          * Removes a listener from the log handler.
  60          *
  61          * @param loggingListener
  62          *            The listener to remove
  63          */
  64         public static void removeLoggingListener(LoggingListener loggingListener) {
  65                 logHandler.removeLoggingListener(loggingListener);
  66         }
  67
  68         /**
  69          * Sets up logging and installs the log handler.
  70          *
  71          * @param hierarchyName
  72          *            The name of the hierarchy root logger
  73          */
  74         public static void setup(String hierarchyName) {
  75                 hierarchyRootName = hierarchyName;
  76                 Logger rootLogger = Logger.getLogger(hierarchyName);
  77                 rootLogger.addHandler(logHandler);
  78                 rootLogger.setUseParentHandlers(false);
  79                 rootLogger.setLevel(Level.ALL);
  80         }
  81
  82         /**
  83          * Returns a named logger from the jSite hierarchy.
  84          *
  85          * @param name
  86          *            The name of the logger
  87          * @return The logger
  88          */
  89         public static Logger getLogger(String name) {
  90                 Logger logger = Logger.getLogger(hierarchyRootName + "." + name);
  91                 return logger;
  92         }
  93
  94         /**
  95          * The log handler simply forwards every log message it receives to all
  96          * registered listeners.
  97          *
  98          * @see LoggingListener
  99          * @author David ‘Bombe’ Roden &lt;bombe@freenetproject.org&gt;
 100          * @version $Id$
 101          */
 102         private static class LogHandler extends Handler {
 103
 104                 /**
 105                  * Package-private constructor.
 106                  */
 107                 LogHandler() {
 108                         /* do nothing. */
 109                 }
 110
 111                 /** The list of the listeners. */
 112                 private final List<LoggingListener> loggingListeners = Collections.synchronizedList(new ArrayList<LoggingListener>());
 113
 114                 //
 115                 // EVENT MANAGEMENT
 116                 //
 117
 118                 /**
 119                  * Adds a listener to the log handler.
 120                  *
 121                  * @param loggingListener
 122                  *            The listener to add
 123                  */
 124                 public void addLoggingListener(LoggingListener loggingListener) {
 125                         loggingListeners.add(loggingListener);
 126                 }
 127
 128                 /**
 129                  * Removes a listener from the log handler.
 130                  *
 131                  * @param loggingListener
 132                  *            The listener to remove
 133                  */
 134                 public void removeLoggingListener(LoggingListener loggingListener) {
 135                         loggingListeners.remove(loggingListener);
 136                 }
 137
 138                 /**
 139                  * Notifies all listeners that a log record was received.
 140                  *
 141                  * @param logRecord
 142                  *            The received log record
 143                  */
 144                 private void fireLogged(LogRecord logRecord) {
 145                         for (LoggingListener loggingListener: loggingListeners) {
 146                                 loggingListener.logged(logRecord);
 147                         }
 148                 }
 149
 150                 //
 151                 // INTERFACE Handler
 152                 //
 153
 154                 /**
 155                  * {@inheritDoc}
 156                  */
 157                 @Override
 158                 public void close() throws SecurityException {
 159                         /* do nothing. */
 160                 }
 161
 162                 /**
 163                  * {@inheritDoc}
 164                  */
 165                 @Override
 166                 public void flush() {
 167                         /* do nothing. */
 168                 }
 169
 170                 /**
 171                  * {@inheritDoc}
 172                  */
 173                 @Override
 174                 public void publish(LogRecord logRecord) {
 175                         fireLogged(logRecord);
 176                 }
 177
 178         }
 179
 180 }