LoggerFactory can produce Loggers for various logging APIs,
+ * most notably for log4j, JDK 1.4 logging. Other implemenations such as
+ * {@link org.slf4j.impl.NOPLogger NOPLogger} and
+ * {@link org.slf4j.impl.DumbLogger DumbLogger} are also supported.
+ *
+ * @author Ceki Gülcü
+ */
+public class LoggerFactory {
+ static LoggerFactoryAdapter adapter;
+
+ //
+ // WARNING Modify the original in
+ // $SLF4J_HOME/src/filtered-java/org/apache/slf4j/
+
+ static {
+ String adapterClassStr = "org.slf4j.impl.@IMPL@LoggerFA";
+ System.out.println("SLF4J built for "+adapterClassStr);
+ try {
+ adapter = new org.slf4j.impl.@IMPL@LoggerFA();
+ } catch (Exception e) {
+ // unless there was a problem with the build or the JVM we will never
+ // get exceptions
+ System.err.println(
+ "Could not instantiate instance of class [" + adapterClassStr + "]");
+ e.printStackTrace();
+ }
+ }
+
+ public static ULogger getLogger(String name) {
+ return adapter.getLogger(name);
+ }
+
+ public static ULogger getLogger(String domainName, String subDomainName) {
+ return adapter.getLogger(domainName, subDomainName);
+ }
+
+ public static ULogger getLogger(Class clazz) {
+ return adapter.getLogger(clazz.getName());
+ }
+
+ public static ULogger getLogger(Class clazz, String subDomainName) {
+ return adapter.getLogger(clazz.getName(), subDomainName);
+ }
+}
diff --git a/src/filtered-java/org/slf4j/LoggerFactoryAdapter.java b/src/filtered-java/org/slf4j/LoggerFactoryAdapter.java
new file mode 100644
index 00000000..143e7bfb
--- /dev/null
+++ b/src/filtered-java/org/slf4j/LoggerFactoryAdapter.java
@@ -0,0 +1,28 @@
+package org.slf4j;
+
+/**
+ * LoggerFactoryAdapter interface is used internally by {@link
+ * LoggerFactory}.
+ *
+ * Only developers wishing to write new UGLI adapters need to worry
+ * about this interface.
+ *
+ * @author Ceki Gülcü
+ *
+ */
+public interface LoggerFactoryAdapter {
+
+ /**
+ * Return the appropriate named {@link ULogger} instance.
+ */
+ public ULogger getLogger(String name);
+
+ /**
+ * Return a {@link ULogger} instance in domain, subDomain.
+ *
+ * @param domain
+ * @param subDomain
+ * @return ULogger instance
+ */
+ public ULogger getLogger(String domain, String subDomain);
+}
diff --git a/src/filtered-java/org/slf4j/ULogger.java b/src/filtered-java/org/slf4j/ULogger.java
new file mode 100644
index 00000000..b43af3c9
--- /dev/null
+++ b/src/filtered-java/org/slf4j/ULogger.java
@@ -0,0 +1,72 @@
+package org.slf4j;
+
+
+/**
+ *
+ * The main user inteface to logging. It is expected that logging
+ * takes places through concerete implemetations of the ULogger
+ * interface.
+ *
+ * @author Ceki Gülcü
+ */
+public interface ULogger {
+
+ /**
+ * Is the logger instance enabled for the DEBUG level?
+ * @return
+ */
+ public boolean isDebugEnabled();
+
+ /**
+ * Log a message object with the DEBUG level.
+ * @param msg - the message object to be logged
+ */
+ public void debug(Object msg);
+
+
+ /**
+ * Log a parameterized message object at the DEBUG level.
+ *
+ *
This form is useful in avoiding the superflous object creation + * problem when invoking this method while it is disabled. + *
+ * @param parameterizedMsg - the parameterized message object + * @param param1 - the parameter + */ + public void debug(Object parameterizedMsg, Object param1); + + /** + * Log a parameterized message object at the DEBUG level. + * + *This form is useful in avoiding the superflous object creation + * problem when invoking this method while it is disabled. + *
+ * @param parameterizedMsg - the parameterized message object + * @param param1 - the first parameter + * @param param2 - the second parameter + */ + public void debug(String parameterizedMsg, Object param1, Object param2); + public void debug(Object msg, Throwable t); + + + public boolean isInfoEnabled(); + public void info(Object msg); + public void info(Object parameterizedMsg, Object param1); + public void info(String parameterizedMsg, Object param1, Object param2); + public void info(Object msg, Throwable t); + + + public boolean isWarnEnabled(); + public void warn(Object msg); + public void warn(Object parameterizedMsg, Object param1); + public void warn(String parameterizedMsg, Object param1, Object param2); + public void warn(Object msg, Throwable t); + + + public boolean isErrorEnabled(); + public void error(Object msg); + public void error(Object parameterizedMsg, Object param1); + public void error(String parameterizedMsg, Object param1, Object param2); + public void error(Object msg, Throwable t); + +} diff --git a/src/filtered-java/org/slf4j/impl/JDK14Logger.java b/src/filtered-java/org/slf4j/impl/JDK14Logger.java new file mode 100644 index 00000000..82af79d9 --- /dev/null +++ b/src/filtered-java/org/slf4j/impl/JDK14Logger.java @@ -0,0 +1,212 @@ +package org.slf4j.impl; + + +import org.slf4j.ULogger; + +import java.util.logging.Level; +import java.util.logging.Logger; + + +/** + * A wrapper over @{link java.utill.Logger} which conforms to the + * {@link ULogger} interface. + * + * @author Ceki Gülcü + */ +public class JDK14Logger implements ULogger { + final Logger logger; + + // WARN: JDK14Logger constructor should have only package access so that + // only JDK14LoggerFA be able to create one. + JDK14Logger(Logger logger) { + this.logger = logger; + } + + /** + * Is the logger instance enabled for the DEBUG level? + * @return + */ + public boolean isDebugEnabled() { + return logger.isLoggable(Level.FINE); + } + + // + + /** + * Log a message object with the DEBUG level. + * @param msg - the message object to be logged + */ + public void debug(Object msg) { + logger.fine(String.valueOf(msg)); + } + + /** + * Log a parameterized message object at the DEBUG level. + * + *This form is useful in avoiding the superflous object creation + * problem when invoking this method while it is disabled. + *
+ * @param parameterizedMsg - the parameterized message object + * @param param1 - the parameter + */ + public void debug(Object parameterizedMsg, Object param1) { + if (logger.isLoggable(Level.FINE)) { + if (parameterizedMsg instanceof String) { + String msgStr = (String) parameterizedMsg; + msgStr = MessageFormatter.format(msgStr, param1); + logger.fine(msgStr); + } else { + // To be failsafe, we handle the case where 'messagePattern' is not + // a String. Unless the user makes a mistake, this should not happen. + logger.fine(parameterizedMsg.toString()); + } + } + } + + /** + * Log a parameterized message object at the DEBUG level. + * + *This form is useful in avoiding the superflous object creation + * problem when invoking this method while it is disabled. + *
+ * @param parameterizedMsg - the parameterized message object + * @param param1 - the first parameter + * @param param2 - the second parameter + */ + public void debug(String parameterizedMsg, Object param1, Object param2) { + if (logger.isLoggable(Level.FINE)) { + if (parameterizedMsg instanceof String) { + String msgStr = (String) parameterizedMsg; + msgStr = MessageFormatter.format(msgStr, param1, param2); + logger.fine(msgStr); + } else { + // To be failsafe, we handle the case where 'messagePattern' is not + // a String. Unless the user makes a mistake, this should not happen. + logger.fine(parameterizedMsg.toString()); + } + } + } + + public void debug(Object msg, Throwable t) { + logger.log(Level.FINE, msg.toString(), t); + } + + public boolean isInfoEnabled() { + return logger.isLoggable(Level.INFO); + } + + public void info(Object msg) { + logger.info(msg.toString()); + } + + public void info(Object parameterizedMsg, Object param1) { + if (logger.isLoggable(Level.INFO)) { + if (parameterizedMsg instanceof String) { + String msgStr = (String) parameterizedMsg; + msgStr = MessageFormatter.format(msgStr, param1); + logger.info(msgStr); + } else { + // To be failsafe, we handle the case where 'messagePattern' is not + // a String. Unless the user makes a mistake, this should not happen. + logger.info(parameterizedMsg.toString()); + } + } + } + + public void info(String parameterizedMsg, Object param1, Object param2) { + if (logger.isLoggable(Level.INFO)) { + if (parameterizedMsg instanceof String) { + String msgStr = (String) parameterizedMsg; + msgStr = MessageFormatter.format(msgStr, param1, param2); + logger.info(msgStr); + } else { + // To be failsafe, we handle the case where 'messagePattern' is not + // a String. Unless the user makes a mistake, this should not happen. + logger.info(parameterizedMsg.toString()); + } + } + } + + public void info(Object msg, Throwable t) { + logger.log(Level.INFO, msg.toString(), t); + } + + public boolean isWarnEnabled() { + return logger.isLoggable(Level.WARNING); + } + + public void warn(Object msg) { + logger.warning(msg.toString()); + } + + public void warn(Object parameterizedMsg, Object param1) { + if (logger.isLoggable(Level.WARNING)) { + if (parameterizedMsg instanceof String) { + String msgStr = (String) parameterizedMsg; + msgStr = MessageFormatter.format(msgStr, param1); + logger.warning(msgStr); + } else { + // To be failsafe, we handle the case where 'messagePattern' is not + // a String. Unless the user makes a mistake, this should not happen. + logger.warning(parameterizedMsg.toString()); + } + } + } + + public void warn(String parameterizedMsg, Object param1, Object param2) { + if (logger.isLoggable(Level.WARNING)) { + if (parameterizedMsg instanceof String) { + String msgStr = (String) parameterizedMsg; + msgStr = MessageFormatter.format(msgStr, param1, param2); + logger.warning(msgStr); + } else { + // To be failsafe, we handle the case where 'messagePattern' is not + // a String. Unless the user makes a mistake, this should not happen. + logger.warning(parameterizedMsg.toString()); + } + } + } + + public void warn(Object msg, Throwable t) { + logger.log(Level.WARNING, msg.toString(), t); + } + + public boolean isErrorEnabled() { + return logger.isLoggable(Level.SEVERE); + } + + public void error(Object msg) { + logger.severe(msg.toString()); + } + + public void error(Object parameterizedMsg, Object param1) { + if (logger.isLoggable(Level.WARNING)) { + if (parameterizedMsg instanceof String) { + String msgStr = (String) parameterizedMsg; + msgStr = MessageFormatter.format(msgStr, param1); + logger.severe(msgStr); + } else { + // To be failsafe, we handle the case where 'messagePattern' is not + // a String. Unless the user makes a mistake, this should not happen. + logger.severe(parameterizedMsg.toString()); + } + } + } + + public void error(String parameterizedMsg, Object param1, Object param2) { + if (logger.isLoggable(Level.WARNING)) { + if (parameterizedMsg instanceof String) { + String msgStr = (String) parameterizedMsg; + msgStr = MessageFormatter.format(msgStr, param1, param2); + logger.severe(msgStr); + } else { + // To be failsafe, we handle the case where 'messagePattern' is not + // a String. Unless the user makes a mistake, this should not happen. + logger.severe(parameterizedMsg.toString()); + } + } + } + public void error(Object msg, Throwable t) { + logger.log(Level.SEVERE, msg.toString(), t); + } +} diff --git a/src/filtered-java/org/slf4j/impl/JDK14LoggerFA.java b/src/filtered-java/org/slf4j/impl/JDK14LoggerFA.java new file mode 100644 index 00000000..e64e83c2 --- /dev/null +++ b/src/filtered-java/org/slf4j/impl/JDK14LoggerFA.java @@ -0,0 +1,41 @@ +package org.slf4j.impl; + +import org.slf4j.LoggerFactoryAdapter; +import org.slf4j.ULogger; + +import java.util.HashMap; +import java.util.Map; +import java.util.logging.Logger; + + +/** + * + * @author Ceki Gülcü + */ +public class JDK14LoggerFA implements LoggerFactoryAdapter { + Map map; + + public JDK14LoggerFA() { + map = new HashMap(); + } + + /* (non-Javadoc) + * @see org.slf4j.LoggerFactoryAdapter#getLogger(java.lang.String) + */ + public ULogger getLogger(String name) { + ULogger ulogger = (ULogger) map.get(name); + if (ulogger == null) { + Logger logger = Logger.getLogger(name); + ulogger = new JDK14Logger(logger); + map.put(name, ulogger); + } + return ulogger; + } + + /* (non-Javadoc) + * @see org.slf4j.LoggerFactoryAdapter#getLogger(java.lang.String, java.lang.String) + */ + public ULogger getLogger(String domainName, String subDomainName) { + return getLogger(domainName); + } +} diff --git a/src/filtered-java/org/slf4j/impl/MessageFormatter.java b/src/filtered-java/org/slf4j/impl/MessageFormatter.java new file mode 100644 index 00000000..6248d93f --- /dev/null +++ b/src/filtered-java/org/slf4j/impl/MessageFormatter.java @@ -0,0 +1,110 @@ +package org.slf4j.impl; + + +/** + * Formats messages according to very simple rules. + * See {@link #format(String, Object)} and + * {@link #format(String, Object, Object)} for more details. + * + * @author Ceki Gülcü + */ +public class MessageFormatter { + static final char DELIM_START = '{'; + static final char DELIM_STOP = '}'; + + /** + * Performs single argument substitution for the 'messagePattern' passed as + * parameter. + *
+ * For example, MessageFormatter.format("Hi {}.", "there"); will
+ * return the string "Hi there.".
+ *
+ * The {} pair is called the formatting element. It serves to designate the + * location where the argument needs to be inserted within the pattern. + * + * @param messagePattern The message pattern which will be parsed and formatted + * @param argument The argument to be inserted instead of the formatting element + * @return The formatted message + */ + public static String format(String messagePattern, Object argument) { + int j = messagePattern.indexOf(DELIM_START); + int len = messagePattern.length(); + char escape = 'x'; + + // if there are no { characters or { is the last character of the messsage + // then we just return messagePattern + if (j == -1 || (j+1 == len)) { + return messagePattern; + } else { + if(j+1 == len) { + } + + char delimStop = messagePattern.charAt(j + 1); + if (j > 0) { + escape = messagePattern.charAt(j - 1); + } + if ((delimStop != DELIM_STOP) || (escape == '\\')) { + // invalid DELIM_START/DELIM_STOP pair or espace character is + // present + return messagePattern; + } else { + StringBuffer sbuf = new StringBuffer(len + 20); + sbuf.append(messagePattern.substring(0, j)); + sbuf.append(argument); + sbuf.append(messagePattern.substring(j + 2)); + return sbuf.toString(); + } + } + } + + /** + * /** + * Performs a two argument substitution for the 'messagePattern' passed as + * parameter. + *
+ * For example, MessageFormatter.format("Hi {}. My name is {}.",
+ * "there", "David"); will return the string "Hi there. My name is David.".
+ *
+ * The '{}' pair is called a formatting element. It serves to designate the
+ * location where the arguments need to be inserted within the message pattern.
+ *
+ * @param messagePattern The message pattern which will be parsed and formatted
+ * @param arg1 The first argument to replace the first formatting element
+ * @param arg2 The second argument to replace the second formatting element
+ * @return The formatted message
+ */
+ public static String format(String messagePattern, Object arg1, Object arg2) {
+ int i = 0;
+ int len = messagePattern.length();
+ int j = messagePattern.indexOf(DELIM_START);
+
+ StringBuffer sbuf = new StringBuffer(messagePattern.length() + 50);
+
+ for (int L = 0; L < 2; L++) {
+ j = messagePattern.indexOf(DELIM_START, i);
+
+ if (j == -1 || (j+1 == len)) {
+ // no more variables
+ if (i == 0) { // this is a simple string
+ return messagePattern;
+ } else { // add the tail string which contains no variables and return the result.
+ sbuf.append(messagePattern.substring(i, messagePattern.length()));
+ return sbuf.toString();
+ }
+ } else {
+ char delimStop = messagePattern.charAt(j + 1);
+ if ((delimStop != DELIM_STOP)) {
+ // invalid DELIM_START/DELIM_STOP pair
+ sbuf.append(messagePattern.substring(i, messagePattern.length()));
+ return sbuf.toString();
+ }
+ sbuf.append(messagePattern.substring(i, j));
+ sbuf.append((L == 0) ? arg1 : arg2);
+ i = j + 2;
+ }
+ }
+ // append the characters following the second {} pair.
+ sbuf.append(messagePattern.substring(i, messagePattern.length()));
+ return sbuf.toString();
+ }
+}
diff --git a/src/filtered-java/org/slf4j/impl/NOPLogger.java b/src/filtered-java/org/slf4j/impl/NOPLogger.java
new file mode 100644
index 00000000..399802ae
--- /dev/null
+++ b/src/filtered-java/org/slf4j/impl/NOPLogger.java
@@ -0,0 +1,167 @@
+package org.slf4j.impl;
+
+import org.slf4j.ULogger;
+
+
+/**
+ * A no operation (NOP) implementation of {@link ULogger}.
+ *
+ * @author Ceki Gülcü
+ */
+public class NOPLogger implements ULogger {
+
+ /**
+ * The unique instance of NOPLogger.
+ */
+ public final static NOPLogger NOP_LOGGER = new NOPLogger();
+
+ /**
+ * There is no point in people creating multiple instances of NullLogger.
+ * Hence, the private access modifier.
+ */
+ private NOPLogger() {
+ }
+
+ /* Always returns false.
+ *
+ * @see org.slf4j.Logger#isDebugEnabled()
+ */
+ public boolean isDebugEnabled() {
+ return false;
+ }
+
+ /* A NOP implementation.
+ * @see org.slf4j.Logger#debug(java.lang.Object)
+ */
+ public void debug(Object msg) {
+ // NOP
+ }
+
+ /* A NOP implementation.
+ * @see org.slf4j.Logger#debug(java.lang.Object, java.lang.Object)
+ */
+ public void debug(Object parameterizedMsg, Object param1) {
+ // NOP
+ }
+
+ /* A NOP implementation.
+ * @see org.slf4j.Logger#debug(java.lang.Object, java.lang.Object, java.lang.Object)
+ */
+ public void debug(String parameterizedMsg, Object param1, Object param2) {
+ // NOP
+ }
+
+ /* A NOP implementation.
+ * @see org.slf4j.Logger#debug(java.lang.Object, java.lang.Throwable)
+ */
+ public void debug(Object msg, Throwable t) {
+ // NOP
+ }
+
+ /* Always returns false.
+ * @see org.slf4j.Logger#isInfoEnabled()
+ */
+ public boolean isInfoEnabled() {
+ // NOP
+ return false;
+ }
+
+ /* A NOP implementation.
+ * @see org.slf4j.Logger#info(java.lang.Object)
+ */
+ public void info(Object msg) {
+ // NOP
+ }
+
+ /* A NOP implementation.
+ * @see org.slf4j.Logger#info(java.lang.Object, java.lang.Object)
+ */
+ public void info(Object parameterizedMsg, Object param1) {
+ // NOP
+ }
+
+ /* A NOP implementation.
+ * @see org.slf4j.Logger#info(java.lang.Object, java.lang.Object, java.lang.Object)
+ */
+ public void info(String parameterizedMsg, Object param1, Object param2) {
+ // NOP
+ }
+
+ /* A NOP implementation.
+ * @see org.slf4j.Logger#info(java.lang.Object, java.lang.Throwable)
+ */
+ public void info(Object msg, Throwable t) {
+ // NOP
+ }
+
+ /* Always returns false.
+ * @see org.slf4j.Logger#isWarnEnabled()
+ */
+ public boolean isWarnEnabled() {
+ return false;
+ }
+
+ /* A NOP implementation.
+ * @see org.slf4j.Logger#warn(java.lang.Object)
+ */
+ public void warn(Object msg) {
+ // NOP
+ }
+
+ /* A NOP implementation.
+ * @see org.slf4j.Logger#warn(java.lang.Object, java.lang.Object)
+ */
+ public void warn(Object parameterizedMsg, Object param1) {
+ // NOP
+ }
+
+ /* A NOP implementation.
+ * @see org.slf4j.Logger#warn(java.lang.Object, java.lang.Object, java.lang.Object)
+ */
+ public void warn(String parameterizedMsg, Object param1, Object param2) {
+ // NOP
+ }
+
+ /* A NOP implementation.
+ * @see org.slf4j.Logger#warn(java.lang.Object, java.lang.Throwable)
+ */
+ public void warn(Object msg, Throwable t) {
+ // NOP
+ }
+
+ /* Always returns false.
+ * @see org.slf4j.Logger#isErrorEnabled()
+ */
+ public boolean isErrorEnabled() {
+ return false;
+ }
+
+ /* A NOP implementation.
+ * @see org.slf4j.Logger#error(java.lang.Object)
+ */
+ public void error(Object msg) {
+ // NOP
+ }
+
+ /* A NOP implementation.
+ * @see org.slf4j.Logger#error(java.lang.Object, java.lang.Object)
+ */
+ public void error(Object parameterizedMsg, Object param1) {
+ // NOP
+ }
+
+ /* A NOP implementation.
+ * @see org.slf4j.Logger#error(java.lang.Object, java.lang.Object, java.lang.Object)
+ */
+ public void error(String parameterizedMsg, Object param1, Object param2) {
+ // NOP
+ }
+
+ /* A NOP implementation.
+ * @see org.slf4j.Logger#error(java.lang.Object, java.lang.Throwable)
+ */
+ public void error(Object msg, Throwable t) {
+ // NOP
+ }
+
+}
diff --git a/src/filtered-java/org/slf4j/impl/NOPLoggerFA.java b/src/filtered-java/org/slf4j/impl/NOPLoggerFA.java
new file mode 100644
index 00000000..c9f9eb7a
--- /dev/null
+++ b/src/filtered-java/org/slf4j/impl/NOPLoggerFA.java
@@ -0,0 +1,25 @@
+package org.slf4j.impl;
+
+import org.slf4j.LoggerFactoryAdapter;
+import org.slf4j.ULogger;
+
+
+/**
+ * NOPLoggerFA is am implementation of {@link LoggerFactoryAdapter}
+ * which always returns the unique instance of NOPLogger.
+ *
+ * @author Ceki Gulcu
+ */
+public class NOPLoggerFA implements LoggerFactoryAdapter {
+
+ public NOPLoggerFA() {
+ // nothing to do
+ }
+
+ public ULogger getLogger(String name) {
+ return NOPLogger.NOP_LOGGER;
+ }
+ public ULogger getLogger(String domainName, String subDomainName) {
+ return NOPLogger.NOP_LOGGER;
+ }
+}
diff --git a/src/filtered-java/org/slf4j/impl/SimpleLogger.java b/src/filtered-java/org/slf4j/impl/SimpleLogger.java
new file mode 100644
index 00000000..f1cef03b
--- /dev/null
+++ b/src/filtered-java/org/slf4j/impl/SimpleLogger.java
@@ -0,0 +1,257 @@
+package org.slf4j.impl;
+
+import org.slf4j.ULogger;
+
+
+/**
+ * A simple implementation that logs messages of level INFO or higher on
+ * the console (
+ * The output includes the relative time in milliseconds, thread name, the level,
+ * logger name, and the message followed by the line separator for the host.
+ * In log4j terms it amounts to the "%r [%t] %level %logger - %m%n" pattern.
+ * System.out).
+ *
+176 [main] INFO examples.Sort - Populating an array of 2 elements in reverse order.
+225 [main] INFO examples.SortAlgo - Entered the sort method.
+304 [main] INFO SortAlgo.DUMP - Dump of interger array:
+317 [main] INFO SortAlgo.DUMP - Element [0] = 0
+331 [main] INFO SortAlgo.DUMP - Element [1] = 1
+343 [main] INFO examples.Sort - The next log statement should be an error message.
+346 [main] ERROR SortAlgo.DUMP - Tried to dump an uninitialized array.
+ at org.log4j.examples.SortAlgo.dump(SortAlgo.java:58)
+ at org.log4j.examples.Sort.main(Sort.java:64)
+467 [main] INFO examples.Sort - Exiting main method.
+
+ *
+ * @author Ceki Gülcü
+ */
+public class SimpleLogger implements ULogger {
+
+ String loggerName;
+
+ /**
+ * Mark the time when this class gets loaded into memory.
+ */
+ static private long startTime = System.currentTimeMillis();
+
+ public static final String LINE_SEPARATOR = System.getProperty("line.separator");
+
+ static private String INFO_STR = "INFO";
+ static private String WARN_STR = "WARN";
+ static private String ERROR_STR = "ERROR";
+
+ /**
+ * Package access allows only {@link SimpleLoggerFA} to instantiate
+ * SimpleLogger instances.
+ */
+ SimpleLogger(String name) {
+ this.loggerName = name;
+ }
+
+ /**
+ * Always returns false.
+ */
+ public boolean isDebugEnabled() {
+ return false;
+ }
+
+ /**
+ * A NOP implementation.
+ */
+ public void debug(Object msg) {
+ // NOP
+ }
+
+ /**
+ * A NOP implementation.
+ */
+ public void debug(Object parameterizedMsg, Object param1) {
+ // NOP
+ }
+
+ /**
+ * A NOP implementation.
+ */
+ public void debug(String parameterizedMsg, Object param1, Object param2) {
+ // NOP
+ }
+
+ /**
+ * A NOP implementation.
+ */
+ public void debug(Object msg, Throwable t) {
+ // NOP
+ }
+
+ /**
+ * This is our internal implementation for logging regular (non-parameterized)
+ * log messages.
+ *
+ * @param level
+ * @param message
+ * @param t
+ */
+ private void log(String level, String message, Throwable t) {
+ StringBuffer buf = new StringBuffer();
+
+ long millis = System.currentTimeMillis();
+ buf.append(millis-startTime);
+
+ buf.append(" [");
+ buf.append(Thread.currentThread().getName());
+ buf.append("] ");
+
+ buf.append(level);
+ buf.append(" ");
+
+ buf.append(loggerName);
+ buf.append(" - ");
+
+ buf.append(message);
+
+ buf.append(LINE_SEPARATOR);
+
+ System.out.print(buf.toString());
+ if(t != null) {
+ t.printStackTrace(System.out);
+ }
+ System.out.flush();
+ }
+ /**
+ * For parameterized messages, first substitute parameters and then log.
+ *
+ * @param level
+ * @param parameterizedMsg
+ * @param param1
+ * @param param2
+ */
+ private void parameterizedLog(String level, Object parameterizedMsg, Object param1, Object param2) {
+ if (parameterizedMsg instanceof String) {
+ String msgStr = (String) parameterizedMsg;
+ msgStr = MessageFormatter.format(msgStr, param1, param2);
+ log(level, msgStr, null);
+ } else {
+ // To be failsafe, we handle the case where 'messagePattern' is not
+ // a String. Unless the user makes a mistake, this should not happen.
+ log(level, parameterizedMsg.toString(), null);
+ }
+ }
+
+ /**
+ * Always returns true.
+ */
+ public boolean isInfoEnabled() {
+ return true;
+ }
+
+ /**
+ * A simple implementation which always logs messages of level INFO according
+ * to the format outlined above.
+ */
+ public void info(Object msg) {
+ log(INFO_STR, msg.toString(), null);
+ }
+
+
+ /**
+ * Perform single parameter substituion before logging the message of level
+ * INFO according to the format outlined above.
+ */
+ public void info(Object parameterizedMsg, Object param1) {
+ parameterizedLog(INFO_STR, parameterizedMsg, param1, null);
+ }
+
+ /**
+ * Perform double parameter substituion before logging the message of level
+ * INFO according to the format outlined above.
+ */
+
+ public void info(String parameterizedMsg, Object param1, Object param2) {
+ parameterizedLog(INFO_STR, parameterizedMsg, param1, param2);
+ }
+
+ /**
+ * Log a message of level INFO, including an exception.
+ */
+ public void info(Object msg, Throwable t) {
+ log(INFO_STR, msg.toString(), t);
+ }
+
+ /**
+ * Always returns true.
+ */
+ public boolean isWarnEnabled() {
+ return true;
+ }
+
+ /**
+ * A simple implementation which always logs messages of level WARN according
+ * to the format outlined above.
+ */
+ public void warn(Object msg) {
+ log(WARN_STR, msg.toString(), null);
+ }
+
+ /**
+ * Perform single parameter substituion before logging the message of level
+ * WARN according to the format outlined above.
+ */
+ public void warn(Object parameterizedMsg, Object param1) {
+ parameterizedLog(WARN_STR, parameterizedMsg, param1, null);
+ }
+
+ /**
+ * Perform double parameter substituion before logging the message of level
+ * WARN according to the format outlined above.
+ */
+ public void warn(String parameterizedMsg, Object param1, Object param2) {
+ parameterizedLog(WARN_STR, parameterizedMsg, param1, param2);
+ }
+
+ /**
+ * Log a message of level WARN, including an exception.
+ */
+ public void warn(Object msg, Throwable t) {
+ log(WARN_STR, msg.toString(), t);
+ }
+
+ /**
+ * Always returns true.
+ */
+ public boolean isErrorEnabled() {
+ return true;
+ }
+
+ /**
+ * A simple implementation which always logs messages of level ERROR acoording
+ * to the format outlined above.
+ */
+ public void error(Object msg) {
+ log(ERROR_STR, msg.toString(), null);
+ }
+
+
+ /**
+ * Perform single parameter substituion before logging the message of level
+ * ERROR according to the format outlined above.
+ */
+ public void error(Object parameterizedMsg, Object param1) {
+ parameterizedLog(ERROR_STR, parameterizedMsg, param1, null);
+ }
+
+ /**
+ * Perform double parameter substituion before logging the message of level
+ * ERROR according to the format outlined above.
+ */
+ public void error(String parameterizedMsg, Object param1, Object param2) {
+ parameterizedLog(ERROR_STR, parameterizedMsg, param1, param2);
+ }
+
+ /**
+ * Log a message of level ERROR, including an exception.
+ */
+ public void error(Object msg, Throwable t) {
+ log(ERROR_STR, msg.toString(), t);
+ }
+
+}
diff --git a/src/filtered-java/org/slf4j/impl/SimpleLoggerFA.java b/src/filtered-java/org/slf4j/impl/SimpleLoggerFA.java
new file mode 100644
index 00000000..796da7f9
--- /dev/null
+++ b/src/filtered-java/org/slf4j/impl/SimpleLoggerFA.java
@@ -0,0 +1,50 @@
+package org.slf4j.impl;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import org.slf4j.LoggerFactoryAdapter;
+import org.slf4j.ULogger;
+
+
+/**
+ * An implementation of {@link LoggerFactoryAdapter} which always returns
+ * {@link SimpleLogger} instances.
+ *
+ * @author Ceki Gülcü
+ */
+public class SimpleLoggerFA implements LoggerFactoryAdapter {
+
+ Map map;
+
+ public SimpleLoggerFA() {
+ map = new HashMap();
+ }
+
+
+ /**
+ * Return an appropriate {@link SimpleLogger} instance by name. At this time,
+ *
+ */
+ /**
+ * Return an appropriate {@link SimpleLogger} instance.
+ * */
+ public ULogger getLogger(String name) {
+ ULogger ulogger = (ULogger) map.get(name);
+ if(ulogger == null) {
+ ulogger = new SimpleLogger(name);
+ map.put(name, ulogger);
+ }
+ return ulogger;
+ }
+
+ /*
+ * (non-Javadoc)
+ * @see org.slf4j.LoggerFactoryAdapter#getLogger(java.lang.String, java.lang.String)
+ */
+ public ULogger getLogger(String domainName, String subDomainName) {
+ return getLogger(domainName);
+ }
+
+
+}