|
/*
* JCommon : a free general purpose class library for the Java(tm) platform
*
*
* (C) Copyright 2000-2005, by Object Refinery Limited and Contributors.
*
* Project Info: http://www.jfree.org/jcommon/index.html
*
* This library is free software; you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as published by
* the Free Software Foundation; either version 2.1 of the License, or
* (at your option) any later version.
*
* This library is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
* or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
* License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
* USA.
*
* [Java is a trademark or registered trademark of Sun Microsystems, Inc.
* in the United States and other countries.]
*
* --------
* Log.java
* --------
* (C)opyright 2002-2004, by Thomas Morgner and Contributors.
*
* Original Author: Thomas Morgner (taquera@sherito.org);
* Contributor(s): David Gilbert (for Object Refinery Limited);
*
* $Id: Log.java,v 1.5 2006/06/08 17:42:20 taqua Exp $
*
* Changes
* -------
* 29-Apr-2003 : Distilled from the JFreeReport project and moved into JCommon
* 11-Jun-2003 : Removing LogTarget did not work.
*
*/
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
/**
* A simple logging facility. Create a class implementing the
* {@link org.jfree.util.LogTarget} interface to use this feature.
*
* @author Thomas Morgner
*/
public class Log {
/**
* A simple message class.
*/
public static class SimpleMessage {
/**
* The message.
*/
private String message;
/**
* The parameters.
*/
private Object[] param;
/**
* Creates a new message.
*
* @param message
* the message text.
* @param param1
* parameter 1.
*/
public SimpleMessage(final String message, final Object param1) {
this.message = message;
this.param = new Object[] { param1 };
}
/**
* Creates a new message.
*
* @param message
* the message text.
* @param param1
* parameter 1.
* @param param2
* parameter 2.
*/
public SimpleMessage(final String message, final Object param1, final Object param2) {
this.message = message;
this.param = new Object[] { param1, param2 };
}
/**
* Creates a new message.
*
* @param message
* the message text.
* @param param1
* parameter 1.
* @param param2
* parameter 2.
* @param param3
* parameter 3.
*/
public SimpleMessage(final String message, final Object param1, final Object param2,
final Object param3) {
this.message = message;
this.param = new Object[] { param1, param2, param3 };
}
/**
* Creates a new message.
*
* @param message
* the message text.
* @param param1
* parameter 1.
* @param param2
* parameter 2.
* @param param3
* parameter 3.
* @param param4
* parameter 4.
*/
public SimpleMessage(final String message, final Object param1, final Object param2,
final Object param3, final Object param4) {
this.message = message;
this.param = new Object[] { param1, param2, param3, param4 };
}
/**
* Creates a new message.
*
* @param message
* the message text.
* @param param
* the parameters.
*/
public SimpleMessage(final String message, final Object[] param) {
this.message = message;
this.param = param;
}
/**
* Returns a string representation of the message (useful for debugging).
*
* @return the string.
*/
public String toString() {
final StringBuffer b = new StringBuffer();
b.append(this.message);
if (this.param != null) {
for (int i = 0; i < this.param.length; i++) {
b.append(this.param[i]);
}
}
return b.toString();
}
}
/**
* The logging threshold.
*/
private int debuglevel;
/**
* Storage for the log targets.
*/
private LogTarget[] logTargets;
/** The log contexts. */
private HashMap logContexts;
/**
* the singleton instance of the Log system.
*/
private static Log singleton;
/**
* Creates a new Log instance. The Log is used to manage the log targets.
*/
protected Log() {
this.logContexts = new HashMap();
this.logTargets = new LogTarget[0];
this.debuglevel = 100;
}
/**
* Returns the singleton Log instance. A new instance is created if necessary.
*
* @return the singleton instance.
*/
public static synchronized Log getInstance() {
if (singleton == null) {
singleton = new Log();
}
return singleton;
}
/**
* Redefines or clears the currently used log instance.
*
* @param log
* the new log instance or null, to return to the default
* implementation.
*/
protected static synchronized void defineLog(final Log log) {
singleton = log;
}
/**
* Returns the currently defined debug level. The higher the level, the more
* details are printed.
*
* @return the debug level.
*/
public int getDebuglevel() {
return this.debuglevel;
}
/**
* Defines the debug level for the log system.
*
* @param debuglevel
* the new debug level
* @see #getDebuglevel()
*/
protected void setDebuglevel(final int debuglevel) {
this.debuglevel = debuglevel;
}
/**
* Adds a log target to this facility. Log targets get informed, via the
* LogTarget interface, whenever a message is logged with this class.
*
* @param target
* the target.
*/
public synchronized void addTarget(final LogTarget target) {
if (target == null) {
throw new NullPointerException();
}
final LogTarget[] data = new LogTarget[this.logTargets.length + 1];
System.arraycopy(this.logTargets, 0, data, 0, this.logTargets.length);
data[this.logTargets.length] = target;
this.logTargets = data;
}
/**
* Removes a log target from this facility.
*
* @param target
* the target to remove.
*/
public synchronized void removeTarget(final LogTarget target) {
if (target == null) {
throw new NullPointerException();
}
final ArrayList l = new ArrayList();
l.addAll(Arrays.asList(this.logTargets));
l.remove(target);
final LogTarget[] targets = new LogTarget[l.size()];
this.logTargets = (LogTarget[]) l.toArray(targets);
}
/**
* Returns the registered logtargets.
*
* @return the logtargets.
*/
public LogTarget[] getTargets() {
return (LogTarget[]) this.logTargets.clone();
}
/**
* Replaces all log targets by the given target.
*
* @param target
* the new and only logtarget.
*/
public synchronized void replaceTargets(final LogTarget target) {
if (target == null) {
throw new NullPointerException();
}
this.logTargets = new LogTarget[] { target };
}
/**
* A convenience method for logging a 'debug' message.
*
* @param message
* the message.
*/
public static void debug(final Object message) {
log(LogTarget.DEBUG, message);
}
/**
* A convenience method for logging a 'debug' message.
*
* @param message
* the message.
* @param e
* the exception.
*/
public static void debug(final Object message, final Exception e) {
log(LogTarget.DEBUG, message, e);
}
/**
* A convenience method for logging an 'info' message.
*
* @param message
* the message.
*/
public static void info(final Object message) {
log(LogTarget.INFO, message);
}
/**
* A convenience method for logging an 'info' message.
*
* @param message
* the message.
* @param e
* the exception.
*/
public static void info(final Object message, final Exception e) {
log(LogTarget.INFO, message, e);
}
/**
* A convenience method for logging a 'warning' message.
*
* @param message
* the message.
*/
public static void warn(final Object message) {
log(LogTarget.WARN, message);
}
/**
* A convenience method for logging a 'warning' message.
*
* @param message
* the message.
* @param e
* the exception.
*/
public static void warn(final Object message, final Exception e) {
log(LogTarget.WARN, message, e);
}
/**
* A convenience method for logging an 'error' message.
*
* @param message
* the message.
*/
public static void error(final Object message) {
log(LogTarget.ERROR, message);
}
/**
* A convenience method for logging an 'error' message.
*
* @param message
* the message.
* @param e
* the exception.
*/
public static void error(final Object message, final Exception e) {
log(LogTarget.ERROR, message, e);
}
/**
* Logs a message to the main log stream. All attached log targets will also
* receive this message. If the given log-level is higher than the given
* debug-level in the main config file, no logging will be done.
*
* @param level
* log level of the message.
* @param message
* text to be logged.
*/
protected void doLog(int level, final Object message) {
if (level > 3) {
level = 3;
}
if (level <= this.debuglevel) {
for (int i = 0; i < this.logTargets.length; i++) {
final LogTarget t = this.logTargets[i];
t.log(level, message);
}
}
}
/**
* Logs a message to the main log stream. All attached log targets will also
* receive this message. If the given log-level is higher than the given
* debug-level in the main config file, no logging will be done.
*
* @param level
* log level of the message.
* @param message
* text to be logged.
*/
public static void log(final int level, final Object message) {
getInstance().doLog(level, message);
}
/**
* Logs a message to the main log stream. All attached logTargets will also
* receive this message. If the given log-level is higher than the given
* debug-level in the main config file, no logging will be done. <p/> The
* exception's stacktrace will be appended to the log-stream
*
* @param level
* log level of the message.
* @param message
* text to be logged.
* @param e
* the exception, which should be logged.
*/
public static void log(final int level, final Object message, final Exception e) {
getInstance().doLog(level, message, e);
}
/**
* Logs a message to the main log stream. All attached logTargets will also
* receive this message. If the given log-level is higher than the given
* debug-level in the main config file, no logging will be done. <p/> The
* exception's stacktrace will be appended to the log-stream
*
* @param level
* log level of the message.
* @param message
* text to be logged.
* @param e
* the exception, which should be logged.
*/
protected void doLog(int level, final Object message, final Exception e) {
if (level > 3) {
level = 3;
}
if (level <= this.debuglevel) {
for (int i = 0; i < this.logTargets.length; i++) {
final LogTarget t = this.logTargets[i];
t.log(level, message, e);
}
}
}
/**
* Initializes the logging system. Implementors should override this method to
* supply their own log configuration.
*/
public void init() {
// this method is intentionally empty.
}
/**
* Returns true, if the log level allows debug messages to be printed.
*
* @return true, if messages with an log level of DEBUG are allowed.
*/
public static boolean isDebugEnabled() {
return getInstance().getDebuglevel() >= LogTarget.DEBUG;
}
/**
* Returns true, if the log level allows informational messages to be printed.
*
* @return true, if messages with an log level of INFO are allowed.
*/
public static boolean isInfoEnabled() {
return getInstance().getDebuglevel() >= LogTarget.INFO;
}
/**
* Returns true, if the log level allows warning messages to be printed.
*
* @return true, if messages with an log level of WARN are allowed.
*/
public static boolean isWarningEnabled() {
return getInstance().getDebuglevel() >= LogTarget.WARN;
}
/**
* Returns true, if the log level allows error messages to be printed.
*
* @return true, if messages with an log level of ERROR are allowed.
*/
public static boolean isErrorEnabled() {
return getInstance().getDebuglevel() >= LogTarget.ERROR;
}
/**
* Creates a log context.
*
* @param context
* the class (<code>null</code> not permitted).
*
* @return A log context.
*/
public static LogContext createContext(final Class context) {
return createContext(context.getName());
}
/**
* Creates a log context.
*
* @param context
* the label for the context.
*
* @return A log context.
*/
public static LogContext createContext(final String context) {
return getInstance().internalCreateContext(context);
}
/**
* Creates a log context.
*
* @param context
* the name of the logging context (a common prefix).
*
* @return A log context.
*/
protected LogContext internalCreateContext(final String context) {
synchronized (this) {
LogContext ctx = (LogContext) this.logContexts.get(context);
if (ctx == null) {
ctx = new LogContext(context);
this.logContexts.put(context, ctx);
}
return ctx;
}
}
}
/*
* JCommon : a free general purpose class library for the Java(tm) platform
*
*
* (C) Copyright 2000-2005, by Object Refinery Limited and Contributors.
*
* Project Info: http://www.jfree.org/jcommon/index.html
*
* This library is free software; you can redistribute it and/or modify it under
* the terms of the GNU Lesser General Public License as published by the Free
* Software Foundation; either version 2.1 of the License, or (at your option)
* any later version.
*
* This library is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
* FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
* details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with this library; if not, write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*
* [Java is a trademark or registered trademark of Sun Microsystems, Inc. in the
* United States and other countries.]
*
* -------------- LogTarget.java -------------- (C)opyright 2002-2004, by Object
* Refinery Limited.
*
* $Id: LogTarget.java,v 1.3 2005/11/14 10:55:59 mungady Exp $
*
* Changes ------- 11-May-2002 : Initial version 06-Dec-2002 : LogTargets now
* use Object-Parameters instead of Strings. 05-Feb-2003 : Removed unnecessary
* methods. 29-Apr-2003 : Distilled from the JFreeReport project and moved into
* JCommon
*
*/
/**
* An interface that defines a log target (a consumer of log messages). Classes
* which implement this interface can be registered with the
* {@link org.jfree.util.Log} class and will then receive logging messages
* generated by the code.
*
* @author Thomas Morgner
*/
interface LogTarget {
/**
* Loglevel ERROR.
*/
public static final int ERROR = 0;
/**
* Loglevel WARN.
*/
public static final int WARN = 1;
/**
* Loglevel INFO.
*/
public static final int INFO = 2;
/**
* Loglevel DEBUG.
*/
public static final int DEBUG = 3;
/** Strings for the log levels. */
public static final String[] LEVELS = { "ERROR: ", "WARN: ", "INFO: ", "DEBUG: " };
/**
* Logs a message at a specified log level.
*
* @param level
* the log level.
* @param message
* the log message.
*/
public void log(int level, Object message);
/**
* Logs a message at a specified log level.
*
* @param level
* the log level.
* @param message
* the log message.
* @param e
* the exception
*/
public void log(int level, Object message, Exception e);
}
/*
* JCommon : a free general purpose class library for the Java(tm) platform
*
*
* (C) Copyright 2000-2005, by Object Refinery Limited and Contributors.
*
* Project Info: http://www.jfree.org/jcommon/index.html
*
* This library is free software; you can redistribute it and/or modify it under
* the terms of the GNU Lesser General Public License as published by the Free
* Software Foundation; either version 2.1 of the License, or (at your option)
* any later version.
*
* This library is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
* FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
* details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with this library; if not, write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*
* [Java is a trademark or registered trademark of Sun Microsystems, Inc. in the
* United States and other countries.]
*
* --------------- LogContext.java --------------- (C)opyright 2004, by Thomas
* Morgner and Contributors.
*
* Original Author: Thomas Morgner; Contributor(s): David Gilbert (for Object
* Refinery Limited);
*
* $Id: LogContext.java,v 1.3 2005/10/18 13:24:19 mungady Exp $
*
* Changes ------- 26-Apr-2004 : Initial version (TM);
*
*/
/**
* A log context.
*
* @author Thomas Morgner
*/
class LogContext {
/** The prefix string. */
private String contextPrefix;
/**
* Creates a new log context.
*
* @param contextPrefix
* the prefix.
*/
public LogContext(final String contextPrefix) {
this.contextPrefix = contextPrefix;
}
/**
* Returns true, if the log level allows debug messages to be printed.
*
* @return true, if messages with an log level of DEBUG are allowed.
*/
public boolean isDebugEnabled() {
return Log.isDebugEnabled();
}
/**
* Returns true, if the log level allows informational messages to be printed.
*
* @return true, if messages with an log level of INFO are allowed.
*/
public boolean isInfoEnabled() {
return Log.isInfoEnabled();
}
/**
* Returns true, if the log level allows warning messages to be printed.
*
* @return true, if messages with an log level of WARN are allowed.
*/
public boolean isWarningEnabled() {
return Log.isWarningEnabled();
}
/**
* Returns true, if the log level allows error messages to be printed.
*
* @return true, if messages with an log level of ERROR are allowed.
*/
public boolean isErrorEnabled() {
return Log.isErrorEnabled();
}
/**
* A convenience method for logging a 'debug' message.
*
* @param message
* the message.
*/
public void debug(final Object message) {
log(LogTarget.DEBUG, message);
}
/**
* A convenience method for logging a 'debug' message.
*
* @param message
* the message.
* @param e
* the exception.
*/
public void debug(final Object message, final Exception e) {
log(LogTarget.DEBUG, message, e);
}
/**
* A convenience method for logging an 'info' message.
*
* @param message
* the message.
*/
public void info(final Object message) {
log(LogTarget.INFO, message);
}
/**
* A convenience method for logging an 'info' message.
*
* @param message
* the message.
* @param e
* the exception.
*/
public void info(final Object message, final Exception e) {
log(LogTarget.INFO, message, e);
}
/**
* A convenience method for logging a 'warning' message.
*
* @param message
* the message.
*/
public void warn(final Object message) {
log(LogTarget.WARN, message);
}
/**
* A convenience method for logging a 'warning' message.
*
* @param message
* the message.
* @param e
* the exception.
*/
public void warn(final Object message, final Exception e) {
log(LogTarget.WARN, message, e);
}
/**
* A convenience method for logging an 'error' message.
*
* @param message
* the message.
*/
public void error(final Object message) {
log(LogTarget.ERROR, message);
}
/**
* A convenience method for logging an 'error' message.
*
* @param message
* the message.
* @param e
* the exception.
*/
public void error(final Object message, final Exception e) {
log(LogTarget.ERROR, message, e);
}
/**
* Logs a message to the main log stream. All attached log targets will also
* receive this message. If the given log-level is higher than the given
* debug-level in the main config file, no logging will be done.
*
* @param level
* log level of the message.
* @param message
* text to be logged.
*/
public void log(final int level, final Object message) {
if (this.contextPrefix != null) {
Log.getInstance().doLog(level, new Log.SimpleMessage(this.contextPrefix, ":", message));
} else {
Log.getInstance().doLog(level, message);
}
}
/**
* Logs a message to the main log stream. All attached logTargets will also
* receive this message. If the given log-level is higher than the given
* debug-level in the main config file, no logging will be done. <p/> The
* exception's stacktrace will be appended to the log-stream
*
* @param level
* log level of the message.
* @param message
* text to be logged.
* @param e
* the exception, which should be logged.
*/
public void log(final int level, final Object message, final Exception e) {
if (this.contextPrefix != null) {
Log.getInstance().doLog(level, new Log.SimpleMessage(this.contextPrefix, ":", message), e);
} else {
Log.getInstance().doLog(level, message, e);
}
}
/**
* Tests this object for equality with an arbitrary object.
*
* @param o
* the object to test against (<code>null</code> permitted).
*
* @return A boolean.
*/
public boolean equals(final Object o) {
if (this == o) {
return true;
}
if (!(o instanceof LogContext)) {
return false;
}
final LogContext logContext = (LogContext) o;
if (this.contextPrefix != null) {
if (!this.contextPrefix.equals(logContext.contextPrefix)) {
return false;
}
} else {
if (logContext.contextPrefix != null) {
return false;
}
}
return true;
}
/**
* Returns a hashcode.
*
* @return The hashcode.
*/
public int hashCode() {
return (this.contextPrefix != null ? this.contextPrefix.hashCode() : 0);
}
}
|