Update of /cvsroot/metamorphosis/ruper2/src/java/core/org/krysalis/ruper2/log
In directory sc8-pr-cvs1:/tmp/cvs-serv30481/src/java/core/org/krysalis/ruper2/log
Added Files:
LogListener.java Logger.java StandardLogListener.java
LogConstant.java
Log Message:
Avoid clash with existing Ruper...
--- NEW FILE: LogListener.java ---
/*
* Created on Aug 28, 2003
*/
package org.krysalis.ruper2.log;
/**
* @author anou_mana
*/
public interface LogListener {
// thrower is null if not present
void log(int severity, Object message, Throwable thrower);
}
--- NEW FILE: Logger.java ---
/*
* Created on Aug 28, 2003
*/
package org.krysalis.ruper2.log;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Stack;
import org.krysalis.version.util.debug.DebugUtils;
/**
* @author anou_mana
*/
public class Logger {
// Listener Tables...
private List m_debugListeners = null;
private List m_infoListeners = null;
private List m_verboseListeners = null;
private List m_warnListeners = null;
private List m_errorListeners = null;
// Chaining...
private Logger m_next = null;
// The root singleton instance
private static Logger l_logger = null;
class LoggingContext {
//
// The context
//
Logger m_currentLogger = null;
Stack m_stack = null;
LoggingContext(Logger currentLogger) {
m_stack = new Stack();
push(currentLogger);
}
public void push(Logger currentLogger) {
m_stack.push(currentLogger);
m_currentLogger = (Logger) m_stack.peek();
}
public void pop(Logger currentLogger) {
Logger currentTop = (Logger) m_stack.pop();
// Set current
m_currentLogger = (Logger) m_stack.peek();
if (currentTop != currentLogger)
m_currentLogger.warn(
"Popped a bad logging context ["
+ currentLogger
+ "] != ["
+ currentTop
+ "]");
}
public Logger getCurrentLogger() {
return m_currentLogger;
}
}
//
// One per thread...
//
private static ThreadLocal l_context = null;
//:TODO: Store a Stack/Current Logger object in a ThreadLocal
// variable, so can have high level code push a "context" and
// lower level code will respect it (transparently)
// Push a logger which chains (next) the current logger, to
// get nested context...
static {
l_logger = new Logger();
l_context = new ThreadLocal() {
protected synchronized Object initialValue() {
return l_logger.new LoggingContext(l_logger);
}
};
}
public Logger(Logger next) {
initClass();
m_next = next;
}
public Logger() {
initClass();
m_next = null;
}
private void initClass() {
m_debugListeners = new ArrayList();
m_infoListeners = new ArrayList();
m_verboseListeners = new ArrayList();
m_warnListeners = new ArrayList();
m_errorListeners = new ArrayList();
}
public static Logger getLog() {
return ((LoggingContext) l_context.get()).getCurrentLogger();
}
public static Logger pushContext(LogListener listener) {
return pushContext(LogConstant.DEBUG_LISTENER, listener);
}
public static Logger pushContext(int level, LogListener listener) {
Logger newLogger = pushContext();
// :TODO: Fix level, ask lisener what they want...
newLogger.addListener(level, listener);
return newLogger;
}
public static Logger pushContext() {
LoggingContext context = ((LoggingContext) l_context.get());
Logger newLogger = new Logger(context.getCurrentLogger());
context.push(newLogger);
return newLogger;
}
public static Logger pushContext(Logger newContext) {
((LoggingContext) l_context.get()).push(newContext);
return newContext;
}
public static void popContext(Logger expectedLogger) {
((LoggingContext) l_context.get()).pop(expectedLogger);
}
public void addListener(int listenerType, LogListener listener) {
switch (listenerType) {
default :
case LogConstant.DEBUG_LISTENER :
{
m_debugListeners.add(listener);
// Note: Falls through to INFO...
}
case LogConstant.INFO_LISTENER :
{
m_infoListeners.add(listener);
// Note: Falls through to VERBOSE...
}
case LogConstant.VERBOSE_LISTENER :
{
m_verboseListeners.add(listener);
// Note: Falls through to WARN...
}
case LogConstant.WARN_LISTENER :
{
m_warnListeners.add(listener);
// Note: Falls through to ERROR...
}
case LogConstant.ERROR_LISTENER :
{
m_errorListeners.add(listener);
}
}
}
public void removeListener(int listenerType, LogListener listener) {
switch (listenerType) {
default :
case LogConstant.DEBUG_LISTENER :
{
m_debugListeners.remove(listener);
// Note: Falls through to VERBOSE...
}
case LogConstant.VERBOSE_LISTENER :
{
m_infoListeners.remove(listener);
// Note: Falls through to INFO...
}
case LogConstant.INFO_LISTENER :
{
m_infoListeners.remove(listener);
// Note: Falls through to WARN...
}
case LogConstant.WARN_LISTENER :
{
m_warnListeners.remove(listener);
// Note: Falls through to ERROR...
}
case LogConstant.ERROR_LISTENER :
{
m_errorListeners.remove(listener);
}
}
}
// DEBUG
public boolean isDebug() {
return !m_debugListeners.isEmpty();
}
public void debug(Object message) {
notify(m_debugListeners, LogConstant.DEBUG, message, null);
if (null != m_next)
m_next.debug(message);
}
public void debug(Object message, Throwable thrower) {
notify(m_debugListeners, LogConstant.DEBUG, message, thrower);
if (null != m_next)
m_next.debug(message, thrower);
}
// VERBOSE
public boolean isVerbose() {
return !m_verboseListeners.isEmpty();
}
public void verbose(Object message) {
notify(m_verboseListeners, LogConstant.VERBOSE, message, null);
if (null != m_next)
m_next.verbose(message);
}
public void verbose(Object message, Throwable thrower) {
notify(m_verboseListeners, LogConstant.VERBOSE, message, thrower);
if (null != m_next)
m_next.verbose(message, thrower);
}
// INFO
public void info(Object message) {
notify(m_infoListeners, LogConstant.INFO, message, null);
if (null != m_next)
m_next.info(message);
}
public void info(Object message, Throwable thrower) {
notify(m_infoListeners, LogConstant.INFO, message, thrower);
if (null != m_next)
m_next.info(message, thrower);
}
// WARN
public void warn(Object message) {
notify(m_warnListeners, LogConstant.WARN, message, null);
if (null != m_next)
m_next.warn(message);
}
public void warn(Object message, Throwable thrower) {
notify(m_warnListeners, LogConstant.WARN, message, thrower);
if (null != m_next)
m_next.warn(message, thrower);
}
// ERROR
public void error(Object message) {
notify(m_errorListeners, LogConstant.ERROR, message, null);
if (null != m_next)
m_next.error(message);
}
public void error(Object message, Throwable thrower) {
notify(m_errorListeners, LogConstant.ERROR, message, thrower);
if (null != m_next)
m_next.error(message, thrower);
}
private void notify(
List listeners,
int severity,
Object message,
Throwable thrower) {
for (Iterator i = listeners.iterator(); i.hasNext();) {
try {
((LogListener) i.next()).log(severity, message, thrower);
}
catch (Throwable t) {
// Their problems are not ours...
}
}
}
public static void testInit() {
DebugUtils.enableCommonsLogging();
getLog().addListener(
LogConstant.DEBUG_LISTENER,
new StandardLogListener());
}
}
--- NEW FILE: StandardLogListener.java ---
/*
* Created on Aug 28, 2003
*/
package org.krysalis.ruper2.log;
/**
* @author anou_mana
*/
public class StandardLogListener implements LogListener {
public void log(int severity, Object message, Throwable thrower) {
String severityStr = "UNKNOWN";
switch (severity) {
case LogConstant.DEBUG :
{
severityStr = "DEBUG ";
break;
}
case LogConstant.INFO :
{
severityStr = "INFO ";
break;
}
case LogConstant.VERBOSE :
{
severityStr = "VERBOSE";
break;
}
case LogConstant.WARN :
{
severityStr = "WARN ";
break;
}
case LogConstant.ERROR :
{
severityStr = "ERROR ";
break;
}
}
System.out.print(severityStr);
System.out.print(" : ");
System.out.println(message.toString());
if (null != thrower) {
System.out.println(
"Exception: "
+ thrower.getClass().getName()
+ " : "
+ thrower.getLocalizedMessage());
thrower.printStackTrace(System.out);
}
}
}
--- NEW FILE: LogConstant.java ---
/*
* Created on Aug 28, 2003
*/
package org.krysalis.ruper2.log;
/**
* @author anou_mana
*/
public class LogConstant
{
// Severities
public static final int ERROR = 1;
public static final int WARN = 2;
public static final int INFO = 3;
public static final int VERBOSE = 4;
public static final int DEBUG = 5;
// Listener Classes
public static final int ERROR_LISTENER = 1;
public static final int WARN_LISTENER = 2;
public static final int INFO_LISTENER = 3;
public static final int VERBOSE_LISTENER = 4;
public static final int DEBUG_LISTENER = 5;
}
-------------------------------------------------------
This sf.net email is sponsored by:ThinkGeek
Welcome to geek heaven.
http://thinkgeek.com/sf
lmpx.com only provides a reader for public news (NNTP) servers. It is not
affiliated with the servers or forums shown here and is not responsible for
the content of articles, which is written by their respective authors.